Nip13 pow (#357)

* add pow

* animation

* matrix style

* animation better

* improve animation

* improve animation

* works

* fix jump

* difficulty indicator

* 10 is default

* animation runs forever

* pow in message timestamp

* pow works

* default on

* adjust animation

* no printing

app/src/main/java/com/bitchat/android/ui/AboutSheet.kt

@@ -7,6 +7,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Bluetooth
 import androidx.compose.material.icons.filled.Lock
 import androidx.compose.material.icons.filled.Public
+import androidx.compose.material.icons.filled.Security
 import androidx.compose.material.icons.filled.Warning
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
@@ -20,6 +21,8 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.BaselineShift
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import com.bitchat.android.nostr.NostrProofOfWork
+import com.bitchat.android.nostr.PoWPreferenceManager
 
 /**
  * About Sheet for bitchat app information
@@ -168,6 +171,128 @@ fun AboutSheet(
                     }
                 }
 
+                // Proof of Work section
+                item {
+                    val context = LocalContext.current
+                    
+                    // Initialize PoW preferences if not already done
+                    LaunchedEffect(Unit) {
+                        PoWPreferenceManager.init(context)
+                    }
+                    
+                    val powEnabled by PoWPreferenceManager.powEnabled.collectAsState()
+                    val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsState()
+                    
+                    Column(
+                        modifier = Modifier.fillMaxWidth(),
+                        verticalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        Text(
+                            text = "proof of work",
+                            fontSize = 12.sp,
+                            fontFamily = FontFamily.Monospace,
+                            fontWeight = FontWeight.Medium,
+                            color = colorScheme.onSurface.copy(alpha = 0.8f)
+                        )
+                        
+                        Row(
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            verticalAlignment = Alignment.CenterVertically
+                        ) {
+                            FilterChip(
+                                selected = !powEnabled,
+                                onClick = { PoWPreferenceManager.setPowEnabled(false) },
+                                label = { Text("pow off", fontFamily = FontFamily.Monospace) }
+                            )
+                            FilterChip(
+                                selected = powEnabled,
+                                onClick = { PoWPreferenceManager.setPowEnabled(true) },
+                                label = { 
+                                    Row(
+                                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                                        verticalAlignment = Alignment.CenterVertically
+                                    ) {
+                                        Text("pow on", fontFamily = FontFamily.Monospace)
+                                        // Show current difficulty
+                                        if (powEnabled) {
+                                            Surface(
+                                                color = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D),
+                                                shape = RoundedCornerShape(50)
+                                            ) { Box(Modifier.size(8.dp)) }
+                                        }
+                                    }
+                                }
+                            )
+                        }
+                        
+                        Text(
+                            text = "add proof of work to geohash messages for spam deterrence.",
+                            fontSize = 10.sp,
+                            fontFamily = FontFamily.Monospace,
+                            color = colorScheme.onSurface.copy(alpha = 0.6f)
+                        )
+                        
+                        // Show difficulty slider when enabled
+                        if (powEnabled) {
+                            Column(
+                                modifier = Modifier.fillMaxWidth(),
+                                verticalArrangement = Arrangement.spacedBy(8.dp)
+                            ) {
+                                Text(
+                                    text = "difficulty: $powDifficulty bits (~${NostrProofOfWork.estimateMiningTime(powDifficulty)})",
+                                    fontSize = 11.sp,
+                                    fontFamily = FontFamily.Monospace,
+                                    color = colorScheme.onSurface.copy(alpha = 0.7f)
+                                )
+                                
+                                Slider(
+                                    value = powDifficulty.toFloat(),
+                                    onValueChange = { PoWPreferenceManager.setPowDifficulty(it.toInt()) },
+                                    valueRange = 0f..20f,
+                                    steps = 21, // 20 discrete values (0-20)
+                                    colors = SliderDefaults.colors(
+                                        thumbColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D),
+                                        activeTrackColor = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
+                                    )
+                                )
+                                
+                                // Show difficulty description
+                                Surface(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    color = colorScheme.surfaceVariant.copy(alpha = 0.25f),
+                                    shape = RoundedCornerShape(8.dp)
+                                ) {
+                                    Column(
+                                        modifier = Modifier.padding(12.dp),
+                                        verticalArrangement = Arrangement.spacedBy(4.dp)
+                                    ) {
+                                        Text(
+                                            text = "difficulty $powDifficulty requires ~${NostrProofOfWork.estimateWork(powDifficulty)} hash attempts",
+                                            fontSize = 10.sp,
+                                            fontFamily = FontFamily.Monospace,
+                                            color = colorScheme.onSurface.copy(alpha = 0.7f)
+                                        )
+                                        Text(
+                                            text = when {
+                                                powDifficulty == 0 -> "no proof of work required"
+                                                powDifficulty <= 8 -> "very low - minimal spam protection"
+                                                powDifficulty <= 12 -> "low - basic spam protection"
+                                                powDifficulty <= 16 -> "medium - good spam protection"
+                                                powDifficulty <= 20 -> "high - strong spam protection"
+                                                powDifficulty <= 24 -> "very high - may cause delays"
+                                                else -> "extreme - significant computation required"
+                                            },
+                                            fontSize = 10.sp,
+                                            fontFamily = FontFamily.Monospace,
+                                            color = colorScheme.onSurface.copy(alpha = 0.6f)
+                                        )
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
                 // Network (Tor) section
                 item {
                     val ctx = LocalContext.current

app/src/main/java/com/bitchat/android/ui/ChatHeader.kt

@@ -571,6 +571,12 @@ private fun MainHeader(
 
             // Tor status cable icon when Tor is enabled
             TorStatusIcon(modifier = Modifier.size(14.dp))
+            
+            // PoW status indicator
+            PoWStatusIndicator(
+                modifier = Modifier,
+                style = PoWIndicatorStyle.COMPACT
+            )
 
             PeerCounter(
                 connectedPeers = connectedPeers.filter { it != viewModel.meshService.myPeerID },

app/src/main/java/com/bitchat/android/ui/ChatUIUtils.kt

@@ -117,11 +117,18 @@ fun formatMessageAsAnnotatedString(
         appendIOSFormattedContent(builder, message.content, message.mentions, currentUserNickname, baseColor, isSelf, isDark)
         
         // iOS-style timestamp at the END (smaller, grey)
+        // Timestamp (and optional PoW badge)
         builder.pushStyle(SpanStyle(
             color = Color.Gray.copy(alpha = 0.7f),
             fontSize = (BASE_FONT_SIZE - 4).sp
         ))
         builder.append(" [${timeFormatter.format(message.timestamp)}]")
+        // If message has valid PoW difficulty, append bits immediately after timestamp with minimal spacing
+        //message.powDifficulty?.let { bits ->
+        //    if (bits > 0) {
+        //        builder.append(" ${bits}b")
+        //    }
+        //}
         builder.pop()
         
     } else {

app/src/main/java/com/bitchat/android/ui/MatrixEncryptionAnimation.kt

@@ -0,0 +1,270 @@
+package com.bitchat.android.ui
+
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.font.FontFamily
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import kotlin.random.Random
+
+/**
+ * Animation state for individual characters
+ */
+private enum class CharacterAnimationState {
+    ENCRYPTED,    // Showing random encrypted characters
+    DECRYPTING,   // Transitioning to final character
+    FINAL         // Showing final decrypted character
+}
+
+/**
+ * Check if a message should be animated based on its mining state
+ */
+@Composable
+fun shouldAnimateMessage(messageId: String): Boolean {
+    val miningMessages by PoWMiningTracker.miningMessages.collectAsState()
+    return miningMessages.contains(messageId)
+}
+
+/**
+ * Tracks which messages are currently being mined for PoW
+ * Provides reactive state for UI animations
+ */
+object PoWMiningTracker {
+    private val _miningMessages = MutableStateFlow<Set<String>>(emptySet())
+    val miningMessages: StateFlow<Set<String>> = _miningMessages.asStateFlow()
+    
+    /**
+     * Start tracking a message as mining
+     */
+    fun startMiningMessage(messageId: String) {
+        _miningMessages.value = _miningMessages.value + messageId
+    }
+    
+    /**
+     * Stop tracking a message as mining
+     */
+    fun stopMiningMessage(messageId: String) {
+        _miningMessages.value = _miningMessages.value - messageId
+    }
+    
+    /**
+     * Check if a message is currently mining
+     */
+    fun isMiningMessage(messageId: String): Boolean {
+        return _miningMessages.value.contains(messageId)
+    }
+    
+    /**
+     * Clear all mining messages (for cleanup)
+     */
+    fun clearAllMining() {
+        _miningMessages.value = emptySet()
+    }
+}
+
+/**
+ * Enhanced message display that shows matrix animation during PoW mining
+ * Formats message like a normal message but animates only the content portion
+ */
+@Composable
+fun MessageWithMatrixAnimation(
+    message: com.bitchat.android.model.BitchatMessage,
+    currentUserNickname: String,
+    meshService: com.bitchat.android.mesh.BluetoothMeshService,
+    colorScheme: androidx.compose.material3.ColorScheme,
+    timeFormatter: java.text.SimpleDateFormat,
+    onNicknameClick: ((String) -> Unit)?,
+    onMessageLongPress: ((com.bitchat.android.model.BitchatMessage) -> Unit)?,
+    modifier: Modifier = Modifier
+) {
+    val isAnimating = shouldAnimateMessage(message.id)
+    
+    if (isAnimating) {
+        // During animation: Show formatted message with animated content
+        AnimatedMessageDisplay(
+            message = message,
+            currentUserNickname = currentUserNickname,
+            meshService = meshService,
+            colorScheme = colorScheme,
+            timeFormatter = timeFormatter,
+            modifier = modifier
+        )
+    } else {
+        // After animation: Show complete normal message using existing formatter
+        val annotatedText = formatMessageAsAnnotatedString(
+            message = message,
+            currentUserNickname = currentUserNickname,
+            meshService = meshService,
+            colorScheme = colorScheme,
+            timeFormatter = timeFormatter
+        )
+        
+        Text(
+            text = annotatedText,
+            modifier = modifier,
+            fontFamily = FontFamily.Monospace,
+            softWrap = true
+        )
+    }
+}
+
+/**
+ * Display message with proper formatting but animated content
+ * Uses IDENTICAL layout structure as normal message for pixel-perfect alignment
+ */
+@Composable
+private fun AnimatedMessageDisplay(
+    message: com.bitchat.android.model.BitchatMessage,
+    currentUserNickname: String,
+    meshService: com.bitchat.android.mesh.BluetoothMeshService,
+    colorScheme: androidx.compose.material3.ColorScheme,
+    timeFormatter: java.text.SimpleDateFormat,
+    modifier: Modifier = Modifier
+) {
+    // Get the animated content text
+    var animatedContent by remember(message.content) { mutableStateOf(message.content) }
+    val isAnimating = shouldAnimateMessage(message.id)
+    
+    // Character-by-character animation state like the JavaScript version
+    var characterStates by remember(message.content) { 
+        mutableStateOf(message.content.map { char -> 
+            if (char == ' ') CharacterAnimationState.FINAL else CharacterAnimationState.ENCRYPTED 
+        })
+    }
+    
+    // Update animated content when animation state changes
+    LaunchedEffect(isAnimating, message.content) {
+        if (isAnimating && message.content.isNotEmpty()) {
+            val encryptedChars = "!@$%^&*()_+-=[]{}|;:,<>?".toCharArray()
+            
+            // Start character animations with staggered delays (like JS version)
+            message.content.forEachIndexed { index, targetChar ->
+                if (targetChar != ' ') { // Skip spaces
+                    launch {
+                        delay(index * 50L) // Stagger start like JS version
+                        
+                        // Animate this character indefinitely in a loop
+                        while (true) {
+                            // Animate with random characters
+                            while (characterStates.getOrNull(index) == CharacterAnimationState.ENCRYPTED) {
+                                // Generate random encrypted character for this position
+                                val newContent = animatedContent.toCharArray()
+                                if (index < newContent.size) {
+                                    newContent[index] = encryptedChars[Random.nextInt(encryptedChars.size)]
+                                    animatedContent = String(newContent)
+                                }
+                                
+                                delay(100L) // Change character every 100ms like JS
+                                
+                                // Random chance to reveal (10% like JS version)
+                                if (Random.nextFloat() < 0.1f) {
+                                    // Reveal the final character
+                                    val finalContent = animatedContent.toCharArray()
+                                    if (index < finalContent.size) {
+                                        finalContent[index] = targetChar
+                                        animatedContent = String(finalContent)
+                                    }
+                                    
+                                    // Mark as revealed
+                                    val finalStates = characterStates.toMutableList()
+                                    finalStates[index] = CharacterAnimationState.FINAL
+                                    characterStates = finalStates
+                                    break
+                                }
+                            }
+                            
+                            // Keep revealed for 2 seconds, then fade back to encrypted (like JS)
+                            delay(2000L)
+                            
+                            // Reset back to encrypted for next cycle
+                            val resetStates = characterStates.toMutableList()
+                            resetStates[index] = CharacterAnimationState.ENCRYPTED
+                            characterStates = resetStates
+                        }
+                    }
+                }
+            }
+        } else {
+            // Not animating, show final content
+            animatedContent = message.content
+            characterStates = message.content.map { CharacterAnimationState.FINAL }
+        }
+    }
+    
+    // Create a temporary message with animated content for formatting
+    val animatedMessage = message.copy(content = animatedContent)
+    
+    // Use formatting function without timestamp during animation
+    val annotatedText = if (isAnimating) {
+        formatMessageAsAnnotatedStringWithoutTimestamp(
+            message = animatedMessage,
+            currentUserNickname = currentUserNickname,
+            meshService = meshService,
+            colorScheme = colorScheme
+        )
+    } else {
+        formatMessageAsAnnotatedString(
+            message = animatedMessage,
+            currentUserNickname = currentUserNickname,
+            meshService = meshService,
+            colorScheme = colorScheme,
+            timeFormatter = timeFormatter
+        )
+    }
+    
+    // Use IDENTICAL Text composable structure as normal message
+    Text(
+        text = annotatedText,
+        modifier = modifier,
+        fontFamily = FontFamily.Monospace,
+        softWrap = true,
+        overflow = androidx.compose.ui.text.style.TextOverflow.Visible,
+        style = androidx.compose.ui.text.TextStyle(
+            color = colorScheme.onSurface
+        )
+    )
+}
+
+
+/**
+ * Format message without timestamp and PoW badge for animation phase
+ * Identical to formatMessageAsAnnotatedString but excludes timestamp and PoW badge
+ */
+private fun formatMessageAsAnnotatedStringWithoutTimestamp(
+    message: com.bitchat.android.model.BitchatMessage,
+    currentUserNickname: String,
+    meshService: com.bitchat.android.mesh.BluetoothMeshService,
+    colorScheme: androidx.compose.material3.ColorScheme
+): AnnotatedString {
+    // Get the full formatted text first
+    val timeFormatter = java.text.SimpleDateFormat("HH:mm:ss", java.util.Locale.getDefault())
+    val fullText = formatMessageAsAnnotatedString(
+        message = message,
+        currentUserNickname = currentUserNickname,
+        meshService = meshService,
+        colorScheme = colorScheme,
+        timeFormatter = timeFormatter
+    )
+    
+    // Find and remove the timestamp and PoW badge at the end
+    val text = fullText.text
+    val timestampPattern = """ \[\d{2}:\d{2}:\d{2}].*$""".toRegex() // Matches " [HH:mm:ss] 12b" or just " [HH:mm:ss]"
+    val match = timestampPattern.find(text)
+    
+    return if (match != null) {
+        // Remove timestamp and PoW portion
+        val endIndex = match.range.first
+        AnnotatedString(
+            text = text.substring(0, endIndex),
+            spanStyles = fullText.spanStyles.filter { it.end <= endIndex },
+            paragraphStyles = fullText.paragraphStyles.filter { it.end <= endIndex }
+        )
+    } else {
+        fullText
+    }
+}

app/src/main/java/com/bitchat/android/ui/MessageComponents.kt

@@ -166,101 +166,120 @@ private fun MessageTextWithClickableNicknames(
     onMessageLongPress: ((BitchatMessage) -> Unit)?,
     modifier: Modifier = Modifier
 ) {
-    val annotatedText = formatMessageAsAnnotatedString(
-        message = message,
-        currentUserNickname = currentUserNickname,
-        meshService = meshService,
-        colorScheme = colorScheme,
-        timeFormatter = timeFormatter
-    )
+    // Check if this message should be animated during PoW mining
+    val shouldAnimate = shouldAnimateMessage(message.id)
     
-    // Check if this message was sent by self to avoid click interactions on own nickname
-    val isSelf = message.senderPeerID == meshService.myPeerID || 
-                 message.sender == currentUserNickname ||
-                 message.sender.startsWith("$currentUserNickname#")
-    
-    val haptic = LocalHapticFeedback.current
-    val context = LocalContext.current
-    var textLayoutResult by remember { mutableStateOf<TextLayoutResult?>(null) }
-    Text(
-        text = annotatedText,
-        modifier = modifier.pointerInput(message) {
-            detectTapGestures(
-                onTap = { position ->
-                    val layout = textLayoutResult ?: return@detectTapGestures
-                    val offset = layout.getOffsetForPosition(position)
-                    // Nickname click only when not self
-                    if (!isSelf && onNicknameClick != null) {
-                        val nicknameAnnotations = annotatedText.getStringAnnotations(
-                            tag = "nickname_click",
+    // If animation is needed, use the matrix animation component for content only
+    if (shouldAnimate) {
+        // Display message with matrix animation for content
+        MessageWithMatrixAnimation(
+            message = message,
+            currentUserNickname = currentUserNickname,
+            meshService = meshService,
+            colorScheme = colorScheme,
+            timeFormatter = timeFormatter,
+            onNicknameClick = onNicknameClick,
+            onMessageLongPress = onMessageLongPress,
+            modifier = modifier
+        )
+    } else {
+        // Normal message display
+        val annotatedText = formatMessageAsAnnotatedString(
+            message = message,
+            currentUserNickname = currentUserNickname,
+            meshService = meshService,
+            colorScheme = colorScheme,
+            timeFormatter = timeFormatter
+        )
+        
+        // Check if this message was sent by self to avoid click interactions on own nickname
+        val isSelf = message.senderPeerID == meshService.myPeerID || 
+                     message.sender == currentUserNickname ||
+                     message.sender.startsWith("$currentUserNickname#")
+        
+        val haptic = LocalHapticFeedback.current
+        val context = LocalContext.current
+        var textLayoutResult by remember { mutableStateOf<TextLayoutResult?>(null) }
+        Text(
+            text = annotatedText,
+            modifier = modifier.pointerInput(message) {
+                detectTapGestures(
+                    onTap = { position ->
+                        val layout = textLayoutResult ?: return@detectTapGestures
+                        val offset = layout.getOffsetForPosition(position)
+                        // Nickname click only when not self
+                        if (!isSelf && onNicknameClick != null) {
+                            val nicknameAnnotations = annotatedText.getStringAnnotations(
+                                tag = "nickname_click",
+                                start = offset,
+                                end = offset
+                            )
+                            if (nicknameAnnotations.isNotEmpty()) {
+                                val nickname = nicknameAnnotations.first().item
+                                haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+                                onNicknameClick.invoke(nickname)
+                                return@detectTapGestures
+                            }
+                        }
+                        // Geohash teleport (all messages)
+                        val geohashAnnotations = annotatedText.getStringAnnotations(
+                            tag = "geohash_click",
                             start = offset,
                             end = offset
                         )
-                        if (nicknameAnnotations.isNotEmpty()) {
-                            val nickname = nicknameAnnotations.first().item
+                        if (geohashAnnotations.isNotEmpty()) {
+                            val geohash = geohashAnnotations.first().item
+                            try {
+                                val locationManager = com.bitchat.android.geohash.LocationChannelManager.getInstance(
+                                    context
+                                )
+                                val level = when (geohash.length) {
+                                    in 0..2 -> com.bitchat.android.geohash.GeohashChannelLevel.REGION
+                                    in 3..4 -> com.bitchat.android.geohash.GeohashChannelLevel.PROVINCE
+                                    5 -> com.bitchat.android.geohash.GeohashChannelLevel.CITY
+                                    6 -> com.bitchat.android.geohash.GeohashChannelLevel.NEIGHBORHOOD
+                                    else -> com.bitchat.android.geohash.GeohashChannelLevel.BLOCK
+                                }
+                                val channel = com.bitchat.android.geohash.GeohashChannel(level, geohash.lowercase())
+                                locationManager.setTeleported(true)
+                                locationManager.select(com.bitchat.android.geohash.ChannelID.Location(channel))
+                            } catch (_: Exception) { }
                             haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
-                            onNicknameClick.invoke(nickname)
                             return@detectTapGestures
                         }
+                        // URL open (all messages)
+                        val urlAnnotations = annotatedText.getStringAnnotations(
+                            tag = "url_click",
+                            start = offset,
+                            end = offset
+                        )
+                        if (urlAnnotations.isNotEmpty()) {
+                            val raw = urlAnnotations.first().item
+                            val resolved = if (raw.startsWith("http://", ignoreCase = true) || raw.startsWith("https://", ignoreCase = true)) raw else "https://$raw"
+                            try {
+                                val intent = Intent(Intent.ACTION_VIEW, Uri.parse(resolved))
+                                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                                context.startActivity(intent)
+                            } catch (_: Exception) { }
+                            haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
+                            return@detectTapGestures
+                        }
+                    },
+                    onLongPress = {
+                        haptic.performHapticFeedback(HapticFeedbackType.LongPress)
+                        onMessageLongPress?.invoke(message)
                     }
-                    // Geohash teleport (all messages)
-                    val geohashAnnotations = annotatedText.getStringAnnotations(
-                        tag = "geohash_click",
-                        start = offset,
-                        end = offset
-                    )
-                    if (geohashAnnotations.isNotEmpty()) {
-                        val geohash = geohashAnnotations.first().item
-                        try {
-                            val locationManager = com.bitchat.android.geohash.LocationChannelManager.getInstance(
-                                context
-                            )
-                            val level = when (geohash.length) {
-                                in 0..2 -> com.bitchat.android.geohash.GeohashChannelLevel.REGION
-                                in 3..4 -> com.bitchat.android.geohash.GeohashChannelLevel.PROVINCE
-                                5 -> com.bitchat.android.geohash.GeohashChannelLevel.CITY
-                                6 -> com.bitchat.android.geohash.GeohashChannelLevel.NEIGHBORHOOD
-                                else -> com.bitchat.android.geohash.GeohashChannelLevel.BLOCK
-                            }
-                            val channel = com.bitchat.android.geohash.GeohashChannel(level, geohash.lowercase())
-                            locationManager.setTeleported(true)
-                            locationManager.select(com.bitchat.android.geohash.ChannelID.Location(channel))
-                        } catch (_: Exception) { }
-                        haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
-                        return@detectTapGestures
-                    }
-                    // URL open (all messages)
-                    val urlAnnotations = annotatedText.getStringAnnotations(
-                        tag = "url_click",
-                        start = offset,
-                        end = offset
-                    )
-                    if (urlAnnotations.isNotEmpty()) {
-                        val raw = urlAnnotations.first().item
-                        val resolved = if (raw.startsWith("http://", ignoreCase = true) || raw.startsWith("https://", ignoreCase = true)) raw else "https://$raw"
-                        try {
-                            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(resolved))
-                            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                            context.startActivity(intent)
-                        } catch (_: Exception) { }
-                        haptic.performHapticFeedback(HapticFeedbackType.TextHandleMove)
-                        return@detectTapGestures
-                    }
-                },
-                onLongPress = {
-                    haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-                    onMessageLongPress?.invoke(message)
-                }
-            )
-        },
-        fontFamily = FontFamily.Monospace,
-        softWrap = true,
-        overflow = TextOverflow.Visible,
-        style = androidx.compose.ui.text.TextStyle(
-            color = colorScheme.onSurface
-        ),
-        onTextLayout = { result -> textLayoutResult = result }
-    )
+                )
+            },
+            fontFamily = FontFamily.Monospace,
+            softWrap = true,
+            overflow = TextOverflow.Visible,
+            style = androidx.compose.ui.text.TextStyle(
+                color = colorScheme.onSurface
+            ),
+            onTextLayout = { result -> textLayoutResult = result }
+        )
+    }
 }
 
 @Composable

app/src/main/java/com/bitchat/android/ui/PoWStatusIndicator.kt

@@ -0,0 +1,194 @@
+package com.bitchat.android.ui
+
+import androidx.compose.animation.core.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Security
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.bitchat.android.nostr.NostrProofOfWork
+import com.bitchat.android.nostr.PoWPreferenceManager
+
+/**
+ * Shows the current Proof of Work status and settings
+ */
+@Composable
+fun PoWStatusIndicator(
+    modifier: Modifier = Modifier,
+    style: PoWIndicatorStyle = PoWIndicatorStyle.COMPACT
+) {
+    val powEnabled by PoWPreferenceManager.powEnabled.collectAsState()
+    val powDifficulty by PoWPreferenceManager.powDifficulty.collectAsState()
+    val isMining by PoWPreferenceManager.isMining.collectAsState()
+    val colorScheme = MaterialTheme.colorScheme
+    val isDark = colorScheme.background.red + colorScheme.background.green + colorScheme.background.blue < 1.5f
+    
+    if (!powEnabled) return
+    
+    when (style) {
+        PoWIndicatorStyle.COMPACT -> {
+            Row(
+                modifier = modifier,
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                // PoW icon with animation if mining
+                if (isMining) {
+                    val rotation by rememberInfiniteTransition(label = "pow-rotation").animateFloat(
+                        initialValue = 0f,
+                        targetValue = 360f,
+                        animationSpec = infiniteRepeatable(
+                            animation = tween(1000, easing = LinearEasing),
+                            repeatMode = RepeatMode.Restart
+                        ),
+                        label = "pow-icon-rotation"
+                    )
+                    
+                    Icon(
+                        imageVector = Icons.Filled.Security,
+                        contentDescription = "Mining PoW",
+                        tint = Color(0xFFFF9500), // Orange for mining
+                        modifier = Modifier
+                            .size(12.dp)
+                            .graphicsLayer { rotationZ = rotation }
+                    )
+                } else {
+                    Icon(
+                        imageVector = Icons.Filled.Security,
+                        contentDescription = "PoW Enabled",
+                        tint = if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D), // Green when ready
+                        modifier = Modifier.size(12.dp)
+                    )
+                }
+            }
+        }
+        
+        PoWIndicatorStyle.DETAILED -> {
+            Surface(
+                modifier = modifier,
+                color = colorScheme.surfaceVariant.copy(alpha = 0.3f),
+                shape = androidx.compose.foundation.shape.RoundedCornerShape(8.dp)
+            ) {
+                Row(
+                    modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
+                    horizontalArrangement = Arrangement.spacedBy(6.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
+                    // PoW icon
+                    Icon(
+                        imageVector = Icons.Filled.Security,
+                        contentDescription = "Proof of Work",
+                        tint = if (isMining) Color(0xFFFF9500) else {
+                            if (isDark) Color(0xFF32D74B) else Color(0xFF248A3D)
+                        },
+                        modifier = Modifier.size(14.dp)
+                    )
+                    
+                    // Status text
+                    Text(
+                        text = if (isMining) {
+                            "mining..."
+                        } else {
+                            "pow: ${powDifficulty}bit"
+                        },
+                        fontSize = 11.sp,
+                        fontFamily = FontFamily.Monospace,
+                        color = if (isMining) Color(0xFFFF9500) else {
+                            colorScheme.onSurface.copy(alpha = 0.7f)
+                        }
+                    )
+                    
+                    // Time estimate
+                    if (!isMining && powDifficulty > 0) {
+                        Text(
+                            text = "(~${NostrProofOfWork.estimateMiningTime(powDifficulty)})",
+                            fontSize = 9.sp,
+                            fontFamily = FontFamily.Monospace,
+                            color = colorScheme.onSurface.copy(alpha = 0.5f)
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Style options for the PoW status indicator
+ */
+enum class PoWIndicatorStyle {
+    COMPACT,    // Small icon + difficulty number
+    DETAILED    // Icon + status text + time estimate
+}
+
+/**
+ * Shows mining progress with animated indicator
+ */
+@Composable
+fun PoWMiningIndicator(
+    modifier: Modifier = Modifier,
+    difficulty: Int,
+    iterations: Int? = null
+) {
+    val colorScheme = MaterialTheme.colorScheme
+    
+    Surface(
+        modifier = modifier,
+        color = Color(0xFFFF9500).copy(alpha = 0.1f),
+        shape = androidx.compose.foundation.shape.RoundedCornerShape(8.dp)
+    ) {
+        Row(
+            modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            // Animated security icon
+            val rotation by rememberInfiniteTransition(label = "mining-rotation").animateFloat(
+                initialValue = 0f,
+                targetValue = 360f,
+                animationSpec = infiniteRepeatable(
+                    animation = tween(1000, easing = LinearEasing),
+                    repeatMode = RepeatMode.Restart
+                ),
+                label = "mining-icon-rotation"
+            )
+            
+            Icon(
+                imageVector = Icons.Filled.Security,
+                contentDescription = "Mining Proof of Work",
+                tint = Color(0xFFFF9500),
+                modifier = Modifier
+                    .size(16.dp)
+                    .graphicsLayer { rotationZ = rotation }
+            )
+            
+            Column(
+                verticalArrangement = Arrangement.spacedBy(2.dp)
+            ) {
+                Text(
+                    text = "mining proof of work...",
+                    fontSize = 12.sp,
+                    fontFamily = FontFamily.Monospace,
+                    fontWeight = FontWeight.Medium,
+                    color = Color(0xFFFF9500)
+                )
+                
+                Text(
+                    text = "difficulty: ${difficulty}bit (~${NostrProofOfWork.estimateMiningTime(difficulty)})" +
+                            if (iterations != null) " • ${iterations} attempts" else "",
+                    fontSize = 10.sp,
+                    fontFamily = FontFamily.Monospace,
+                    color = colorScheme.onSurface.copy(alpha = 0.7f)
+                )
+            }
+        }
+    }
+}