Adjust PoW policy defaults (finalize 16/15/14 mapping)

* Screenshot privacy: warn on location sheet; gate screenshot broadcasts to chat only\n\n- Track sheet presentation in ChatViewModel\n- Show privacy alert when screenshot taken on location channels\n- Ignore screenshots for App Info and Location sheet for broadcast\n- ContentView wires sheet onAppear/onDisappear and presents alert\n- Fix location sheet subtitle wrapping: render as single Text to avoid orphaned bullets

* Fix duplicate messages after channel switch\n\n- Dedup on per-geohash append (skip if ID exists)\n- Dedup and sort timeline by timestamp when switching into a geohash\n- Keep content/layout unchanged; add lightweight debug logs for empty rows

---------

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

README.md

@@ -2,7 +2,7 @@
 
 ## bitchat
 
-A decentralized peer-to-peer messaging app that works over Bluetooth mesh networks. No internet required, no servers, no phone numbers. It's the side-groupchat. 
+A decentralized peer-to-peer messaging app with dual transport architecture: local Bluetooth mesh networks for offline communication and internet-based Nostr protocol for global reach. No accounts, no phone numbers, no central servers. It's the side-groupchat.
 
 [bitchat.free](http://bitchat.free)
 
@@ -11,50 +11,99 @@ A decentralized peer-to-peer messaging app that works over Bluetooth mesh networ
 > [!WARNING]
 > Private messages have not received external security review and may contain vulnerabilities. Do not use for sensitive use cases, and do not rely on its security until it has been reviewed. Now uses the [Noise Protocol](http://www.noiseprotocol.org) for identity and encryption. Public local chat (the main feature) has no security concerns.
 
-
 ## License
 
 This project is released into the public domain. See the [LICENSE](LICENSE) file for details.
 
-
 ## Features
 
+- **Dual Transport Architecture**: Bluetooth mesh for offline + Nostr protocol for internet-based messaging
+- **Location-Based Channels**: Geographic chat rooms using geohash coordinates over global Nostr relays
+- **Intelligent Message Routing**: Automatically chooses best transport (Bluetooth → Nostr fallback)
 - **Decentralized Mesh Network**: Automatic peer discovery and multi-hop message relay over Bluetooth LE
 - **Privacy First**: No accounts, no phone numbers, no persistent identifiers
-- **Private Message End-to-End Encryption**: [Noise Protocol](http://noiseprotocol.org)
+- **Private Message End-to-End Encryption**: [Noise Protocol](http://noiseprotocol.org) for mesh, NIP-17 for Nostr
 - **IRC-Style Commands**: Familiar `/slap`, `/msg`, `/who` style interface
 - **Universal App**: Native support for iOS and macOS
 - **Emergency Wipe**: Triple-tap to instantly clear all data
 - **Performance Optimizations**: LZ4 message compression, adaptive battery modes, and optimized networking
 
-
 ## [Technical Architecture](https://deepwiki.com/permissionlesstech/bitchat)
 
-### Binary Protocol
+BitChat uses a **hybrid messaging architecture** with two complementary transport layers:
-bitchat uses an efficient binary protocol optimized for Bluetooth LE:
-- Compact packet format with 1-byte type field
-- TTL-based message routing (max 7 hops)
-- Automatic fragmentation for large messages
-- Message deduplication via unique IDs
 
-### Mesh Networking
+### Bluetooth Mesh Network (Offline)
-- Each device acts as both client and peripheral
+
-- Automatic peer discovery and connection management
+- **Local Communication**: Direct peer-to-peer within Bluetooth range
-- Adaptive duty cycling for battery optimization
+- **Multi-hop Relay**: Messages route through nearby devices (max 7 hops)
+- **No Internet Required**: Works completely offline in disaster scenarios
+- **Noise Protocol Encryption**: End-to-end encryption with forward secrecy
+- **Binary Protocol**: Compact packet format optimized for Bluetooth LE constraints
+- **Automatic Discovery**: Peer discovery and connection management
+- **Adaptive Power**: Battery-optimized duty cycling
+
+### Nostr Protocol (Internet)
+
+- **Global Reach**: Connect with users worldwide via internet relays
+- **Location Channels**: Geographic chat rooms using geohash coordinates
+- **290+ Relay Network**: Distributed across the globe for reliability
+- **NIP-17 Encryption**: Gift-wrapped private messages for internet privacy
+- **Ephemeral Keys**: Fresh cryptographic identity per geohash area
+
+### Channel Types
+
+#### `mesh #bluetooth`
+
+- **Transport**: Bluetooth Low Energy mesh network
+- **Scope**: Local devices within multi-hop range
+- **Internet**: Not required
+- **Use Case**: Offline communication, protests, disasters, remote areas
+
+#### Location Channels (`block #dr5rsj7`, `neighborhood #dr5rs`, `country #dr`)
+
+- **Transport**: Nostr protocol over internet
+- **Scope**: Geographic areas defined by geohash precision
+  - `block` (7 chars): City block level
+  - `neighborhood` (6 chars): District/neighborhood
+  - `city` (5 chars): City level
+  - `province` (4 chars): State/province
+  - `region` (2 chars): Country/large region
+- **Internet**: Required (connects to Nostr relays)
+- **Use Case**: Location-based community chat, local events, regional discussions
+
+### Direct Message Routing
+
+Private messages use **intelligent transport selection**:
+
+1. **Bluetooth First** (preferred when available)
+
+   - Direct connection with established Noise session
+   - Fastest and most private option
+
+2. **Nostr Fallback** (when Bluetooth unavailable)
+
+   - Uses recipient's Nostr public key
+   - NIP-17 gift-wrapping for privacy
+   - Routes through global relay network
+
+3. **Smart Queuing** (when neither available)
+   - Messages queued until transport becomes available
+   - Automatic delivery when connection established
 
 For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.md).
 
-
 ## Setup
 
 ### Option 1: Using XcodeGen (Recommended)
 
 1. Install XcodeGen if you haven't already:
+
    ```bash
    brew install xcodegen
    ```
 
 2. Generate the Xcode project:
+
    ```bash
    cd bitchat
    xcodegen generate
@@ -68,6 +117,7 @@ For detailed protocol documentation, see the [Technical Whitepaper](WHITEPAPER.m
 ### Option 2: Using Swift Package Manager
 
 1. Open the project in Xcode:
+
    ```bash
    cd bitchat
    open Package.swift

bitchat.xcodeproj/project.pbxproj

@@ -7,6 +7,14 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		04657AB52E633C6A002D5BBE /* NostrPoW.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657AB42E633C6A002D5BBE /* NostrPoW.swift */; };
+		04657AB62E633C6A002D5BBE /* NostrPoW.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657AB42E633C6A002D5BBE /* NostrPoW.swift */; };
+		04657AB82E633C76002D5BBE /* PowPolicy.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657AB72E633C76002D5BBE /* PowPolicy.swift */; };
+		04657AB92E633C76002D5BBE /* PowPolicy.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657AB72E633C76002D5BBE /* PowPolicy.swift */; };
+		04657ABB2E633C94002D5BBE /* MiningAnimation.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657ABA2E633C94002D5BBE /* MiningAnimation.swift */; };
+		04657ABC2E633C94002D5BBE /* MiningAnimation.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657ABA2E633C94002D5BBE /* MiningAnimation.swift */; };
+		04657ABE2E633CA4002D5BBE /* NostrPoWTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657ABD2E633CA4002D5BBE /* NostrPoWTests.swift */; };
+		04657ABF2E633CA4002D5BBE /* NostrPoWTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 04657ABD2E633CA4002D5BBE /* NostrPoWTests.swift */; };
 		047502802E53A0FC0083520F /* FragmentationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0475027E2E53A0FC0083520F /* FragmentationTests.swift */; };
 		047502812E53A0FC0083520F /* FragmentationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0475027E2E53A0FC0083520F /* FragmentationTests.swift */; };
 		047502872E5416250083520F /* Geohash.swift in Sources */ = {isa = PBXBuildFile; fileRef = 047502852E5416250083520F /* Geohash.swift */; };
@@ -32,6 +40,10 @@
 		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 */; };
+		048A4C282E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */; };
+		048A4C292E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */; };
+		048A4C2B2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */; };
+		048A4C2C2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */; };
 		049BD3902E4EC4F0001A566B /* PrivateChatManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38F2E4EC4F0001A566B /* PrivateChatManager.swift */; };
 		049BD3912E4EC4F0001A566B /* AutocompleteService.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38C2E4EC4F0001A566B /* AutocompleteService.swift */; };
 		049BD3922E4EC4F0001A566B /* CommandProcessor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 049BD38D2E4EC4F0001A566B /* CommandProcessor.swift */; };
@@ -193,6 +205,10 @@
 
 /* Begin PBXFileReference section */
 		03C57F452B55FD0FD8F51421 /* bitchatTests_macOS.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = bitchatTests_macOS.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		04657AB42E633C6A002D5BBE /* NostrPoW.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NostrPoW.swift; sourceTree = "<group>"; };
+		04657AB72E633C76002D5BBE /* PowPolicy.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PowPolicy.swift; sourceTree = "<group>"; };
+		04657ABA2E633C94002D5BBE /* MiningAnimation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MiningAnimation.swift; sourceTree = "<group>"; };
+		04657ABD2E633CA4002D5BBE /* NostrPoWTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NostrPoWTests.swift; sourceTree = "<group>"; };
 		0475027E2E53A0FC0083520F /* FragmentationTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FragmentationTests.swift; sourceTree = "<group>"; };
 		047502852E5416250083520F /* Geohash.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Geohash.swift; sourceTree = "<group>"; };
 		047502862E5416250083520F /* LocationChannel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LocationChannel.swift; sourceTree = "<group>"; };
@@ -205,6 +221,8 @@
 		047502B32E55FED60083520F /* MeshPeerList.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MeshPeerList.swift; sourceTree = "<group>"; };
 		047502B82E560F690083520F /* RelayController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RelayController.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>"; };
 		049BD38C2E4EC4F0001A566B /* AutocompleteService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AutocompleteService.swift; sourceTree = "<group>"; };
 		049BD38D2E4EC4F0001A566B /* CommandProcessor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CommandProcessor.swift; sourceTree = "<group>"; };
 		049BD38F2E4EC4F0001A566B /* PrivateChatManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PrivateChatManager.swift; sourceTree = "<group>"; };
@@ -445,6 +463,7 @@
 		A55126E93155456CAA8D6656 /* Views */ = {
 			isa = PBXGroup;
 			children = (
+				04657ABA2E633C94002D5BBE /* MiningAnimation.swift */,
 				AA77BB13CC22DD33EE44FF57 /* VerificationViews.swift */,
 				047502B22E55FED60083520F /* GeohashPeopleList.swift */,
 				047502B32E55FED60083520F /* MeshPeerList.swift */,
@@ -484,6 +503,8 @@
 			isa = PBXGroup;
 			children = (
 				D69A18D27F9A565FD6041E12 /* Info.plist */,
+				04657ABD2E633CA4002D5BBE /* NostrPoWTests.swift */,
+				048A4C2A2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift */,
 				047502912E547ACC0083520F /* LocationChannelsTests.swift */,
 				C272F137CE00FC5A96E0CC06 /* NostrProtocolTests.swift */,
 				980B109CBA72BC996455C62B /* BLEServiceTests.swift */,
@@ -519,6 +540,8 @@
 		D98A3186D7E4C72E35BDF7FE /* Services */ = {
 			isa = PBXGroup;
 			children = (
+				04657AB72E633C76002D5BBE /* PowPolicy.swift */,
+				048A4C272E5FCD6600162C4A /* GeohashBookmarksStore.swift */,
 				048A4BE62E5CCCC300162C4A /* TransportConfig.swift */,
 				AA77BB10CC22DD33EE44FF55 /* VerificationService.swift */,
 				047502B82E560F690083520F /* RelayController.swift */,
@@ -542,6 +565,7 @@
 		E78C7F4B6769C0A72F5DE544 /* Nostr */ = {
 			isa = PBXGroup;
 			children = (
+				04657AB42E633C6A002D5BBE /* NostrPoW.swift */,
 				A1B2C3D44E5F60718293A4B4 /* XChaCha20Poly1305Compat.swift */,
 				049BD39B2E51DBD9001A566B /* NostrEmbeddedBitChat.swift */,
 				5F8043995007F0D84438EDD9 /* NostrIdentity.swift */,
@@ -771,6 +795,7 @@
 				0475028C2E54171C0083520F /* LocationChannelManager.swift in Sources */,
 				AFF33EF44626EF0579D17EB1 /* NoiseHandshakeCoordinator.swift in Sources */,
 				8C1AB0F2D48207E0755DA91A /* NoiseProtocol.swift in Sources */,
+				048A4C282E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */,
 				049BD3AC2E51E38E001A566B /* PeerIDResolver.swift in Sources */,
 				D691938B4029A04CC905FDC8 /* NoiseSecurityConsiderations.swift in Sources */,
 				8A14ADADF5CD7A79919CB655 /* NoiseSession.swift in Sources */,
@@ -783,15 +808,18 @@
 				749D8CF8A362B6CD0786782D /* NotificationService.swift in Sources */,
 				049BD3AF2E51ED60001A566B /* Transport.swift in Sources */,
 				E2DCF7817344F1CCDB8B7B2F /* SecureIdentityStateManager.swift in Sources */,
+				04657ABC2E633C94002D5BBE /* MiningAnimation.swift in Sources */,
 				049BD3A02E51DBF4001A566B /* Packets.swift in Sources */,
 				047502892E5416250083520F /* Geohash.swift in Sources */,
 				0475028A2E5416250083520F /* LocationChannel.swift in Sources */,
+				04657AB82E633C76002D5BBE /* PowPolicy.swift in Sources */,
 				049BD3A12E51DBF4001A566B /* PeerID.swift in Sources */,
 				049BD3942E4EC4F0001A566B /* PrivateChatManager.swift in Sources */,
 				049BD3952E4EC4F0001A566B /* AutocompleteService.swift in Sources */,
 				049BD3962E4EC4F0001A566B /* CommandProcessor.swift in Sources */,
 				D111988977C3BC246AB27FA4 /* SecureLogger.swift in Sources */,
 				8DE687D2EB5EB120868DBFB5 /* BLEService.swift in Sources */,
+				04657AB52E633C6A002D5BBE /* NostrPoW.swift in Sources */,
 				AA11BB22CC33DD44EE55FF66 /* MessageTextHelpers.swift in Sources */,
 				E0A1B2C3D4E5F6012345678B /* GeoRelayDirectory.swift in Sources */,
 			);
@@ -830,6 +858,7 @@
 				0475028D2E54171C0083520F /* LocationChannelManager.swift in Sources */,
 				6D0D4A0B1D8B659DCBAE7C9C /* NoiseHandshakeCoordinator.swift in Sources */,
 				A7187D48B07C6857DE01D0ED /* NoiseProtocol.swift in Sources */,
+				048A4C292E5FCD6600162C4A /* GeohashBookmarksStore.swift in Sources */,
 				049BD3AB2E51E38E001A566B /* PeerIDResolver.swift in Sources */,
 				9CCF09F7527EC681A13FC246 /* NoiseSecurityConsiderations.swift in Sources */,
 				92D1CF17DF88EA298F6E5E8E /* NoiseSession.swift in Sources */,
@@ -842,15 +871,18 @@
 				61C81ED5F679D5E973EE0C07 /* NotificationService.swift in Sources */,
 				049BD3AE2E51ED60001A566B /* Transport.swift in Sources */,
 				68C4BE564735F6E7915274A2 /* SecureIdentityStateManager.swift in Sources */,
+				04657ABB2E633C94002D5BBE /* MiningAnimation.swift in Sources */,
 				049BD3A22E51DBF4001A566B /* Packets.swift in Sources */,
 				047502872E5416250083520F /* Geohash.swift in Sources */,
 				047502882E5416250083520F /* LocationChannel.swift in Sources */,
+				04657AB92E633C76002D5BBE /* PowPolicy.swift in Sources */,
 				049BD3A32E51DBF4001A566B /* PeerID.swift in Sources */,
 				049BD3902E4EC4F0001A566B /* PrivateChatManager.swift in Sources */,
 				049BD3912E4EC4F0001A566B /* AutocompleteService.swift in Sources */,
 				049BD3922E4EC4F0001A566B /* CommandProcessor.swift in Sources */,
 				EC5241969D2550B97629EBD0 /* SecureLogger.swift in Sources */,
 				C165DD35BB8E9C327A3C2DA4 /* BLEService.swift in Sources */,
+				04657AB62E633C6A002D5BBE /* NostrPoW.swift in Sources */,
 				AA11BB22CC33DD44EE55FF67 /* MessageTextHelpers.swift in Sources */,
 				E0A1B2C3D4E5F6012345678C /* GeoRelayDirectory.swift in Sources */,
 			);
@@ -865,7 +897,9 @@
 				8F282E9CCA5AE1ECC001D2E4 /* IntegrationTests.swift in Sources */,
 				047502B12E55E8450083520F /* InputValidatorTests.swift in Sources */,
 				D727EA273CB214FC32612469 /* MockBluetoothMeshService.swift in Sources */,
+				04657ABF2E633CA4002D5BBE /* NostrPoWTests.swift in Sources */,
 				047502932E547ACC0083520F /* LocationChannelsTests.swift in Sources */,
+				048A4C2B2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */,
 				6C803BF930E7E19BE6E99EAA /* MockBLEService.swift in Sources */,
 				765254F56997F01054699AC0 /* NoiseProtocolTests.swift in Sources */,
 				968181D255CA7A804340B4DA /* NostrProtocolTests.swift in Sources */,
@@ -887,7 +921,9 @@
 				686441ABC2AF83EE98E6ECF2 /* IntegrationTests.swift in Sources */,
 				047502B02E55E8450083520F /* InputValidatorTests.swift in Sources */,
 				8851F08D88C5B1DE7B9F55C6 /* MockBluetoothMeshService.swift in Sources */,
+				04657ABE2E633CA4002D5BBE /* NostrPoWTests.swift in Sources */,
 				047502922E547ACC0083520F /* LocationChannelsTests.swift in Sources */,
+				048A4C2C2E5FCE0300162C4A /* GeohashBookmarksStoreTests.swift in Sources */,
 				3849CA6D99B2D536636DF4A6 /* MockBLEService.swift in Sources */,
 				BC4DC75F4FB823FF40569676 /* NoiseProtocolTests.swift in Sources */,
 				EE8C3ECADAB3083A2687D50B /* NostrProtocolTests.swift in Sources */,

bitchat/BitchatApp.swift

@@ -173,6 +173,14 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
                 }
             }
         }
+        // Handle deeplink (e.g., geohash activity)
+        if let deep = userInfo["deeplink"] as? String, let url = URL(string: deep) {
+            #if os(iOS)
+            DispatchQueue.main.async { UIApplication.shared.open(url) }
+            #else
+            DispatchQueue.main.async { NSWorkspace.shared.open(url) }
+            #endif
+        }
         
         completionHandler()
     }
@@ -192,6 +200,15 @@ class NotificationDelegate: NSObject, UNUserNotificationCenterDelegate {
                 }
             }
         }
+        // Suppress geohash activity notification if we're already in that geohash channel
+        if identifier.hasPrefix("geo-activity-"),
+           let deep = userInfo["deeplink"] as? String,
+           let gh = deep.components(separatedBy: "/").last {
+            if case .location(let ch) = LocationChannelManager.shared.selectedChannel, ch.geohash == gh {
+                completionHandler([])
+                return
+            }
+        }
         
         // Show notification in all other cases
         completionHandler([.banner, .sound])

bitchat/Nostr/NostrPoW.swift

@@ -0,0 +1,96 @@
+import Foundation
+import CryptoKit
+import Security
+import Darwin
+
+/// NIP-13 Proof-of-Work utilities for Nostr events.
+/// - Counts leading zero bits and mines a nonce tag to meet a target.
+enum NostrPoW {
+    /// Table of leading zero bit counts for all 256 byte values.
+    private static let lzTable: [UInt8] = {
+        (0...255).map { v -> UInt8 in
+            var x = UInt8(v)
+            if x == 0 { return 8 }
+            var n: UInt8 = 0
+            while (x & 0x80) == 0 {
+                n &+= 1
+                x <<= 1
+            }
+            return n
+        }
+    }()
+
+    /// Count leading zero bits in a 32-byte hash.
+    static func leadingZeroBits(_ data: Data) -> Int {
+        var total = 0
+        for b in data {
+            let lz = Int(lzTable[Int(b)])
+            total += lz
+            if lz != 8 { break }
+        }
+        return total
+    }
+
+    /// Compute Nostr event id hash (SHA-256 over canonical serialization) for given fields.
+    private static func eventIDHash(pubkey: String, createdAt: Int, kind: Int, tags: [[String]], content: String) -> (hex: String, data: Data) {
+        let serialized: [Any] = [0, pubkey, createdAt, kind, tags, content]
+        let json = try! JSONSerialization.data(withJSONObject: serialized, options: [.withoutEscapingSlashes])
+        let digest = SHA256.hash(data: json)
+        let data = Data(digest)
+        let hex = data.map { String(format: "%02x", $0) }.joined()
+        return (hex, data)
+    }
+
+    /// Mine a NIP-13 nonce tag that satisfies the target leading-zero bits.
+    /// - Parameters:
+    ///   - pubkey: x-only hex pubkey (64-hex chars)
+    ///   - createdAt: seconds since epoch
+    ///   - kind: event kind
+    ///   - baseTags: existing tags (e.g., [ ["g", geohash], ["n", nickname], ... ])
+    ///   - content: event content
+    ///   - targetBits: required leading zero bits
+    ///   - startNonce: optional starting nonce (random if nil)
+    /// - Returns: (nonce, idHex)
+    static func mine(pubkey: String,
+                     createdAt: Int,
+                     kind: Int,
+                     baseTags: [[String]],
+                     content: String,
+                     targetBits: Int,
+                     startNonce: UInt64? = nil) -> (nonce: UInt64, idHex: String) {
+        var nonce: UInt64 = startNonce ?? randomNonce()
+        // Build a local tags buffer once to avoid reallocating unrelated tags
+        var tags = baseTags
+        tags.append(["nonce", "0", String(targetBits)])
+
+        var iter: UInt64 = 0
+        while true {
+            var solved = false
+            var idHexOut = ""
+            // Use an autorelease pool periodically to keep memory stable on iOS
+            autoreleasepool {
+                // Update nonce tag value (second element)
+                tags[tags.count - 1][1] = String(nonce)
+                let (idHex, idData) = eventIDHash(pubkey: pubkey, createdAt: createdAt, kind: kind, tags: tags, content: content)
+                if leadingZeroBits(idData) >= targetBits {
+                    solved = true
+                    idHexOut = idHex
+                }
+            }
+            if solved {
+                return (nonce, idHexOut)
+            }
+            nonce &+= 1
+            iter &+= 1
+            if iter & 0x3FFF == 0 { /* yield every ~16k iterations */ _ = sched_yield() }
+        }
+    }
+
+    private static func randomNonce() -> UInt64 {
+        var n: UInt64 = 0
+        withUnsafeMutableBytes(of: &n) { ptr in
+            _ = SecRandomCopyBytes(kSecRandomDefault, ptr.count, ptr.baseAddress!)
+        }
+        return n
+    }
+}

bitchat/Protocols/BitchatProtocol.swift

@@ -409,6 +409,8 @@ class BitchatMessage: Codable {
     let senderPeerID: String?
     let mentions: [String]?  // Array of mentioned nicknames
     var deliveryStatus: DeliveryStatus? // Delivery tracking
+    // Mining state for Nostr geohash PoW (UI hint: hide timestamp, animate)
+    var isMiningPow: Bool? // default nil/false
     
     // Cached formatted text (not included in Codable)
     private var _cachedFormattedText: [String: AttributedString] = [:]
@@ -421,13 +423,18 @@ class BitchatMessage: Codable {
         _cachedFormattedText["\(isDark)-\(isSelf)"] = text
     }
     
+    func clearCachedFormattedText() {
+        _cachedFormattedText.removeAll()
+    }
+    
     // Codable implementation
     enum CodingKeys: String, CodingKey {
         case id, sender, content, timestamp, isRelay, originalSender
         case isPrivate, recipientNickname, senderPeerID, mentions, deliveryStatus
+        case isMiningPow
     }
     
-    init(id: String? = nil, sender: String, content: String, timestamp: Date, isRelay: Bool, originalSender: String? = nil, isPrivate: Bool = false, recipientNickname: String? = nil, senderPeerID: String? = nil, mentions: [String]? = nil, deliveryStatus: DeliveryStatus? = nil) {
+    init(id: String? = nil, sender: String, content: String, timestamp: Date, isRelay: Bool, originalSender: String? = nil, isPrivate: Bool = false, recipientNickname: String? = nil, senderPeerID: String? = nil, mentions: [String]? = nil, deliveryStatus: DeliveryStatus? = nil, isMiningPow: Bool? = nil) {
         self.id = id ?? UUID().uuidString
         self.sender = sender
         self.content = content
@@ -439,6 +446,7 @@ class BitchatMessage: Codable {
         self.senderPeerID = senderPeerID
         self.mentions = mentions
         self.deliveryStatus = deliveryStatus ?? (isPrivate ? .sending : nil)
+        self.isMiningPow = isMiningPow
     }
 }
 
@@ -455,7 +463,8 @@ extension BitchatMessage: Equatable {
                lhs.recipientNickname == rhs.recipientNickname &&
                lhs.senderPeerID == rhs.senderPeerID &&
                lhs.mentions == rhs.mentions &&
-               lhs.deliveryStatus == rhs.deliveryStatus
+               lhs.deliveryStatus == rhs.deliveryStatus &&
+               (lhs.isMiningPow ?? false) == (rhs.isMiningPow ?? false)
     }
 }
 

bitchat/Protocols/Geohash.swift

@@ -87,4 +87,28 @@ enum Geohash {
         let lon = (lonInterval.0 + lonInterval.1) / 2
         return (lat, lon)
     }
+
+    /// Decodes a geohash into its latitude and longitude bounds.
+    /// - Parameter geohash: Base32 geohash string.
+    /// - Returns: (latMin, latMax, lonMin, lonMax)
+    static func decodeBounds(_ geohash: String) -> (latMin: Double, latMax: Double, lonMin: Double, lonMax: Double) {
+        var latInterval: (Double, Double) = (-90.0, 90.0)
+        var lonInterval: (Double, Double) = (-180.0, 180.0)
+
+        var isEven = true
+        for ch in geohash.lowercased() {
+            guard let cd = base32Map[ch] else { continue }
+            for mask in [16, 8, 4, 2, 1] {
+                if isEven {
+                    let mid = (lonInterval.0 + lonInterval.1) / 2
+                    if (cd & mask) != 0 { lonInterval.0 = mid } else { lonInterval.1 = mid }
+                } else {
+                    let mid = (latInterval.0 + latInterval.1) / 2
+                    if (cd & mask) != 0 { latInterval.0 = mid } else { latInterval.1 = mid }
+                }
+                isEven.toggle()
+            }
+        }
+        return (latInterval.0, latInterval.1, lonInterval.0, lonInterval.1)
+    }
 }

bitchat/Services/GeohashBookmarksStore.swift

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

bitchat/Services/LocationChannelManager.swift

@@ -50,10 +50,8 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
            let arr = try? JSONDecoder().decode([String].self, from: data) {
             teleportedSet = Set(arr)
         }
-        // Initialize teleported flag from persisted state if a location channel is selected
+        // Do not eagerly mark teleported on startup; wait for location to compute regional set.
-        if case .location(let ch) = selectedChannel {
+        // This avoids showing teleported for in-region channels during cold start.
-            teleported = teleportedSet.contains(ch.geohash)
-        }
         let status: CLAuthorizationStatus
         if #available(iOS 14.0, macOS 11.0, *) {
             status = cl.authorizationStatus
@@ -61,6 +59,15 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
             status = CLLocationManager.authorizationStatus()
         }
         updatePermissionState(from: status)
+        // If we don't have location authorization at startup, fall back to persisted teleport state
+        switch status {
+        case .authorizedAlways, .authorizedWhenInUse, .authorized:
+            break // will compute from location
+        default:
+            if case .location(let ch) = selectedChannel {
+                teleported = teleportedSet.contains(ch.geohash)
+            }
+        }
     }
 
     // MARK: - Public API
@@ -92,23 +99,30 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         }
     }
 
-    /// Begin periodic one-shot location refreshes while a selector UI is visible.
+    /// Begin continuous, distance-filtered updates while the channel sheet is visible.
+    /// Uses a 21m filter (configurable) to only refresh on meaningful movement.
     func beginLiveRefresh(interval: TimeInterval = TransportConfig.locationLiveRefreshInterval) {
         guard permissionState == .authorized else { return }
-        // Switch to a lightweight periodic one-shot request (polling) while the sheet is open
+        // Stop any previous polling timer
         refreshTimer?.invalidate()
-        refreshTimer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { [weak self] _ in
+        refreshTimer = nil
-            self?.requestOneShotLocation()
+        // Tighten accuracy and distance filter for live view
-        }
+        cl.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
-        // Kick off immediately
+        cl.distanceFilter = TransportConfig.locationDistanceFilterLiveMeters
+        // Start continuous updates
+        cl.startUpdatingLocation()
+        // Request an immediate fix to populate UI without waiting for movement
         requestOneShotLocation()
     }
 
-    /// Stop periodic refreshes when selector UI is dismissed.
+    /// Stop continuous refreshes when selector UI is dismissed.
     func endLiveRefresh() {
         refreshTimer?.invalidate()
         refreshTimer = nil
         cl.stopUpdatingLocation()
+        // Restore more relaxed defaults for background/idle state
+        cl.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        cl.distanceFilter = TransportConfig.locationDistanceFilterMeters
     }
 
     func select(_ channel: ChannelID) {
@@ -122,10 +136,24 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
             case .mesh:
                 self.teleported = false
             case .location(let ch):
+                // If this geohash is in our current regional set, do NOT mark teleported.
+                let inRegional = self.availableChannels.contains { $0.geohash == ch.geohash }
+                if inRegional {
+                    self.teleported = false
+                    // Clear persisted teleport for this geohash to keep future selections clean
+                    if self.teleportedSet.contains(ch.geohash) {
+                        self.teleportedSet.remove(ch.geohash)
+                        if let data = try? JSONEncoder().encode(Array(self.teleportedSet)) {
+                            UserDefaults.standard.set(data, forKey: self.teleportedStoreKey)
+                        }
+                    }
+                } else {
+                    // Fall back to persisted mark (set by deep link or manual teleport)
                     self.teleported = self.teleportedSet.contains(ch.geohash)
                 }
             }
         }
+    }
 
     // Mark or unmark a geohash as teleported in persistence and update current flag if relevant
     func markTeleported(for geohash: String, _ flag: Bool) {
@@ -195,14 +223,25 @@ final class LocationChannelManager: NSObject, CLLocationManagerDelegate, Observa
         }
         Task { @MainActor in
             self.availableChannels = result
-            // Recompute teleported status based on persisted state OR current location vs selected channel
+            // Recompute teleported status based on whether the selected geohash is in our regional set
             switch self.selectedChannel {
             case .mesh:
                 self.teleported = false
             case .location(let ch):
-                let persisted = self.teleportedSet.contains(ch.geohash)
+                // Membership check using freshly computed regional channels; avoids precision/rename drift
-                let currentGH = Geohash.encode(latitude: coord.latitude, longitude: coord.longitude, precision: ch.level.precision)
+                let inRegional = result.contains { $0.geohash == ch.geohash }
-                self.teleported = persisted || (currentGH != ch.geohash)
+                if inRegional {
+                    self.teleported = false
+                    // Clear persisted teleport flag if present
+                    if self.teleportedSet.contains(ch.geohash) {
+                        self.teleportedSet.remove(ch.geohash)
+                        if let data = try? JSONEncoder().encode(Array(self.teleportedSet)) {
+                            UserDefaults.standard.set(data, forKey: self.teleportedStoreKey)
+                        }
+                    }
+                } else {
+                    self.teleported = true
+                }
             }
         }
     }

bitchat/Services/NotificationService.swift

@@ -90,6 +90,15 @@ class NotificationService {
         }
     }
     
+    // Geohash public chat notification with deep link to a specific geohash
+    func sendGeohashActivityNotification(geohash: String, titlePrefix: String = "#", bodyPreview: String) {
+        let title = "\(titlePrefix)\(geohash)"
+        let identifier = "geo-activity-\(geohash)-\(Date().timeIntervalSince1970)"
+        let deeplink = "bitchat://geohash/\(geohash)"
+        let userInfo: [String: Any] = ["deeplink": deeplink]
+        sendLocalNotification(title: title, body: bodyPreview, identifier: identifier, userInfo: userInfo)
+    }
+
     func sendNetworkAvailableNotification(peerCount: Int) {
         let title = "👥 bitchatters nearby!"
         let body = peerCount == 1 ? "1 person around" : "\(peerCount) people around"

bitchat/Services/PowPolicy.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+/// Simple default policy for NIP-13 difficulty on geohash chats.
+/// Progressive by geohash precision; adjustable later by live activity.
+enum PowPolicy {
+    /// Determine target bits for a given geohash string.
+    /// Clamped to a sane range to keep UX responsive on phones.
+    static func requiredBits(forGeohash geohash: String) -> Int {
+        let precision = geohash.count
+        // Start at 13 and go down with higher precision (smaller areas)
+        switch precision {
+        case ...5: return 16
+        case 6:    return 15
+        default:   return 14
+        }
+    }
+}

bitchat/Services/TransportConfig.swift

@@ -100,8 +100,14 @@ 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 locationLiveRefreshInterval: TimeInterval = 5.0
 
+    // Notifications (geohash)
+    static let uiGeoNotifyCooldownSeconds: TimeInterval = 60.0
+    static let uiGeoNotifySnippetMaxLen: Int = 80
+
     // Nostr geohash
     static let nostrGeohashInitialLookbackSeconds: TimeInterval = 3600
     static let nostrGeohashInitialLimit: Int = 200
@@ -169,6 +175,10 @@ enum TransportConfig {
     // UI color tuning
     static let uiColorHueAvoidanceDelta: Double = 0.05
     static let uiColorHueOffset: Double = 0.12
+    // Peer list palette
+    static let uiPeerPaletteSlots: Int = 36
+    static let uiPeerPaletteRingBrightnessDeltaLight: Double = 0.07
+    static let uiPeerPaletteRingBrightnessDeltaDark: Double = -0.07
 
     // UI windowing (infinite scroll)
     static let uiWindowInitialCountPublic: Int = 300

bitchat/Views/ContentView.swift

@@ -24,6 +24,7 @@ struct ContentView: View {
     
     @EnvironmentObject var viewModel: ChatViewModel
     @ObservedObject private var locationManager = LocationChannelManager.shared
+    @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
     @State private var messageText = ""
     @State private var textFieldSelection: NSRange? = nil
     @FocusState private var isTextFieldFocused: Bool
@@ -164,6 +165,8 @@ struct ContentView: View {
         }
         .sheet(isPresented: $showAppInfo) {
             AppInfoView()
+                .onAppear { viewModel.isAppInfoPresented = true }
+                .onDisappear { viewModel.isAppInfoPresented = false }
         }
         .sheet(isPresented: Binding(
             get: { viewModel.showingFingerprintFor != nil },
@@ -278,8 +281,10 @@ struct ContentView: View {
                         }
                     }()
                     let items = windowedMessages.map { (uiID: "\(contextKey)|\($0.id)", message: $0) }
+                    // Filter out empty/whitespace-only messages to avoid blank rows
+                    let filteredItems = items.filter { !$0.message.content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
 
-                    ForEach(items, id: \.uiID) { item in
+                    ForEach(filteredItems, id: \.uiID) { item in
                         let message = item.message
                         VStack(alignment: .leading, spacing: 0) {
                             // Check if current user is mentioned
@@ -298,10 +303,21 @@ struct ContentView: View {
                                     HStack(alignment: .top, spacing: 0) {
                                         let isLong = (message.content.count > TransportConfig.uiLongMessageLengthThreshold || message.content.hasVeryLongToken(threshold: TransportConfig.uiVeryLongTokenThreshold)) && cashuTokens.isEmpty
                                         let isExpanded = expandedMessageIDs.contains(message.id)
-                                        Text(viewModel.formatMessageAsText(message, colorScheme: colorScheme))
+                                        let formatted = viewModel.formatMessageAsText(message, colorScheme: colorScheme)
+                                        let prefixAttr = viewModel.formatSenderPrefix(message, colorScheme: colorScheme)
+                                        let baseColor = viewModel.baseColorForMessage(message, colorScheme: colorScheme)
+                                        let isSelfMsg = viewModel.isSelfMessage(message)
+                                        if (message.isMiningPow ?? false) {
+                                            // Single Text combines prefix + animated body, so wrapping matches final layout
+                                            CombinedMiningText(prefix: prefixAttr, original: message.content, color: baseColor, isSelf: isSelfMsg)
+                                            .lineLimit(isLong && !isExpanded ? TransportConfig.uiLongMessageLineLimit : nil)
+                                            .frame(maxWidth: .infinity, alignment: .leading)
+                                        } else {
+                                            Text(formatted)
                                                 .fixedSize(horizontal: false, vertical: true)
                                                 .lineLimit(isLong && !isExpanded ? TransportConfig.uiLongMessageLineLimit : nil)
                                                 .frame(maxWidth: .infinity, alignment: .leading)
+                                        }
                                         
                                         // Delivery status indicator for private messages
                                         if message.isPrivate && message.sender == viewModel.nickname,
@@ -459,7 +475,13 @@ struct ContentView: View {
                 }
                 let level = levelForLength(gh.count)
                 let ch = GeohashChannel(level: level, geohash: gh)
+                // Do not mark teleported when opening a geohash that is in our regional set.
+                // If availableChannels is empty (e.g., cold start), defer marking and let
+                // LocationChannelManager compute teleported based on actual location.
+                let inRegional = LocationChannelManager.shared.availableChannels.contains { $0.geohash == gh }
+                if !inRegional && !LocationChannelManager.shared.availableChannels.isEmpty {
                     LocationChannelManager.shared.markTeleported(for: gh, true)
+                }
                 LocationChannelManager.shared.select(ChannelID.location(ch))
             }
             .onTapGesture(count: 3) {
@@ -1112,6 +1134,15 @@ struct ContentView: View {
                     .buttonStyle(.plain)
                     .accessibilityLabel("Open unread private chat")
                 }
+                // Bookmark toggle for current geohash (not shown for mesh)
+                if case .location(let ch) = locationManager.selectedChannel {
+                    Button(action: { GeohashBookmarksStore.shared.toggle(ch.geohash) }) {
+                        Image(systemName: GeohashBookmarksStore.shared.isBookmarked(ch.geohash) ? "bookmark.fill" : "bookmark")
+                            .font(.system(size: 12))
+                    }
+                    .buttonStyle(.plain)
+                    .accessibilityLabel("Toggle bookmark for #\(ch.geohash)")
+                }
                 // Location channels button '#'
                 Button(action: { showLocationChannelsSheet = true }) {
                     let badgeText: String = {
@@ -1166,6 +1197,13 @@ struct ContentView: View {
         .padding(.horizontal, 12)
         .sheet(isPresented: $showLocationChannelsSheet) {
             LocationChannelsSheet(isPresented: $showLocationChannelsSheet)
+                .onAppear { viewModel.isLocationChannelsSheetPresented = true }
+                .onDisappear { viewModel.isLocationChannelsSheetPresented = false }
+        }
+        .alert("heads up", isPresented: $viewModel.showScreenshotPrivacyWarning) {
+            Button("ok", role: .cancel) {}
+        } message: {
+            Text("screenshots of location channels will reveal your location. think before sharing publicly.")
         }
         .background(backgroundColor.opacity(0.95))
     }
@@ -1360,6 +1398,53 @@ struct ContentView: View {
     
 }
 
+// MARK: - Mining UI helpers (local to ensure inclusion in target)
+fileprivate struct CombinedMiningText: View {
+    let prefix: AttributedString
+    let original: String
+    let color: Color
+    let isSelf: Bool
+    let fontSize: CGFloat = 14
+    let interval: TimeInterval = 0.06
+    @State private var display: String = ""
+    @State private var timer: Timer? = nil
+
+    private let charset: [Character] = Array("abcdefghijklmnopqrstuvwxyz0123456789@#$%&*+-")
+
+    var body: some View {
+        Text(combinedAttributed)
+            .fixedSize(horizontal: false, vertical: true)
+            .onAppear {
+                display = scramble(original)
+                timer?.invalidate()
+                timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { _ in
+                    display = scramble(original)
+                }
+            }
+            .onDisappear { timer?.invalidate(); timer = nil }
+    }
+
+    private var combinedAttributed: AttributedString {
+        var res = AttributedString()
+        res.append(prefix)
+        var style = AttributeContainer()
+        style.foregroundColor = color
+        style.font = .system(size: fontSize, weight: isSelf ? .bold : .regular, design: .monospaced)
+        res.append(AttributedString(display).mergingAttributes(style))
+        return res
+    }
+
+    private func scramble(_ s: String) -> String {
+        var out = String()
+        out.reserveCapacity(s.count)
+        for ch in s {
+            if ch.isWhitespace || ch.isNewline { out.append(ch); continue }
+            out.append(charset.randomElement() ?? ch)
+        }
+        return out
+    }
+}
+
 // MARK: - Helper Views
 
 // Rounded payment chip button

bitchat/Views/LocationChannelsSheet.swift

@@ -8,6 +8,7 @@ import AppKit
 struct LocationChannelsSheet: View {
     @Binding var isPresented: Bool
     @ObservedObject private var manager = LocationChannelManager.shared
+    @ObservedObject private var bookmarks = GeohashBookmarksStore.shared
     @EnvironmentObject var viewModel: ChatViewModel
     @Environment(\.colorScheme) var colorScheme
     @State private var customGeohash: String = ""
@@ -83,29 +84,22 @@ struct LocationChannelsSheet: View {
             }
             // Begin periodic refresh while sheet is open
             manager.beginLiveRefresh()
-            // Begin multi-channel sampling for counts
+            // Geohash sampling is now managed by ChatViewModel globally
-            let ghs = manager.availableChannels.map { $0.geohash }
-            viewModel.beginGeohashSampling(for: ghs)
         }
         .onDisappear {
             manager.endLiveRefresh()
-            viewModel.endGeohashSampling()
         }
         .onChange(of: manager.permissionState) { newValue in
             if newValue == LocationChannelManager.PermissionState.authorized {
                 manager.refreshChannels()
             }
         }
-        .onChange(of: manager.availableChannels) { newValue in
+        .onChange(of: manager.availableChannels) { _ in }
-            // Keep sampling list in sync with available channels as they refresh live
-            let ghs = newValue.map { $0.geohash }
-            viewModel.beginGeohashSampling(for: ghs)
-        }
     }
 
     private var channelList: some View {
         List {
-            // Mesh option first
+            // Mesh option first (no bookmark)
             channelRow(title: meshTitleWithCount(), subtitlePrefix: "#bluetooth • \(bluetoothRangeString())", isSelected: isMeshSelected, titleColor: standardBlue, titleBold: meshCount() > 0) {
                 manager.select(ChannelID.mesh)
                 isPresented = false
@@ -119,7 +113,21 @@ struct LocationChannelsSheet: View {
                     let namePart = nameBase.map { formattedNamePrefix(for: channel.level) + $0 }
                     let subtitlePrefix = "#\(channel.geohash) • \(coverage)"
                     let highlight = viewModel.geohashParticipantCount(for: channel.geohash) > 0
-                    channelRow(title: geohashTitleWithCount(for: channel), subtitlePrefix: subtitlePrefix, subtitleName: namePart, isSelected: isSelected(channel), titleBold: highlight) {
+                    channelRow(
+                        title: geohashTitleWithCount(for: channel),
+                        subtitlePrefix: subtitlePrefix,
+                        subtitleName: namePart,
+                        isSelected: isSelected(channel),
+                        titleBold: highlight,
+                        trailingAccessory: {
+                            Button(action: { bookmarks.toggle(channel.geohash) }) {
+                                Image(systemName: bookmarks.isBookmarked(channel.geohash) ? "bookmark.fill" : "bookmark")
+                                    .font(.system(size: 14))
+                            }
+                            .buttonStyle(.plain)
+                            .padding(.leading, 8)
+                        }
+                    ) {
                         // Selecting a suggested nearby channel is not a teleport. Persist this.
                         manager.markTeleported(for: channel.geohash, false)
                         manager.select(ChannelID.location(channel))
@@ -195,6 +203,48 @@ struct LocationChannelsSheet: View {
                 }
             }
 
+            // Bookmarked geohashes
+            if !bookmarks.bookmarks.isEmpty {
+                VStack(alignment: .leading, spacing: 6) {
+                    Text("bookmarked")
+                        .font(.system(size: 12, design: .monospaced))
+                        .foregroundColor(.secondary)
+                }
+                .listRowSeparator(.hidden)
+                ForEach(bookmarks.bookmarks, id: \.self) { gh in
+                    let level = levelForLength(gh.count)
+                    let channel = GeohashChannel(level: level, geohash: gh)
+                    let coverage = coverageString(forPrecision: gh.count)
+                    let subtitle = "#\(gh) • \(coverage)"
+                    let name = bookmarks.bookmarkNames[gh]
+                    channelRow(
+                        title: geohashHashTitleWithCount(gh),
+                        subtitlePrefix: subtitle,
+                        subtitleName: name.map { formattedNamePrefix(for: level) + $0 },
+                        isSelected: isSelected(channel),
+                        trailingAccessory: {
+                            Button(action: { bookmarks.toggle(gh) }) {
+                                Image(systemName: bookmarks.isBookmarked(gh) ? "bookmark.fill" : "bookmark")
+                                    .font(.system(size: 14))
+                            }
+                            .buttonStyle(.plain)
+                            .padding(.leading, 8)
+                        }
+                    ) {
+                        // For bookmarked selection, mark teleported based on regional membership
+                        let inRegional = manager.availableChannels.contains { $0.geohash == gh }
+                        if !inRegional && !manager.availableChannels.isEmpty {
+                            manager.markTeleported(for: gh, true)
+                        } else {
+                            manager.markTeleported(for: gh, false)
+                        }
+                        manager.select(ChannelID.location(channel))
+                        isPresented = false
+                    }
+                    .onAppear { bookmarks.resolveNameIfNeeded(for: gh) }
+                }
+            }
+
             // Footer action inside the list
             if manager.permissionState == LocationChannelManager.PermissionState.authorized {
                 Button(action: {
@@ -227,9 +277,19 @@ struct LocationChannelsSheet: View {
         return false
     }
 
-    private func channelRow(title: String, subtitlePrefix: String, subtitleName: String? = nil, subtitleNameBold: Bool = false, isSelected: Bool, titleColor: Color? = nil, titleBold: Bool = false, action: @escaping () -> Void) -> some View {
+    @ViewBuilder
-        Button(action: action) {
+    private func channelRow(
-            HStack {
+        title: String,
+        subtitlePrefix: String,
+        subtitleName: String? = nil,
+        subtitleNameBold: Bool = false,
+        isSelected: Bool,
+        titleColor: Color? = nil,
+        titleBold: Bool = false,
+        @ViewBuilder trailingAccessory: () -> some View = { EmptyView() },
+        action: @escaping () -> Void
+    ) -> some View {
+        HStack(alignment: .center, spacing: 8) {
             VStack(alignment: .leading) {
                 // Render title with smaller font for trailing count in parentheses
                 let parts = splitTitleAndCount(title)
@@ -244,20 +304,17 @@ struct LocationChannelsSheet: View {
                                 .foregroundColor(.secondary)
                         }
                     }
-                    HStack(spacing: 0) {
+                let subtitleFull: String = {
-                        Text(subtitlePrefix)
+                    if let name = subtitleName, !name.isEmpty {
-                            .font(.system(size: 12, design: .monospaced))
+                        return subtitlePrefix + " • " + name
-                            .foregroundColor(.secondary)
-                        if let name = subtitleName {
-                            Text(" • ")
-                                .font(.system(size: 12, design: .monospaced))
-                                .foregroundColor(.secondary)
-                            Text(name)
-                                .font(.system(size: 12, design: .monospaced))
-                                .fontWeight(subtitleNameBold ? .bold : .regular)
-                                .foregroundColor(.secondary)
-                        }
                     }
+                    return subtitlePrefix
+                }()
+                Text(subtitleFull)
+                    .font(.system(size: 12, design: .monospaced))
+                    .foregroundColor(.secondary)
+                    .lineLimit(1)
+                    .truncationMode(.tail)
                 }
                 Spacer()
                 if isSelected {
@@ -265,11 +322,11 @@ struct LocationChannelsSheet: View {
                         .font(.system(size: 16, design: .monospaced))
                         .foregroundColor(standardGreen)
                 }
+                trailingAccessory()
             }
             .frame(maxWidth: .infinity, alignment: .leading)
         .contentShape(Rectangle())
-        }
+        .onTapGesture(perform: action)
-        .buttonStyle(.plain)
     }
 
     // Split a title like "#mesh [3 people]" into base and suffix "[3 people]"
@@ -289,20 +346,28 @@ struct LocationChannelsSheet: View {
     }
 
     private func meshCount() -> Int {
+        // Count mesh-connected OR mesh-reachable peers (exclude self)
         let myID = viewModel.meshService.myPeerID
         return viewModel.allPeers.reduce(0) { acc, peer in
-            if peer.id != myID && peer.isConnected { return acc + 1 }
+            if peer.id != myID && (peer.isConnected || peer.isReachable) { return acc + 1 }
             return acc
         }
     }
 
     private func geohashTitleWithCount(for channel: GeohashChannel) -> String {
-        // Use ViewModel's 5-minute activity counts; may be 0 for non-selected channels
+        // Main list: keep level labels (block/neighborhood/city/province/region)
         let count = viewModel.geohashParticipantCount(for: channel.geohash)
         let noun = count == 1 ? "person" : "people"
         return "\(channel.level.displayName.lowercased()) [\(count) \(noun)]"
     }
 
+    private func geohashHashTitleWithCount(_ geohash: String) -> String {
+        // Bookmarked list: show the #geohash as the main label
+        let count = viewModel.geohashParticipantCount(for: geohash)
+        let noun = count == 1 ? "person" : "people"
+        return "#\(geohash) [\(count) \(noun)]"
+    }
+
     private func validateGeohash(_ s: String) -> Bool {
         let allowed = Set("0123456789bcdefghjkmnpqrstuvwxyz")
         guard !s.isEmpty, s.count <= 12 else { return false }

bitchat/Views/MiningAnimation.swift

@@ -0,0 +1,87 @@
+import SwiftUI
+
+/// Mining body animation: scramble characters (matrix-like) until PoW completes.
+struct MiningScrambleText: View {
+    let original: String
+    let color: Color
+    let isSelf: Bool
+    let fontSize: CGFloat = 14
+    let interval: TimeInterval = 0.06
+    @State private var display: String = ""
+    @State private var timer: Timer? = nil
+
+    private let charset: [Character] = Array("abcdefghijklmnopqrstuvwxyz0123456789@#$%&*+-")
+
+    var body: some View {
+        Text(display)
+            .font(.system(size: fontSize, weight: isSelf ? .bold : .regular, design: .monospaced))
+            .foregroundColor(color)
+            .onAppear {
+                display = scramble(original)
+                timer?.invalidate()
+                timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { _ in
+                    display = scramble(original)
+                }
+            }
+            .onDisappear {
+                timer?.invalidate(); timer = nil
+            }
+}
+
+/// Combined prefix+body single-Text variant to ensure identical wrapping
+struct MiningCombinedText: View {
+    let prefix: AttributedString
+    let original: String
+    let color: Color
+    let isSelf: Bool
+    let fontSize: CGFloat = 14
+    let interval: TimeInterval = 0.06
+    @State private var display: String = ""
+    @State private var timer: Timer? = nil
+
+    private let charset: [Character] = Array("abcdefghijklmnopqrstuvwxyz0123456789@#$%&*+-")
+
+    var body: some View {
+        Text(combinedAttributed)
+            .fixedSize(horizontal: false, vertical: true)
+            .onAppear {
+                display = scramble(original)
+                timer?.invalidate()
+                timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { _ in
+                    display = scramble(original)
+                }
+            }
+            .onDisappear { timer?.invalidate(); timer = nil }
+    }
+
+    private var combinedAttributed: AttributedString {
+        var res = AttributedString()
+        res.append(prefix)
+        var style = AttributeContainer()
+        style.foregroundColor = color
+        style.font = .system(size: fontSize, weight: isSelf ? .bold : .regular, design: .monospaced)
+        res.append(AttributedString(display).mergingAttributes(style))
+        return res
+    }
+
+    private func scramble(_ s: String) -> String {
+        var out = String()
+        out.reserveCapacity(s.count)
+        for ch in s {
+            if ch.isWhitespace || ch.isNewline { out.append(ch); continue }
+            out.append(charset.randomElement() ?? ch)
+        }
+        return out
+    }
+}
+
+    private func scramble(_ s: String) -> String {
+        var out = String()
+        out.reserveCapacity(s.count)
+        for ch in s {
+            if ch.isWhitespace || ch.isNewline { out.append(ch); continue }
+            out.append(charset.randomElement() ?? ch)
+        }
+        return out
+    }
+}

bitchatTests/GeohashBookmarksStoreTests.swift

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

bitchatTests/NostrPoWTests.swift

@@ -0,0 +1,32 @@
+import XCTest
+import CryptoKit
+@testable import bitchat
+
+final class NostrPoWTests: XCTestCase {
+    func testLeadingZeroBits() {
+        // 0x00 -> 8, 0x00 -> 8, 0xF0 -> 0 leading zeros
+        let data = Data([0x00, 0x00, 0xF0]) + Data(repeating: 0x00, count: 29)
+        let lz = NostrPoW.leadingZeroBits(data)
+        XCTAssertEqual(lz, 16)
+    }
+
+    func testMineLowDifficulty() {
+        let pubkey = String(repeating: "a", count: 64)
+        let createdAt = Int(Date().timeIntervalSince1970)
+        let kind = 20000
+        let tags = [["g", "u4pruydqqvj"]]
+        let content = "hello"
+        let targetBits = 8 // keep it very low for test speed
+        let (nonce, idHex) = NostrPoW.mine(pubkey: pubkey, createdAt: createdAt, kind: kind, baseTags: tags, content: content, targetBits: targetBits)
+        XCTAssertGreaterThan(nonce, 0)
+        // Verify difficulty
+        let powTags = tags + [["nonce", String(nonce), String(targetBits)]]
+        // Recompute ID
+        let serialized: [Any] = [0, pubkey, createdAt, kind, powTags, content]
+        let json = try! JSONSerialization.data(withJSONObject: serialized, options: [.withoutEscapingSlashes])
+        let digest = CryptoKit.SHA256.hash(data: json)
+        let idData = Data(digest)
+        XCTAssertEqual(idHex.count, 64)
+        XCTAssertGreaterThanOrEqual(NostrPoW.leadingZeroBits(idData), targetBits)
+    }
+}