update concord backend

Reviewed-on: https://git.reya.su/reya/coop-mobile/pulls/52

.gitignore

@@ -17,3 +17,4 @@ captures
 !*.xcworkspace/contents.xcworkspacedata
 **/xcshareddata/WorkspaceSettings.xcsettings
 node_modules/
+.artifacts/

composeApp/build.gradle.kts

@@ -69,7 +69,7 @@ android {
         minSdk = libs.versions.android.minSdk.get().toInt()
         targetSdk = libs.versions.android.targetSdk.get().toInt()
         versionCode = 1
-        versionName = "0.2.4"
+        versionName = "0.2.6"
     }
     packaging {
         resources {

composeApp/src/androidMain/AndroidManifest.xml

@@ -7,6 +7,8 @@
         android:required="false" />
 
     <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

composeApp/src/androidMain/composeResources/drawable/ic_copy.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M360,720Q327,720 303.5,696.5Q280,673 280,640L280,160Q280,127 303.5,103.5Q327,80 360,80L720,80Q753,80 776.5,103.5Q800,127 800,160L800,640Q800,673 776.5,696.5Q753,720 720,720L360,720ZM360,640L720,640Q720,640 720,640Q720,640 720,640L720,160Q720,160 720,160Q720,160 720,160L360,160Q360,160 360,160Q360,160 360,160L360,640Q360,640 360,640Q360,640 360,640ZM200,880Q167,880 143.5,856.5Q120,833 120,800L120,240L200,240L200,800Q200,800 200,800Q200,800 200,800L640,800L640,880L200,880ZM360,640Q360,640 360,640Q360,640 360,640L360,160Q360,160 360,160Q360,160 360,160L360,160Q360,160 360,160Q360,160 360,160L360,640Q360,640 360,640Q360,640 360,640Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_info.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M440,680L520,680L520,440L440,440L440,680ZM508.5,348.5Q520,337 520,320Q520,303 508.5,291.5Q497,280 480,280Q463,280 451.5,291.5Q440,303 440,320Q440,337 451.5,348.5Q463,360 480,360Q497,360 508.5,348.5ZM480,880Q397,880 324,848.5Q251,817 197,763Q143,709 111.5,636Q80,563 80,480Q80,397 111.5,324Q143,251 197,197Q251,143 324,111.5Q397,80 480,80Q563,80 636,111.5Q709,143 763,197Q817,251 848.5,324Q880,397 880,480Q880,563 848.5,636Q817,709 763,763Q709,817 636,848.5Q563,880 480,880ZM480,800Q614,800 707,707Q800,614 800,480Q800,346 707,253Q614,160 480,160Q346,160 253,253Q160,346 160,480Q160,614 253,707Q346,800 480,800ZM480,480Q480,480 480,480Q480,480 480,480Q480,480 480,480Q480,480 480,480Q480,480 480,480Q480,480 480,480Q480,480 480,480Q480,480 480,480Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_reply.xml

@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:autoMirrored="true"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M760,760L760,600Q760,550 725,515Q690,480 640,480L273,480L417,624L360,680L120,440L360,200L417,256L273,400L640,400Q723,400 781.5,458.5Q840,517 840,600L840,760L760,760Z" />
+</vector>

composeApp/src/androidMain/kotlin/su/reya/coop/AndroidConnectivityMonitor.kt

@@ -0,0 +1,49 @@
+package su.reya.coop
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+class AndroidConnectivityMonitor(context: Context) : ConnectivityMonitor {
+    private val manager =
+        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+    
+    private val _isMobileData = MutableStateFlow(checkIsMobileData())
+    override val isMobileData: StateFlow<Boolean> = _isMobileData.asStateFlow()
+
+    init {
+        val networkRequest = NetworkRequest.Builder()
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build()
+
+        manager.registerNetworkCallback(
+            networkRequest,
+            object : ConnectivityManager.NetworkCallback() {
+                override fun onAvailable(network: Network) {
+                    _isMobileData.value = checkIsMobileData()
+                }
+
+                override fun onLost(network: Network) {
+                    _isMobileData.value = checkIsMobileData()
+                }
+
+                override fun onCapabilitiesChanged(
+                    network: Network,
+                    networkCapabilities: NetworkCapabilities
+                ) {
+                    _isMobileData.value = checkIsMobileData()
+                }
+            })
+    }
+
+    private fun checkIsMobileData(): Boolean {
+        val activeNetwork = manager.activeNetwork ?: return false
+        val capabilities = manager.getNetworkCapabilities(activeNetwork) ?: return false
+        return capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
+    }
+}

composeApp/src/androidMain/kotlin/su/reya/coop/App.kt

@@ -4,7 +4,6 @@ import android.app.Activity
 import android.content.Intent
 import android.os.Build
 import androidx.activity.ComponentActivity
-import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
@@ -26,7 +25,10 @@ import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.platform.LocalContext
 import androidx.core.util.Consumer
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
 import androidx.navigation3.runtime.NavBackStack
 import androidx.navigation3.runtime.NavKey
@@ -34,8 +36,10 @@ import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberNavBackStack
 import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
 import androidx.navigation3.ui.NavDisplay
-import su.reya.coop.repository.ErrorRepository
-import su.reya.coop.screens.chat.ChatScreen
+import kotlinx.coroutines.launch
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.SettingsRepository
 import su.reya.coop.screens.ContactListScreen
 import su.reya.coop.screens.HomeScreen
 import su.reya.coop.screens.ImportScreen
@@ -47,21 +51,25 @@ import su.reya.coop.screens.ProfileScreen
 import su.reya.coop.screens.RelayScreen
 import su.reya.coop.screens.RequestListScreen
 import su.reya.coop.screens.ScanScreen
+import su.reya.coop.screens.SettingsScreen
 import su.reya.coop.screens.UpdateProfileScreen
-import su.reya.coop.viewmodel.AuthViewModel
+import su.reya.coop.screens.chat.ChatScreen
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatScreenViewModel
 import su.reya.coop.viewmodel.ChatViewModel
-import su.reya.coop.viewmodel.NostrViewModel
+import su.reya.coop.viewmodel.ProfileCache
+import su.reya.coop.viewmodel.SettingsViewModel
 
-val LocalNostrViewModel = staticCompositionLocalOf<NostrViewModel> {
-    error("No NostrViewModel provided")
+val LocalProfileCache = staticCompositionLocalOf<ProfileCache> {
+    error("No ProfileCache provided")
 }
 
-val LocalChatViewModel = staticCompositionLocalOf<ChatViewModel> {
-    error("No ChatViewModel provided")
+val LocalSettings = staticCompositionLocalOf<Settings> {
+    error("No Settings provided")
 }
 
-val LocalAuthViewModel = staticCompositionLocalOf<AuthViewModel> {
-    error("No AuthViewModel provided")
+val LocalConnectivity = staticCompositionLocalOf<Boolean> {
+    false
 }
 
 val LocalSnackbarHostState = staticCompositionLocalOf<SnackbarHostState> {
@@ -79,10 +87,40 @@ val LocalScanResult = staticCompositionLocalOf<QrScanResult> {
 @OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
 @Composable
 fun App(
-    nostrViewModel: NostrViewModel,
-    chatViewModel: ChatViewModel,
-    authViewModel: AuthViewModel,
+    profileCache: ProfileCache,
+    accountRepository: AccountRepository,
+    chatRepository: ChatRepository,
+    settingsRepository: SettingsRepository,
+    connectivityMonitor: ConnectivityMonitor,
 ) {
+    val viewModelFactory = remember {
+        object : ViewModelProvider.Factory {
+            override fun <T : ViewModel> create(modelClass: Class<T>): T {
+                val result = when {
+                    modelClass.isAssignableFrom(ChatViewModel::class.java) -> ChatViewModel(
+                        chatRepository
+                    )
+
+                    modelClass.isAssignableFrom(AccountViewModel::class.java) -> AccountViewModel(
+                        accountRepository
+                    )
+
+                    modelClass.isAssignableFrom(SettingsViewModel::class.java) -> SettingsViewModel(
+                        settingsRepository
+                    )
+
+                    else -> throw IllegalArgumentException("Unknown ViewModel class")
+                }
+                @Suppress("UNCHECKED_CAST")
+                return result as T
+            }
+        }
+    }
+
+    val accountViewModel: AccountViewModel = viewModel(factory = viewModelFactory)
+    val chatViewModel: ChatViewModel = viewModel(factory = viewModelFactory)
+    val settingsViewModel: SettingsViewModel = viewModel(factory = viewModelFactory)
+
     val context = LocalContext.current
     val activity = context as? ComponentActivity
     val backStack = rememberNavBackStack(Screen.Home)
@@ -90,22 +128,30 @@ fun App(
     val qrScanResult = remember { QrScanResult() }
 
     // Get the signer required state
-    val authState by authViewModel.state.collectAsStateWithLifecycle()
-    val signerRequired = authState.signerRequired
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val signerRequired = accountState.signerRequired
+
+    // Get the settings
+    val settings by settingsViewModel.settings.collectAsStateWithLifecycle()
+
+    // Get connectivity status
+    val isMobileData by connectivityMonitor.isMobileData.collectAsStateWithLifecycle()
 
     // Snackbar
     val snackbarHostState = remember { SnackbarHostState() }
 
     // Check if dark theme enabled
-    val darkMode = isSystemInDarkTheme()
+    val darkMode = when (settings.theme) {
+        Theme.Light -> false
+        Theme.Dark -> true
+        Theme.System -> isSystemInDarkTheme()
+    }
 
     // Enabled the dynamic color scheme
     val colorScheme = when {
         // Enable the dynamic color scheme for Android 12+
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
-            if (isSystemInDarkTheme()) dynamicDarkColorScheme(context) else dynamicLightColorScheme(
-                context
-            )
+        settings.dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            if (darkMode) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
         }
         // When dark mode is enabled, use the dark color scheme
         darkMode -> darkColorScheme()
@@ -113,13 +159,21 @@ fun App(
         else -> expressiveLightColorScheme()
     }
 
-    BackHandler(enabled = backStack.size > 1) {
-        navigator.goBack()
-    }
-
     LaunchedEffect(Unit) {
-        ErrorRepository.errors.collect { message ->
-            snackbarHostState.showSnackbar(message)
+        launch {
+            accountViewModel.errorEvents.collect { message ->
+                snackbarHostState.showSnackbar(message)
+            }
+        }
+        launch {
+            chatViewModel.errorEvents.collect { message ->
+                snackbarHostState.showSnackbar(message)
+            }
+        }
+        launch {
+            profileCache.errorEvents.collect { message ->
+                snackbarHostState.showSnackbar(message)
+            }
         }
     }
 
@@ -128,7 +182,7 @@ fun App(
             fun handleIntent(intent: Intent) {
                 val screen = Screen.fromIntent(intent)
                 // Prevent pushing the same screen
-                if (screen != null && backStack.lastOrNull() != screen) {
+                if ((screen != null) && (backStack.lastOrNull() != screen)) {
                     navigator.navigate(screen)
                 }
             }
@@ -161,14 +215,13 @@ fun App(
         motionScheme = MotionScheme.expressive(),
     ) {
         CompositionLocalProvider(
-            LocalNostrViewModel provides nostrViewModel,
-            LocalChatViewModel provides chatViewModel,
-            LocalAuthViewModel provides authViewModel,
+            LocalProfileCache provides profileCache,
+            LocalSettings provides settings,
+            LocalConnectivity provides isMobileData,
             LocalSnackbarHostState provides snackbarHostState,
             LocalNavigator provides navigator,
             LocalScanResult provides qrScanResult,
         ) {
-
             NavDisplay(
                 backStack = backStack,
                 onBack = {
@@ -184,43 +237,65 @@ fun App(
                 ),
                 entryProvider = entryProvider {
                     entry<Screen.Home> {
-                        HomeScreen()
+                        HomeScreen(accountViewModel, chatViewModel)
                     }
                     entry<Screen.RequestList> {
-                        RequestListScreen()
+                        RequestListScreen(chatViewModel)
                     }
                     entry<Screen.Onboarding> {
-                        OnboardingScreen()
+                        OnboardingScreen(accountViewModel)
                     }
                     entry<Screen.Import> {
-                        ImportScreen()
+                        ImportScreen(accountViewModel)
                     }
                     entry<Screen.NewIdentity> {
-                        NewIdentityScreen()
+                        NewIdentityScreen(accountViewModel)
                     }
                     entry<Screen.Chat> { key ->
-                        ChatScreen(id = key.id, screening = key.screening)
+                        val factory = remember(key) {
+                            object : ViewModelProvider.Factory {
+                                override fun <T : ViewModel> create(modelClass: Class<T>): T {
+                                    @Suppress("UNCHECKED_CAST")
+                                    return ChatScreenViewModel(
+                                        key.id,
+                                        key.screening,
+                                        accountRepository,
+                                        chatRepository
+                                    ) as T
+                                }
+                            }
+                        }
+                        ChatScreen(
+                            viewModel<ChatScreenViewModel>(
+                                key = key.id.toString(),
+                                factory = factory
+                            ),
+                            accountViewModel
+                        )
                     }
                     entry<Screen.NewChat> {
-                        NewChatScreen()
+                        NewChatScreen(accountViewModel, chatViewModel)
                     }
                     entry<Screen.Profile> { key ->
-                        ProfileScreen(pubkey = key.pubkey)
+                        ProfileScreen(pubkey = key.pubkey, chatViewModel = chatViewModel)
                     }
                     entry<Screen.UpdateProfile> {
-                        UpdateProfileScreen()
+                        UpdateProfileScreen(accountViewModel)
                     }
                     entry<Screen.Scan> {
                         ScanScreen()
                     }
                     entry<Screen.MyQr> {
-                        MyQrScreen()
+                        MyQrScreen(accountViewModel)
                     }
                     entry<Screen.ContactList> {
-                        ContactListScreen()
+                        ContactListScreen(accountViewModel, chatViewModel)
                     }
                     entry<Screen.Relay> {
-                        RelayScreen()
+                        RelayScreen(accountViewModel)
+                    }
+                    entry<Screen.Settings> {
+                        SettingsScreen(settingsViewModel)
                     }
                 }
             )

composeApp/src/androidMain/kotlin/su/reya/coop/AppStorage.kt

@@ -1,8 +1,13 @@
-package su.reya.coop.coop.storage
+package su.reya.coop
 
+import android.content.Context
 import android.security.keystore.KeyGenParameterSpec
 import android.security.keystore.KeyProperties
 import android.util.Base64
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import kotlinx.coroutines.flow.first
 import java.nio.charset.StandardCharsets
 import java.security.KeyStore
 import javax.crypto.Cipher
@@ -10,10 +15,9 @@ import javax.crypto.KeyGenerator
 import javax.crypto.SecretKey
 import javax.crypto.spec.GCMParameterSpec
 
-data class SecretEntry(
-    val encrypted: String,
-    val iv: String
-)
+private val Context.dataStore by preferencesDataStore("secret_store")
+
+data class SecretEntry(val encrypted: String, val iv: String)
 
 class SecretCrypto {
     private val keyAlias = "coop"
@@ -21,11 +25,9 @@ class SecretCrypto {
     private val transformation = "AES/GCM/NoPadding"
 
     fun encrypt(content: String): SecretEntry {
-        // Initialize cipher
         val cipher = Cipher.getInstance(transformation)
         cipher.init(Cipher.ENCRYPT_MODE, getOrCreateKey())
 
-        // Encrypt content
         val encrypted = cipher.doFinal(content.toByteArray())
         val iv = cipher.iv
 
@@ -39,12 +41,10 @@ class SecretCrypto {
         val encrypted = Base64.decode(entry.encrypted, Base64.NO_WRAP)
         val iv = Base64.decode(entry.iv, Base64.NO_WRAP)
 
-        // Initialize cipher
         val cipher = Cipher.getInstance(transformation)
         val spec = GCMParameterSpec(128, iv)
         cipher.init(Cipher.DECRYPT_MODE, getOrCreateKey(), spec)
 
-        // Decrypt content
         val plaintext = cipher.doFinal(encrypted)
 
         return String(plaintext, StandardCharsets.UTF_8)
@@ -54,13 +54,9 @@ class SecretCrypto {
         val keyStore = KeyStore.getInstance(keyStoreType).apply { load(null) }
         val existingKey = keyStore.getKey(keyAlias, null)
 
-        // Return existing key if available
         if (existingKey is SecretKey) return existingKey
 
-        // Construct a new key generator
         val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, keyStoreType)
-
-        // Initialize key generation parameters
         val spec = KeyGenParameterSpec.Builder(
             keyAlias,
             KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
@@ -70,9 +66,49 @@ class SecretCrypto {
             .setKeySize(256)
             .build()
 
-        // Generate a new key
         keyGenerator.init(spec)
-
         return keyGenerator.generateKey()
     }
-}
+}
+
+class AppStore(private val context: Context) : AppStorage {
+    private val crypto = SecretCrypto()
+
+    override suspend fun get(key: String): String? {
+        return context.dataStore.data.first()[stringPreferencesKey(key)]
+    }
+
+    override suspend fun set(key: String, value: String) {
+        context.dataStore.edit { it[stringPreferencesKey(key)] = value }
+    }
+
+    override suspend fun getSecret(key: String): String? {
+        val prefs = context.dataStore.data.first()
+        val encrypted = prefs[stringPreferencesKey("${key}_encrypted")] ?: return null
+        val iv = prefs[stringPreferencesKey("${key}_iv")] ?: return null
+
+        return crypto.decrypt(SecretEntry(encrypted, iv))
+    }
+
+    override suspend fun setSecret(key: String, value: String) {
+        val entry = crypto.encrypt(value)
+        context.dataStore.edit { prefs ->
+            prefs[stringPreferencesKey("${key}_encrypted")] = entry.encrypted
+            prefs[stringPreferencesKey("${key}_iv")] = entry.iv
+        }
+    }
+
+    override suspend fun clear(key: String) {
+        context.dataStore.edit { prefs ->
+            prefs.remove(stringPreferencesKey(key))
+            prefs.remove(stringPreferencesKey("${key}_encrypted"))
+            prefs.remove(stringPreferencesKey("${key}_iv"))
+        }
+    }
+
+    override suspend fun has(key: String): Boolean {
+        val prefs = context.dataStore.data.first()
+        return prefs.contains(stringPreferencesKey(key)) ||
+                prefs.contains(stringPreferencesKey("${key}_encrypted"))
+    }
+}

composeApp/src/androidMain/kotlin/su/reya/coop/ExternalSignerLauncher.kt

@@ -4,12 +4,15 @@ import android.content.Intent
 import androidx.activity.result.ActivityResult
 import androidx.activity.result.ActivityResultLauncher
 import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 
-class ExternalSignerLauncher {
+class ExternalSignerLauncher(
+    private val mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
+) {
     private var launcher: ActivityResultLauncher<Intent>? = null
     private var pendingResult: CompletableDeferred<ActivityResult>? = null
     private val mutex = Mutex()
@@ -19,7 +22,7 @@ class ExternalSignerLauncher {
     }
 
     suspend fun launch(intent: Intent): ActivityResult = mutex.withLock {
-        withContext(Dispatchers.Main) {
+        withContext(mainDispatcher) {
             val deferred = CompletableDeferred<ActivityResult>()
             pendingResult = deferred
             launcher?.launch(intent) ?: throw IllegalStateException("Signer not registered")

composeApp/src/androidMain/kotlin/su/reya/coop/MainActivity.kt

@@ -8,15 +8,14 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.activity.viewModels
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.ViewModelProvider
-import su.reya.coop.coop.storage.SecretStore
+import kotlinx.coroutines.MainScope
 import su.reya.coop.nostr.NostrManager
-import su.reya.coop.viewmodel.AuthViewModel
-import su.reya.coop.viewmodel.ChatViewModel
-import su.reya.coop.viewmodel.NostrViewModel
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.MediaRepository
+import su.reya.coop.repository.SettingsRepository
+import su.reya.coop.viewmodel.ProfileCache
 import kotlin.system.exitProcess
 
 class MainActivity : ComponentActivity() {
@@ -24,32 +23,34 @@ class MainActivity : ComponentActivity() {
         val externalSignerLauncher = ExternalSignerLauncher()
     }
 
-    private val factory by lazy {
-        object : ViewModelProvider.Factory {
-            private val androidSigner =
-                AndroidExternalSigner(this@MainActivity, externalSignerLauncher)
-            private val secretStore = SecretStore(this@MainActivity)
-            private val nostrViewModel =
-                NostrViewModel(NostrManager.instance)
-            private val chatViewModel =
-                ChatViewModel(NostrManager.instance)
-            private val authViewModel =
-                AuthViewModel(NostrManager.instance, secretStore, androidSigner)
+    private val profileCache by lazy { ProfileCache(NostrManager.instance) }
+    private val scope = MainScope()
 
-            override fun <T : ViewModel> create(modelClass: Class<T>): T {
-                return when {
-                    modelClass.isAssignableFrom(NostrViewModel::class.java) -> nostrViewModel
-                    modelClass.isAssignableFrom(ChatViewModel::class.java) -> chatViewModel
-                    modelClass.isAssignableFrom(AuthViewModel::class.java) -> authViewModel
-                    else -> throw IllegalArgumentException("Unknown ViewModel class")
-                } as T
-            }
-        }
+    private val connectivityMonitor by lazy { AndroidConnectivityMonitor(this@MainActivity) }
+
+    private val settingsRepository by lazy {
+        val storage = AppStore(this@MainActivity)
+        SettingsRepository(storage, scope)
     }
 
-    private val nostrViewModel: NostrViewModel by viewModels { factory }
-    private val chatViewModel: ChatViewModel by viewModels { factory }
-    private val authViewModel: AuthViewModel by viewModels { factory }
+    private val accountRepository by lazy {
+        val storage = AppStore(this@MainActivity)
+        val mediaRepository = MediaRepository(settingsRepository)
+        val androidSigner = AndroidExternalSigner(this@MainActivity, externalSignerLauncher)
+        AccountRepository(
+            NostrManager.instance,
+            storage,
+            mediaRepository,
+            settingsRepository,
+            scope,
+            androidSigner
+        )
+    }
+
+    private val chatRepository by lazy {
+        val mediaRepository = MediaRepository(settingsRepository)
+        ChatRepository(NostrManager.instance, mediaRepository, settingsRepository, scope)
+    }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
@@ -88,14 +89,16 @@ class MainActivity : ComponentActivity() {
 
         // Keep the splash screen visible until the signer check is complete
         splashScreen.setKeepOnScreenCondition {
-            authViewModel.state.value.signerRequired == null
+            accountRepository.state.value.signerRequired == null
         }
 
         setContent {
             App(
-                nostrViewModel = nostrViewModel,
-                chatViewModel = chatViewModel,
-                authViewModel = authViewModel,
+                profileCache = profileCache,
+                accountRepository = accountRepository,
+                chatRepository = chatRepository,
+                settingsRepository = settingsRepository,
+                connectivityMonitor = connectivityMonitor,
             )
         }
     }

composeApp/src/androidMain/kotlin/su/reya/coop/Navigation.kt

@@ -58,4 +58,7 @@ sealed interface Screen : NavKey {
 
     @Serializable
     data object Relay : Screen
+
+    @Serializable
+    data object Settings : Screen
 }

composeApp/src/androidMain/kotlin/su/reya/coop/NostrForegroundService.kt

@@ -11,6 +11,7 @@ import android.os.Build
 import android.os.IBinder
 import android.util.Log
 import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
 import androidx.core.net.toUri
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.ProcessLifecycleOwner
@@ -62,7 +63,7 @@ class NostrForegroundService : Service() {
 
                 // Initialize Nostr client
                 try {
-                    nostr.init(dbDir.absolutePath)
+                    nostr.init(dbDir.absolutePath, AppStore(this@NostrForegroundService))
                 } catch (e: Exception) {
                     throw IllegalStateException("Failed to initialize Nostr Client", e)
                 }
@@ -188,4 +189,13 @@ class NostrForegroundService : Service() {
         super.onDestroy()
         serviceScope.cancel()
     }
+
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        super.onTaskRemoved(rootIntent)
+        if (!NotificationManagerCompat.from(this).areNotificationsEnabled()) {
+            Log.d("Coop", "Stopping service on task removed because notifications are disabled")
+            stopForeground(STOP_FOREGROUND_REMOVE)
+            stopSelf()
+        }
+    }
 }

composeApp/src/androidMain/kotlin/su/reya/coop/screens/ContactListScreen.kt

@@ -33,11 +33,9 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTooltipState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -55,27 +53,28 @@ import coop.composeapp.generated.resources.ic_check
 import coop.composeapp.generated.resources.ic_close
 import coop.composeapp.generated.resources.ic_plus
 import coop.composeapp.generated.resources.ic_scanner
-import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.Nip05Address
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
 import su.reya.coop.short
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun ContactListScreen() {
+fun ContactListScreen(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
     val navigator = LocalNavigator.current
     val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-
-    val contactList by nostrViewModel.contactList.collectAsStateWithLifecycle()
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val contactList = accountState.contactList
     var openAddContactDialog by remember { mutableStateOf(false) }
     var contactToDelete by remember { mutableStateOf<PublicKey?>(null) }
 
@@ -191,7 +190,10 @@ fun ContactListScreen() {
     )
 
     if (openAddContactDialog) {
-        AddContactDialog(onDismissRequest = { openAddContactDialog = false })
+        AddContactDialog(
+            accountViewModel = accountViewModel,
+            onDismissRequest = { openAddContactDialog = false }
+        )
     }
 
     if (contactToDelete != null) {
@@ -202,7 +204,7 @@ fun ContactListScreen() {
             confirmButton = {
                 TextButton(
                     onClick = {
-                        contactToDelete?.let { nostrViewModel.removeContact(it) }
+                        contactToDelete?.let { accountViewModel.removeContact(it) }
                         contactToDelete = null
                     }
                 ) {
@@ -220,15 +222,15 @@ fun ContactListScreen() {
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun AddContactDialog(onDismissRequest: () -> Unit) {
+fun AddContactDialog(
+    accountViewModel: AccountViewModel,
+    onDismissRequest: () -> Unit,
+) {
     val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
     val focusRequester = remember { FocusRequester() }
     var contact by remember { mutableStateOf("") }
     var isError by remember { mutableStateOf(false) }
 
-    val scope = rememberCoroutineScope()
-
     LaunchedEffect(Unit) {
         focusRequester.requestFocus()
     }
@@ -266,10 +268,8 @@ fun AddContactDialog(onDismissRequest: () -> Unit) {
                     },
                     actions = {
                         IconButton(onClick = {
-                            scope.launch {
-                                val success = nostrViewModel.addContact(contact)
-                                if (success) onDismissRequest()
-                            }
+                            accountViewModel.addContact(contact)
+                            onDismissRequest()
                         }) {
                             Icon(
                                 painter = painterResource(Res.drawable.ic_check),
@@ -326,9 +326,9 @@ fun ContactListItem(
     onClick: () -> Unit,
     onLongClick: () -> Unit,
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
-    val profile by profileFlow.collectAsState(initial = null)
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsStateWithLifecycle(initialValue = null)
 
     SegmentedListItem(
         onClick = onClick,

composeApp/src/androidMain/kotlin/su/reya/coop/screens/HomeScreen.kt

@@ -7,6 +7,7 @@ import android.os.Build
 import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -24,6 +25,8 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Badge
+import androidx.compose.material3.BadgedBox
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -86,50 +89,52 @@ import coop.composeapp.generated.resources.ic_new_chat
 import coop.composeapp.generated.resources.ic_qr
 import coop.composeapp.generated.resources.ic_request
 import coop.composeapp.generated.resources.ic_scanner
+import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalAuthViewModel
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Room
 import su.reya.coop.RoomKind
+import su.reya.coop.RoomUiState
 import su.reya.coop.Screen
 import su.reya.coop.ago
-import su.reya.coop.rememberUiState
 import su.reya.coop.shared.Avatar
 import su.reya.coop.shared.getExpressiveFontFamily
+import su.reya.coop.uiStateFlow
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
 @Composable
-fun HomeScreen() {
+fun HomeScreen(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
     val context = LocalContext.current
     val navigator = LocalNavigator.current
     val qrScanResult = LocalScanResult.current
     val snackbarHostState = LocalSnackbarHostState.current
     val clipboardManager = LocalClipboard.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-    val authViewModel = LocalAuthViewModel.current
 
     val scope = rememberCoroutineScope()
     val sheetState = rememberModalBottomSheetState(true)
     val listState = rememberLazyListState()
     val pullToRefreshState = rememberPullToRefreshState()
 
-    val userProfile by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val userProfile by accountViewModel.currentUserProfile.collectAsStateWithLifecycle()
     val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()
 
-    val isRelayListEmpty by nostrViewModel.isRelayListEmpty.collectAsStateWithLifecycle()
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val isRelayListEmpty = accountState.isRelayListEmpty
+    val isBannerDismissed = accountState.isNotificationBannerDismissed
+
     val isSyncing by chatViewModel.isSyncing.collectAsStateWithLifecycle()
     val isPartialProcessedGiftWrap by chatViewModel.isPartialProcessedGiftWrap.collectAsStateWithLifecycle()
 
-    val authState by authViewModel.state.collectAsStateWithLifecycle()
-    val isBannerDismissed = authState.isNotificationBannerDismissed
-
     val expandedFab by remember { derivedStateOf { listState.firstVisibleItemIndex == 0 } }
     var showBottomSheet by remember { mutableStateOf(false) }
     var isRefreshing by remember { mutableStateOf(false) }
@@ -155,7 +160,7 @@ fun HomeScreen() {
         onPauseOrDispose { }
     }
 
-    LaunchedEffect(Unit) {
+    LaunchedEffect(accountState.signerRequired) {
         chatViewModel.refreshChatRooms()
     }
 
@@ -248,7 +253,9 @@ fun HomeScreen() {
                 modifier = Modifier.padding(top = innerPadding.calculateTopPadding()),
                 verticalArrangement = Arrangement.spacedBy(16.dp),
             ) {
-                if (!isNotificationEnabled && !isBannerDismissed) {
+                AnimatedVisibility(
+                    visible = !isNotificationEnabled && !isBannerDismissed,
+                ) {
                     Surface(
                         modifier = Modifier
                             .fillMaxWidth()
@@ -280,7 +287,7 @@ fun HomeScreen() {
                                 horizontalArrangement = Arrangement.spacedBy(8.dp),
                             ) {
                                 TextButton(
-                                    onClick = { authViewModel.dismissNotificationBanner() },
+                                    onClick = { accountViewModel.dismissNotificationBanner() },
                                     modifier = Modifier.weight(1f),
                                 ) {
                                     Text(text = "Maybe later")
@@ -319,11 +326,9 @@ fun HomeScreen() {
                         isRefreshing = isRefreshing,
                         state = pullToRefreshState,
                         onRefresh = {
-                            scope.launch {
-                                isRefreshing = true
-                                chatViewModel.refreshChatRooms()
-                                isRefreshing = false
-                            }
+                            isRefreshing = true
+                            chatViewModel.refreshChatRooms()
+                            isRefreshing = false
                         },
                         indicator = {
                             PullToRefreshDefaults.LoadingIndicator(
@@ -373,10 +378,14 @@ fun HomeScreen() {
                                 }
 
                                 items(ongoing, key = { it.id }) { room ->
-                                    ChatRoom(
-                                        room = room,
-                                        onClick = { navigator.navigate(Screen.Chat(room.id)) }
-                                    )
+                                    Row(
+                                        modifier = Modifier.animateItem()
+                                    ) {
+                                        ChatRoom(
+                                            room = room,
+                                            onClick = { navigator.navigate(Screen.Chat(room.id)) }
+                                        )
+                                    }
                                 }
                             }
                         }
@@ -461,7 +470,11 @@ fun HomeScreen() {
                     }
                 }
                 Spacer(modifier = Modifier.size(16.dp))
-                BottomMenuList(onDismiss = dismissAndRun)
+                BottomMenuList(
+                    onDismiss = dismissAndRun,
+                    accountViewModel = accountViewModel,
+                    chatViewModel = chatViewModel
+                )
             }
         }
     }
@@ -469,7 +482,7 @@ fun HomeScreen() {
     // Show the relay setup dialog if the msg relay list is empty
     if (isRelayListEmpty) {
         ModalBottomSheet(
-            onDismissRequest = { nostrViewModel.dismissRelayWarning() },
+            onDismissRequest = { accountViewModel.dismissRelayWarning() },
             sheetState = sheetState,
             containerColor = MaterialTheme.colorScheme.surfaceContainer,
         ) {
@@ -573,15 +586,9 @@ fun HomeScreen() {
                         TextButton(
                             enabled = !isBusy,
                             onClick = {
-                                scope.launch {
-                                    isBusy = true
-                                    try {
-                                        nostrViewModel.refetchMsgRelays()
-                                    } catch (e: Exception) {
-                                        snackbarHostState.showSnackbar("Failed to refresh metadata: ${e.message}")
-                                    }
-                                    isBusy = false
-                                }
+                                isBusy = true
+                                accountViewModel.refetchMsgRelays()
+                                isBusy = false
                             },
                             modifier = Modifier
                                 .weight(1f)
@@ -595,10 +602,8 @@ fun HomeScreen() {
                         Button(
                             enabled = !isBusy,
                             onClick = {
-                                scope.launch {
-                                    nostrViewModel.useDefaultMsgRelayList()
-                                    sheetState.hide()
-                                }
+                                accountViewModel.useDefaultMsgRelayList()
+                                scope.launch { sheetState.hide() }
                             },
                             modifier = Modifier
                                 .weight(1f)
@@ -619,17 +624,22 @@ fun HomeScreen() {
 @Composable
 fun NewRequests(requests: List<Room>) {
     val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
+    val profileCache = LocalProfileCache.current
 
     val total = requests.size
     val firstRoom = requests.getOrNull(0)
     val secondRoom = requests.getOrNull(1)
 
-    val firstRoomState by (firstRoom as Room).rememberUiState(nostrViewModel)
-    val secondRoomState by (secondRoom ?: firstRoom).rememberUiState(nostrViewModel)
+    val firstRoomState by remember(firstRoom?.id) {
+        firstRoom?.uiStateFlow(profileCache) ?: flowOf(RoomUiState())
+    }.collectAsStateWithLifecycle(RoomUiState())
+
+    val secondRoomState by remember(secondRoom?.id) {
+        (secondRoom ?: firstRoom)?.uiStateFlow(profileCache) ?: flowOf(RoomUiState())
+    }.collectAsStateWithLifecycle(RoomUiState())
 
     val supportingText = when {
-        total == 1 -> {
+        total == 1 && firstRoom != null -> {
             val message = firstRoom.lastMessage ?: ""
             "${firstRoomState.name}: $message"
         }
@@ -647,27 +657,39 @@ fun NewRequests(requests: List<Room>) {
         else -> ""
     }
 
+    val totalUnread = requests.sumOf { it.unreadCount }
+
     ListItem(
         modifier = Modifier.clickable {
             navigator.navigate(Screen.RequestList)
         },
         leadingContent = {
-            Box(
-                modifier = Modifier
-                    .size(48.dp)
-                    .clip(MaterialShapes.Clover4Leaf.toShape()),
-                contentAlignment = Alignment.Center
+            BadgedBox(
+                badge = {
+                    if (totalUnread > 0) {
+                        Badge {
+                            Text(totalUnread.toString())
+                        }
+                    }
+                }
             ) {
-                Surface(
-                    modifier = Modifier.size(48.dp),
-                    color = MaterialTheme.colorScheme.tertiaryContainer,
+                Box(
+                    modifier = Modifier
+                        .size(48.dp)
+                        .clip(MaterialShapes.Clover4Leaf.toShape()),
+                    contentAlignment = Alignment.Center
                 ) {
-                    Box(contentAlignment = Alignment.Center) {
-                        Icon(
-                            painter = painterResource(Res.drawable.ic_request),
-                            contentDescription = "Requests",
-                            tint = MaterialTheme.colorScheme.onTertiaryFixed
-                        )
+                    Surface(
+                        modifier = Modifier.size(48.dp),
+                        color = MaterialTheme.colorScheme.tertiaryContainer,
+                    ) {
+                        Box(contentAlignment = Alignment.Center) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_request),
+                                contentDescription = "Requests",
+                                tint = MaterialTheme.colorScheme.onTertiaryFixed
+                            )
+                        }
                     }
                 }
             }
@@ -675,14 +697,19 @@ fun NewRequests(requests: List<Room>) {
         headlineContent = {
             Text(
                 text = "Requests",
-                style = MaterialTheme.typography.titleMediumEmphasized
+                style = MaterialTheme.typography.titleMediumEmphasized.copy(
+                    fontWeight = if (totalUnread > 0) FontWeight.SemiBold else FontWeight.Normal
+                )
             )
         },
         supportingContent = {
             if (supportingText.isNotEmpty()) {
                 Text(
                     text = supportingText,
-                    style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium.copy(
+                        fontWeight = if (totalUnread > 0) FontWeight.SemiBold else FontWeight.Normal,
+                        color = if (totalUnread > 0) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.outline
+                    ),
                     maxLines = 1,
                     overflow = TextOverflow.Ellipsis
                 )
@@ -697,28 +724,42 @@ fun NewRequests(requests: List<Room>) {
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun ChatRoom(room: Room, onClick: () -> Unit) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val roomState by room.rememberUiState(nostrViewModel)
+    val profileCache = LocalProfileCache.current
+    val roomState by remember(room.id) { room.uiStateFlow(profileCache) }
+        .collectAsStateWithLifecycle(RoomUiState())
 
     ListItem(
         modifier = Modifier.clickable(onClick = onClick),
         leadingContent = {
-            Avatar(picture = roomState.picture, description = roomState.picture)
+            BadgedBox(
+                badge = {
+                    if (room.unreadCount > 0) {
+                        Badge {
+                            Text(room.unreadCount.toString())
+                        }
+                    }
+                }
+            ) {
+                Avatar(picture = roomState.picture, description = roomState.picture)
+            }
         },
         headlineContent = {
             Row(
                 modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically
+                verticalAlignment = Alignment.CenterVertically,
             ) {
                 Text(
                     text = roomState.name,
-                    style = MaterialTheme.typography.titleMediumEmphasized,
+                    style = MaterialTheme.typography.titleMediumEmphasized.copy(
+                        fontWeight = if (room.unreadCount > 0) FontWeight.SemiBold else FontWeight.Normal
+                    ),
                     modifier = Modifier.weight(1f)
                 )
                 Text(
                     text = room.createdAt.ago(),
                     style = MaterialTheme.typography.bodySmall,
-                    color = MaterialTheme.colorScheme.outline
+                    color = MaterialTheme.colorScheme.outline,
+                    textAlign = TextAlign.End,
                 )
             }
         },
@@ -726,7 +767,10 @@ fun ChatRoom(room: Room, onClick: () -> Unit) {
             if (!room.lastMessage.isNullOrBlank()) {
                 Text(
                     text = room.lastMessage ?: "",
-                    style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium.copy(
+                        fontWeight = if (room.unreadCount > 0) FontWeight.SemiBold else FontWeight.Normal,
+                        color = if (room.unreadCount > 0) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.outline
+                    ),
                     overflow = TextOverflow.Ellipsis,
                     maxLines = 1,
                 )
@@ -741,18 +785,17 @@ fun ChatRoom(room: Room, onClick: () -> Unit) {
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun BottomMenuList(
-    onDismiss: (suspend () -> Unit) -> Unit
+    onDismiss: (suspend () -> Unit) -> Unit,
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel,
 ) {
     val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-    val authViewModel = LocalAuthViewModel.current
 
     val defaultMenuList = listOf(
         "Update Profile" to { navigator.navigate(Screen.UpdateProfile) },
         "Contact List" to { navigator.navigate(Screen.ContactList) },
         "Relay Management" to { navigator.navigate(Screen.Relay) },
-        "Settings" to { }
+        "Settings" to { navigator.navigate(Screen.Settings) }
     )
 
     Column(
@@ -778,8 +821,8 @@ fun BottomMenuList(
         FilledTonalButton(
             onClick = {
                 onDismiss {
-                    authViewModel.logout(onLogout = {
-                        nostrViewModel.resetInternalState()
+                    accountViewModel.logout(onLogout = {
+                        accountViewModel.resetInternalState()
                         chatViewModel.resetInternalState()
                     })
                 }

composeApp/src/androidMain/kotlin/su/reya/coop/screens/ImportScreen.kt

@@ -34,7 +34,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -44,33 +43,30 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_scanner
-import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.Keys
 import rust.nostr.sdk.NostrConnectUri
-import su.reya.coop.LocalAuthViewModel
 import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
+import su.reya.coop.viewmodel.AccountViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun ImportScreen() {
+fun ImportScreen(viewModel: AccountViewModel) {
     val snackbarHostState = LocalSnackbarHostState.current
     val navigator = LocalNavigator.current
     val qrScanResult = LocalScanResult.current
     val focusManager = LocalFocusManager.current
-    val authViewModel = LocalAuthViewModel.current
-    val scope = rememberCoroutineScope()
-
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
     var secret by remember { mutableStateOf("") }
     var password by remember { mutableStateOf("") }
     var requirePassword by remember { mutableStateOf(false) }
-    var loading by remember { mutableStateOf(false) }
 
     LaunchedEffect(qrScanResult.content) {
         qrScanResult.content?.let { result ->
@@ -98,6 +94,13 @@ fun ImportScreen() {
         }
     }
 
+    // Navigate to Home on successful import (signerRequired becomes false)
+    LaunchedEffect(accountState.signerRequired) {
+        if (accountState.signerRequired == false) {
+            navigator.navigate(Screen.Home)
+        }
+    }
+
     Scaffold(
         containerColor = MaterialTheme.colorScheme.surfaceContainer,
         snackbarHost = { SnackbarHost(snackbarHostState) },
@@ -164,7 +167,7 @@ fun ImportScreen() {
                             BasicTextField(
                                 value = secret,
                                 onValueChange = { secret = it },
-                                enabled = !loading,
+                                enabled = !accountState.isImporting,
                                 modifier = Modifier.fillMaxWidth(),
                                 singleLine = true,
                                 keyboardOptions = KeyboardOptions(
@@ -209,7 +212,7 @@ fun ImportScreen() {
                                 BasicTextField(
                                     value = password,
                                     onValueChange = { password = it },
-                                    enabled = !loading && requirePassword,
+                                    enabled = !accountState.isImporting && requirePassword,
                                     modifier = Modifier.fillMaxWidth(),
                                     singleLine = true,
                                     keyboardOptions = KeyboardOptions(
@@ -237,25 +240,14 @@ fun ImportScreen() {
                         Spacer(modifier = Modifier.size(16.dp))
                         Button(
                             onClick = {
-                                scope.launch {
-                                    loading = true
-                                    try {
-                                        // Import the identity
-                                        authViewModel.importIdentity(secret, password)
-                                        // Navigate to the home screen
-                                        navigator.navigate(Screen.Home)
-                                    } catch (e: Exception) {
-                                        snackbarHostState.showSnackbar(e.message ?: "Error")
-                                        loading = false
-                                    }
-                                }
+                                viewModel.importIdentity(secret, password)
                             },
                             modifier = Modifier
                                 .fillMaxWidth()
                                 .height(ButtonDefaults.MediumContainerHeight),
-                            enabled = secret.isNotBlank() && !loading,
+                            enabled = secret.isNotBlank() && !accountState.isImporting,
                         ) {
-                            if (loading) {
+                            if (accountState.isImporting) {
                                 LoadingIndicator()
                             } else {
                                 Text(

composeApp/src/androidMain/kotlin/su/reya/coop/screens/MyQrScreen.kt

@@ -22,15 +22,14 @@ import coop.composeapp.generated.resources.ic_arrow_back
 import io.github.alexzhirkevich.qrose.rememberQrCodePainter
 import org.jetbrains.compose.resources.painterResource
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.viewmodel.AccountViewModel
 
 @Composable
-fun MyQrScreen() {
+fun MyQrScreen(viewModel: AccountViewModel) {
     val navigator = LocalNavigator.current
     val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val currentUser by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val currentUser by viewModel.currentUserProfile.collectAsStateWithLifecycle()
 
     Scaffold(
         snackbarHost = { SnackbarHost(snackbarHostState) },

composeApp/src/androidMain/kotlin/su/reya/coop/screens/NewChatScreen.kt

@@ -55,26 +55,28 @@ import coop.composeapp.generated.resources.ic_scanner
 import kotlinx.coroutines.delay
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
 import su.reya.coop.short
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatViewModel
 import kotlin.time.Duration.Companion.milliseconds
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun NewChatScreen() {
+fun NewChatScreen(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
     val snackbarHostState = LocalSnackbarHostState.current
     val navigator = LocalNavigator.current
     val qrScanResult = LocalScanResult.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-
-    val contactList by nostrViewModel.contactList.collectAsStateWithLifecycle()
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val contactList = accountState.contactList
     var query by remember { mutableStateOf("") }
 
     val createGroup = remember { mutableStateOf(false) }
@@ -96,14 +98,16 @@ fun NewChatScreen() {
                     selectedReceivers.add(pubkey)
                 }
             } else if (query.contains("@")) {
-                val pubkey = nostrViewModel.searchByAddress(query)
-                if (pubkey != null) {
-                    selectedReceivers.add(pubkey)
+                accountViewModel.searchByAddress(query) { pubkey ->
+                    if (pubkey != null) {
+                        selectedReceivers.add(pubkey)
+                    }
                 }
             } else {
-                val results = nostrViewModel.searchByNostr(query)
-                searchResults.clear()
-                searchResults.addAll(results)
+                accountViewModel.searchByNostr(query) { results ->
+                    searchResults.clear()
+                    searchResults.addAll(results)
+                }
             }
 
             query = ""
@@ -182,8 +186,8 @@ fun NewChatScreen() {
                             )
                         },
                         text = { Text("Next") },
-                        containerColor = MaterialTheme.colorScheme.tertiary,
-                        contentColor = MaterialTheme.colorScheme.onTertiary,
+                        containerColor = MaterialTheme.colorScheme.tertiaryContainer,
+                        contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
                     )
                 }
             }
@@ -290,8 +294,8 @@ fun ReceiverChip(
     pubkey: PublicKey,
     onRemove: () -> Unit
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
     val profile by profileFlow.collectAsState(initial = null)
 
     CompositionLocalProvider(LocalMinimumInteractiveComponentSize provides 0.dp) {
@@ -372,8 +376,8 @@ fun ContactListItem(
     onClick: () -> Unit,
     onLongClick: () -> Unit
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
     val profile by profileFlow.collectAsState(initial = null)
 
     SegmentedListItem(
@@ -394,7 +398,7 @@ fun ContactListItem(
         supportingContent = { Text(text = pubkey.short()) },
         content = {
             Text(
-                text = profile?.name ?: "",
+                text = profile?.name ?: "Unknown",
                 style = MaterialTheme.typography.titleMediumEmphasized,
             )
         }

composeApp/src/androidMain/kotlin/su/reya/coop/screens/NewIdentityScreen.kt

@@ -1,22 +1,25 @@
 package su.reya.coop.screens
 
 import androidx.compose.runtime.Composable
-import su.reya.coop.LocalAuthViewModel
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import su.reya.coop.LocalNavigator
 import su.reya.coop.Screen
 import su.reya.coop.shared.ProfileEditor
+import su.reya.coop.viewmodel.AccountViewModel
 
 @Composable
-fun NewIdentityScreen() {
-    val authViewModel = LocalAuthViewModel.current
+fun NewIdentityScreen(viewModel: AccountViewModel) {
     val navigator = LocalNavigator.current
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
 
     ProfileEditor(
         title = "Create a new identity",
         buttonLabel = "Continue",
+        isBusy = accountState.isImporting,
         onBack = { navigator.goBack() },
         onConfirm = { name, bio, bytes, type ->
-            authViewModel.createIdentity(name, bio, bytes, type)
+            viewModel.createIdentity(name, bio, bytes, type)
             navigator.navigate(Screen.Home)
         }
     )

composeApp/src/androidMain/kotlin/su/reya/coop/screens/OnboardingScreen.kt

@@ -24,6 +24,8 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
@@ -41,25 +43,33 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.core.net.toUri
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.coop
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
-import su.reya.coop.LocalAuthViewModel
 import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.getExpressiveFontFamily
+import su.reya.coop.viewmodel.AccountViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun OnboardingScreen() {
+fun OnboardingScreen(viewModel: AccountViewModel) {
     val context = LocalContext.current
     val snackbarHostState = LocalSnackbarHostState.current
     val navigator = LocalNavigator.current
-    val authViewModel = LocalAuthViewModel.current
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
     val scope = rememberCoroutineScope()
 
+    // Navigate to Home on successful external signer connection
+    LaunchedEffect(accountState.signerRequired) {
+        if (accountState.signerRequired == false) {
+            navigator.navigate(Screen.Home)
+        }
+    }
+
     val logoPainter = painterResource(Res.drawable.coop)
     val expressiveFont = getExpressiveFontFamily()
 
@@ -157,18 +167,12 @@ fun OnboardingScreen() {
                             Spacer(modifier = Modifier.size(8.dp))
                             FilledTonalButton(
                                 onClick = {
-                                    scope.launch {
-                                        if (authViewModel.isExternalSignerAvailable()) {
-                                            try {
-                                                // Connect to the external signer
-                                                // TODO: show all available signers?
-                                                authViewModel.connectExternalSigner()
-                                                // Navigate to the home screen
-                                                navigator.navigate(Screen.Home)
-                                            } catch (e: Exception) {
-                                                e.message?.let { snackbarHostState.showSnackbar(it) }
-                                            }
-                                        } else {
+                                    if (viewModel.isExternalSignerAvailable()) {
+                                        // Connect to the external signer
+                                        // TODO: show all available signers?
+                                        viewModel.connectExternalSigner()
+                                    } else {
+                                        scope.launch {
                                             val result = snackbarHostState.showSnackbar(
                                                 message = "External signer not installed. Please install Amber or alternatives.",
                                                 actionLabel = "Install",

composeApp/src/androidMain/kotlin/su/reya/coop/screens/ProfileScreen.kt

@@ -44,28 +44,30 @@ import coop.composeapp.generated.resources.ic_share
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
 import su.reya.coop.shared.getExpressiveFontFamily
 import su.reya.coop.short
+import su.reya.coop.viewmodel.ChatViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun ProfileScreen(pubkey: String) {
+fun ProfileScreen(
+    pubkey: String,
+    chatViewModel: ChatViewModel
+) {
     val pubkey = runCatching { PublicKey.parse(pubkey) }.getOrNull() ?: return
 
     val context = LocalContext.current
     val snackbarHostState = LocalSnackbarHostState.current
     val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
+    val profileCache = LocalProfileCache.current
     val scope = rememberCoroutineScope()
 
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
     val profile by profileFlow.collectAsStateWithLifecycle()
 
     val metadata = profile?.metadata?.asRecord()

composeApp/src/androidMain/kotlin/su/reya/coop/screens/RelayScreen.kt

@@ -56,6 +56,7 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_check
@@ -66,15 +67,14 @@ import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.RelayMetadata
 import rust.nostr.sdk.RelayUrl
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.viewmodel.AccountViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun RelayScreen() {
+fun RelayScreen(viewModel: AccountViewModel) {
     val navigator = LocalNavigator.current
     val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
 
     val scope = rememberCoroutineScope()
     val msgRelayList = remember { mutableStateListOf<RelayUrl>() }
@@ -95,9 +95,27 @@ fun RelayScreen() {
     var openAddRelayDialog by remember { mutableStateOf(false) }
     var relayToDelete by remember { mutableStateOf<String?>(null) }
 
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
+    val loadedRelayList = accountState.userRelayList
+    val loadedMsgRelayList = accountState.userMsgRelayList
+
     LaunchedEffect(Unit) {
-        relayList.putAll(nostrViewModel.currentUserRelayList())
-        msgRelayList.addAll(nostrViewModel.currentUserMsgRelayList())
+        viewModel.loadCurrentUserRelayList()
+        viewModel.loadCurrentUserMsgRelayList()
+    }
+
+    LaunchedEffect(loadedRelayList) {
+        if (loadedRelayList.isNotEmpty()) {
+            relayList.clear()
+            relayList.putAll(loadedRelayList)
+        }
+    }
+
+    LaunchedEffect(loadedMsgRelayList) {
+        if (loadedMsgRelayList.isNotEmpty()) {
+            msgRelayList.clear()
+            msgRelayList.addAll(loadedMsgRelayList)
+        }
     }
 
     Scaffold(
@@ -296,6 +314,7 @@ fun RelayScreen() {
 
     if (openAddRelayDialog) {
         AddRelayDialog(
+            viewModel = viewModel,
             onDismissRequest = { openAddRelayDialog = false },
             onMsgRelayAdded = { newRelay ->
                 msgRelayList.add(RelayUrl.parse(newRelay))
@@ -314,20 +333,16 @@ fun RelayScreen() {
             confirmButton = {
                 TextButton(
                     onClick = {
-                        scope.launch {
-                            if (msgRelayList.size == 1) {
+                        if (msgRelayList.size == 1) {
+                            scope.launch {
                                 snackbarHostState.showSnackbar("You must have at least one relay")
-                                relayToDelete = null
-                                return@launch
-                            }
-                            try {
-                                nostrViewModel.removeMsgRelay(relayToDelete!!)
-                                msgRelayList.removeIf { it.toString() == relayToDelete }
-                                relayToDelete = null
-                            } catch (e: Exception) {
-                                snackbarHostState.showSnackbar("Failed to remove relay: ${e.message}")
                             }
+                            relayToDelete = null
+                            return@TextButton
                         }
+                        viewModel.removeMsgRelay(relayToDelete!!)
+                        msgRelayList.removeIf { it.toString() == relayToDelete }
+                        relayToDelete = null
                     }
                 ) {
                     Text("Confirm")
@@ -345,14 +360,12 @@ fun RelayScreen() {
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun AddRelayDialog(
+    viewModel: AccountViewModel,
     onDismissRequest: () -> Unit,
     onMsgRelayAdded: (newRelay: String) -> Unit,
     onRelayAdded: (newRelay: String, metadata: RelayMetadata?) -> Unit,
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
     val snackbarHostState = LocalSnackbarHostState.current
-
-    val scope = rememberCoroutineScope()
     val focusRequester = remember { FocusRequester() }
 
     var relayAddress by remember { mutableStateOf("") }
@@ -397,26 +410,24 @@ fun AddRelayDialog(
                     },
                     actions = {
                         IconButton(onClick = {
-                            scope.launch {
-                                if (!isError) {
-                                    when (selected) {
-                                        "Messaging" -> {
-                                            nostrViewModel.addMsgRelay(relayAddress)
-                                            onMsgRelayAdded(relayAddress)
-                                        }
+                            if (!isError) {
+                                when (selected) {
+                                    "Messaging" -> {
+                                        viewModel.addMsgRelay(relayAddress)
+                                        onMsgRelayAdded(relayAddress)
+                                    }
 
-                                        "Inbox" -> {
-                                            nostrViewModel.addInboxRelay(relayAddress)
-                                            onRelayAdded(relayAddress, RelayMetadata.WRITE)
-                                        }
+                                    "Inbox" -> {
+                                        viewModel.addInboxRelay(relayAddress)
+                                        onRelayAdded(relayAddress, RelayMetadata.WRITE)
+                                    }
 
-                                        "Outbox" -> {
-                                            nostrViewModel.addOutboxRelay(relayAddress)
-                                            onRelayAdded(relayAddress, RelayMetadata.READ)
-                                        }
+                                    "Outbox" -> {
+                                        viewModel.addOutboxRelay(relayAddress)
+                                        onRelayAdded(relayAddress, RelayMetadata.READ)
                                     }
-                                    onDismissRequest()
                                 }
+                                onDismissRequest()
                             }
                         }) {
                             Icon(

composeApp/src/androidMain/kotlin/su/reya/coop/screens/RequestListScreen.kt

@@ -27,7 +27,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -36,26 +35,23 @@ import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
-import kotlinx.coroutines.launch
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.RoomKind
 import su.reya.coop.Screen
+import su.reya.coop.viewmodel.ChatViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
 @Composable
-fun RequestListScreen() {
+fun RequestListScreen(viewModel: ChatViewModel) {
     val navigator = LocalNavigator.current
     val snackbarHostState = LocalSnackbarHostState.current
-    val chatViewModel = LocalChatViewModel.current
 
-    val scope = rememberCoroutineScope()
     val listState = rememberLazyListState()
     val pullToRefreshState = rememberPullToRefreshState()
 
     var isRefreshing by remember { mutableStateOf(false) }
-    val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()
+    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()
 
     // Get all request rooms
     val requests = remember(chatRooms) {
@@ -101,11 +97,9 @@ fun RequestListScreen() {
                     isRefreshing = isRefreshing,
                     state = pullToRefreshState,
                     onRefresh = {
-                        scope.launch {
-                            isRefreshing = true
-                            chatViewModel.refreshChatRooms()
-                            isRefreshing = false
-                        }
+                        isRefreshing = true
+                        viewModel.refreshChatRooms()
+                        isRefreshing = false
                     },
                     indicator = {
                         PullToRefreshDefaults.LoadingIndicator(

composeApp/src/androidMain/kotlin/su/reya/coop/screens/SettingsScreen.kt

@@ -0,0 +1,291 @@
+package su.reya.coop.screens
+
+import android.content.Intent
+import android.provider.Settings as AndroidSettings
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SegmentedListItem
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.unit.dp
+import coop.composeapp.generated.resources.Res
+import coop.composeapp.generated.resources.ic_arrow_back
+import org.jetbrains.compose.resources.painterResource
+import su.reya.coop.LocalNavigator
+import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.MediaConfig
+import su.reya.coop.Theme
+import su.reya.coop.viewmodel.SettingsViewModel
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun SettingsScreen(viewModel: SettingsViewModel) {
+    val navigator = LocalNavigator.current
+    val context = LocalContext.current
+    val snackbarHostState = LocalSnackbarHostState.current
+    val settings by viewModel.settings.collectAsState()
+
+    var showThemeDialog by remember { mutableStateOf(false) }
+    var showMediaDialog by remember { mutableStateOf(false) }
+    var showBlossomDialog by remember { mutableStateOf(false) }
+
+    Scaffold(
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        text = "Settings",
+                        style = MaterialTheme.typography.titleMediumEmphasized
+                    )
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainer,
+                ),
+                navigationIcon = {
+                    IconButton(onClick = { navigator.goBack() }) {
+                        Icon(
+                            painter = painterResource(Res.drawable.ic_arrow_back),
+                            contentDescription = "Back"
+                        )
+                    }
+                },
+            )
+        },
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .verticalScroll(rememberScrollState())
+                .padding(horizontal = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(24.dp)
+        ) {
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                Text(
+                    text = "General",
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.padding(horizontal = 8.dp)
+                )
+                Column(
+                    verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap)
+                ) {
+                    SegmentedListItem(
+                        onClick = { viewModel.update { it.copy(screening = !it.screening) } },
+                        shapes = ListItemDefaults.segmentedShapes(index = 0, count = 4),
+                        content = { Text("Screening") },
+                        supportingContent = { Text("Filter unknown contacts") },
+                        trailingContent = {
+                            Switch(
+                                checked = settings.screening,
+                                onCheckedChange = { viewModel.update { s -> s.copy(screening = it) } }
+                            )
+                        }
+                    )
+                    SegmentedListItem(
+                        onClick = { showMediaDialog = true },
+                        shapes = ListItemDefaults.segmentedShapes(index = 1, count = 4),
+                        content = { Text("Media Preview") },
+                        supportingContent = {
+                            Text(
+                                when (settings.media) {
+                                    MediaConfig.Disabled -> "Disabled"
+                                    MediaConfig.DisabledForMobileData -> "Disabled for Mobile Data"
+                                    MediaConfig.AlwaysEnabled -> "Always Enabled"
+                                }
+                            )
+                        }
+                    )
+                    SegmentedListItem(
+                        onClick = { showBlossomDialog = true },
+                        shapes = ListItemDefaults.segmentedShapes(index = 2, count = 4),
+                        content = { Text("Blossom Server") },
+                        supportingContent = { Text(settings.blossomServer ?: "Default") }
+                    )
+                    SegmentedListItem(
+                        onClick = {
+                            val intent = Intent(AndroidSettings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
+                                putExtra(AndroidSettings.EXTRA_APP_PACKAGE, context.packageName)
+                            }
+                            context.startActivity(intent)
+                        },
+                        shapes = ListItemDefaults.segmentedShapes(index = 3, count = 4),
+                        content = { Text("Notifications") },
+                        supportingContent = { Text("System notification settings") }
+                    )
+                }
+            }
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                Text(
+                    text = "Appearance",
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.padding(horizontal = 8.dp)
+                )
+                Column(
+                    verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap)
+                ) {
+                    SegmentedListItem(
+                        onClick = { showThemeDialog = true },
+                        shapes = ListItemDefaults.segmentedShapes(index = 0, count = 2),
+                        content = { Text("Theme") },
+                        supportingContent = { Text(settings.theme.name) }
+                    )
+                    SegmentedListItem(
+                        onClick = { viewModel.update { it.copy(dynamicColor = !it.dynamicColor) } },
+                        shapes = ListItemDefaults.segmentedShapes(index = 1, count = 2),
+                        content = { Text("Dynamic Color") },
+                        trailingContent = {
+                            Switch(
+                                checked = settings.dynamicColor,
+                                onCheckedChange = {
+                                    viewModel.update { s -> s.copy(dynamicColor = it) }
+                                }
+                            )
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    if (showThemeDialog) {
+        OptionDialog(
+            title = "Select Theme",
+            options = Theme.entries.map { it.name },
+            selected = settings.theme.name,
+            onSelected = { name ->
+                viewModel.update { it.copy(theme = Theme.valueOf(name)) }
+                showThemeDialog = false
+            },
+            onDismiss = { showThemeDialog = false }
+        )
+    }
+
+    if (showMediaDialog) {
+        OptionDialog(
+            title = "Media Preview",
+            options = listOf("Disabled", "Disabled for Mobile Data", "Always Enabled"),
+            selected = when (settings.media) {
+                MediaConfig.Disabled -> "Disabled"
+                MediaConfig.DisabledForMobileData -> "Disabled for Mobile Data"
+                MediaConfig.AlwaysEnabled -> "Always Enabled"
+            },
+            onSelected = { choice ->
+                val newConfig = when (choice) {
+                    "Disabled" -> MediaConfig.Disabled
+                    "Disabled for Mobile Data" -> MediaConfig.DisabledForMobileData
+                    else -> MediaConfig.AlwaysEnabled
+                }
+                viewModel.update { it.copy(media = newConfig) }
+                showMediaDialog = false
+            },
+            onDismiss = { showMediaDialog = false }
+        )
+    }
+
+    if (showBlossomDialog) {
+        var text by remember { mutableStateOf(settings.blossomServer ?: "") }
+        AlertDialog(
+            onDismissRequest = { showBlossomDialog = false },
+            title = { Text("Blossom Server URL") },
+            text = {
+                OutlinedTextField(
+                    value = text,
+                    onValueChange = { text = it },
+                    modifier = Modifier.fillMaxWidth(),
+                    placeholder = { Text("https://...") },
+                    singleLine = true
+                )
+            },
+            confirmButton = {
+                TextButton(onClick = {
+                    viewModel.update { it.copy(blossomServer = text.ifBlank { null }) }
+                    showBlossomDialog = false
+                }) {
+                    Text("Save")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showBlossomDialog = false }) {
+                    Text("Cancel")
+                }
+            }
+        )
+    }
+}
+
+@Composable
+fun OptionDialog(
+    title: String,
+    options: List<String>,
+    selected: String,
+    onSelected: (String) -> Unit,
+    onDismiss: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(title) },
+        text = {
+            Column(modifier = Modifier.selectableGroup()) {
+                options.forEach { text ->
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .selectable(
+                                selected = (text == selected),
+                                onClick = { onSelected(text) },
+                                role = Role.RadioButton
+                            )
+                            .padding(vertical = 12.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        RadioButton(selected = (text == selected), onClick = null)
+                        Spacer(Modifier.size(16.dp))
+                        Text(text = text, style = MaterialTheme.typography.bodyLarge)
+                    }
+                }
+            }
+        },
+        confirmButton = {}
+    )
+}

composeApp/src/androidMain/kotlin/su/reya/coop/screens/UpdateProfileScreen.kt

@@ -4,16 +4,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.shared.ProfileEditor
+import su.reya.coop.viewmodel.AccountViewModel
 
 @Composable
-fun UpdateProfileScreen() {
-    val nostrViewModel = LocalNostrViewModel.current
+fun UpdateProfileScreen(viewModel: AccountViewModel) {
     val navigator = LocalNavigator.current
-
-    val currentUser by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val currentUser by viewModel.currentUserProfile.collectAsStateWithLifecycle()
     val profile = currentUser?.metadata?.asRecord()
+    val isUpdatingProfile by viewModel.isUpdatingProfile.collectAsStateWithLifecycle()
 
     ProfileEditor(
         title = "Update profile",
@@ -21,9 +20,10 @@ fun UpdateProfileScreen() {
         initialName = profile?.displayName ?: profile?.name ?: "",
         initialBio = profile?.about ?: "",
         initialPicture = profile?.picture,
+        isBusy = isUpdatingProfile,
         onBack = { navigator.goBack() },
         onConfirm = { name, bio, bytes, type ->
-            nostrViewModel.updateProfile(name, bio, bytes, type)
+            viewModel.updateProfile(name, bio, bytes, type)
             navigator.goBack()
         }
     )

composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatComponents.kt

@@ -18,52 +18,47 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_cancel
 import coop.composeapp.generated.resources.ic_check_circle
-import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
 import rust.nostr.sdk.Timestamp
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.Room
 import su.reya.coop.humanReadable
 import su.reya.coop.shared.Avatar
 import su.reya.coop.shared.getExpressiveFontFamily
 import su.reya.coop.short
+import su.reya.coop.viewmodel.AccountViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun ScreenerCard(room: Room) {
+fun ScreenerCard(viewModel: AccountViewModel, room: Room) {
     val pubkey = room.members.firstOrNull() ?: return
 
-    val nostrViewModel = LocalNostrViewModel.current
-    val scope = rememberCoroutineScope()
+    val profileCache = LocalProfileCache.current
 
     var isContact by remember { mutableStateOf(false) }
     var mutualContacts by remember { mutableStateOf<Set<PublicKey>>(emptySet()) }
     var lastActivity by remember { mutableStateOf<Timestamp?>(null) }
 
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
     val profile by profileFlow.collectAsStateWithLifecycle()
 
     LaunchedEffect(pubkey) {
-        scope.launch {
-            // Check contact
-            nostrViewModel.verifyContact(pubkey).let { isContact = it }
-            // Get mutual contacts
-            nostrViewModel.mutualContacts(pubkey).let { mutualContacts = it }
-            // Get the last activity
-            nostrViewModel.verifyActivity(pubkey)?.let { lastActivity = it }
-        }
+        // Check contact
+        viewModel.verifyContact(pubkey) { isContact = it }
+        // Get mutual contacts
+        viewModel.mutualContacts(pubkey) { mutualContacts = it }
+        // Get the last activity
+        viewModel.verifyActivity(pubkey) { lastActivity = it }
     }
 
     Column(

composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatInput.kt

@@ -11,6 +11,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material3.FilledTonalIconButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -23,6 +24,8 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.unit.dp
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_add_circle
@@ -52,6 +55,11 @@ fun ChatInput(
             value = value,
             onValueChange = onValueChange,
             placeholder = { Text("Message") },
+            maxLines = 5,
+            keyboardOptions = KeyboardOptions(
+                capitalization = KeyboardCapitalization.Sentences,
+                imeAction = ImeAction.Default
+            ),
             leadingIcon = {
                 IconButton(onClick = onUpload) {
                     Icon(

composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatMessage.kt

@@ -1,18 +1,17 @@
 package su.reya.coop.screens.chat
 
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.expandVertically
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.shrinkVertically
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
@@ -26,8 +25,11 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.boundsInWindow
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.LinkAnnotation
 import androidx.compose.ui.text.SpanStyle
@@ -36,37 +38,65 @@ import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import coil3.compose.AsyncImage
+import rust.nostr.sdk.EventId
 import rust.nostr.sdk.PublicKey
 import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.LocalConnectivity
+import su.reya.coop.LocalSettings
+import su.reya.coop.MediaConfig
 import su.reya.coop.URL_REGEX
 import su.reya.coop.formatAsTime
 import su.reya.coop.isImageUrl
 import su.reya.coop.removeImageUrls
 
 @Immutable
-data class MessageUiModel(
-    val id: String,
+data class ReactionGroup(
+    val emoji: String,
+    val authors: List<PublicKey>,
+    val containsMe: Boolean
+)
+
+@Immutable
+data class MessageModel(
+    val id: EventId,
+    val author: PublicKey,
     val annotatedContent: AnnotatedString,
     val images: List<String>,
     val timestamp: String,
-    val isMine: Boolean
+    val isMine: Boolean,
+    val replyEventIds: List<EventId>,
+    val reactions: List<ReactionGroup> = emptyList()
 )
 
 @Composable
-fun rememberMessageUiModel(
+fun rememberMessageModel(
     event: UnsignedEvent,
-    currentUserPublicKey: PublicKey?,
-    contentColor: Color
-): MessageUiModel {
-    return remember(event, currentUserPublicKey, contentColor) {
-        val content = event.content()
-        val images = URL_REGEX.findAll(content)
-            .map { it.value }
-            .filter { it.isImageUrl() }
-            .toList()
+    reactions: List<UnsignedEvent> = emptyList(),
+    currentUser: PublicKey? = null
+): MessageModel {
+    val settings = LocalSettings.current
+    val isMobileData = LocalConnectivity.current
 
-        val cleanedContent = content.removeImageUrls()
+    return remember(event, reactions, currentUser, settings, isMobileData) {
+        val id = event.ensureId().id()!!
+        val isMine = currentUser == event.author()
+        val content = event.content()
+        val replyEventIds = event.tags().eventIds()
+
+        val showMedia = when (settings.media) {
+            MediaConfig.AlwaysEnabled -> true
+            MediaConfig.Disabled -> false
+            MediaConfig.DisabledForMobileData -> !isMobileData
+        }
+
+        val images = if (showMedia) {
+            URL_REGEX.findAll(content).map { it.value }.filter { it.isImageUrl() }.toList()
+        } else {
+            emptyList()
+        }
+        val cleanedContent = if (showMedia) content.removeImageUrls() else content
 
         val annotatedString = buildAnnotatedString {
             var lastIndex = 0
@@ -78,7 +108,6 @@ fun rememberMessageUiModel(
                         url = url,
                         styles = TextLinkStyles(
                             style = SpanStyle(
-                                color = contentColor,
                                 textDecoration = TextDecoration.Underline,
                                 fontWeight = FontWeight.Medium
                             )
@@ -92,19 +121,37 @@ fun rememberMessageUiModel(
             append(cleanedContent.substring(lastIndex))
         }
 
-        MessageUiModel(
-            id = event.id()?.toHex() ?: event.hashCode().toString(),
+        val groupedReactions = reactions.groupBy { it.content() }
+            .map { (emoji, events) ->
+                val authors = events.map { it.author() }
+                ReactionGroup(
+                    emoji = emoji,
+                    authors = authors,
+                    containsMe = authors.any { it == currentUser }
+                )
+            }
+
+        MessageModel(
+            id = id,
+            author = event.author(),
             annotatedContent = annotatedString,
             images = images,
             timestamp = event.createdAt().formatAsTime(),
-            isMine = event.author() == currentUserPublicKey
+            isMine = isMine,
+            replyEventIds = replyEventIds,
+            reactions = groupedReactions
         )
     }
 }
 
 @Composable
-fun ChatMessage(model: MessageUiModel) {
+fun ChatMessage(
+    model: MessageModel,
+    modifier: Modifier = Modifier,
+    onLongClick: (Rect) -> Unit = {}
+) {
     var isMessageClicked by remember { mutableStateOf(false) }
+    var layoutCoordinates by remember { mutableStateOf<LayoutCoordinates?>(null) }
 
     val bubbleShape = if (model.isMine) {
         RoundedCornerShape(topStart = 20.dp, topEnd = 4.dp, bottomStart = 20.dp, bottomEnd = 20.dp)
@@ -119,65 +166,128 @@ fun ChatMessage(model: MessageUiModel) {
         if (!model.isMine) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onPrimaryContainer
 
     Box(
-        modifier = Modifier
+        modifier = modifier
+            .onGloballyPositioned { layoutCoordinates = it }
             .fillMaxWidth()
             .padding(vertical = 4.dp),
         contentAlignment = if (model.isMine) Alignment.CenterEnd else Alignment.CenterStart
     ) {
         Column(
-            modifier = Modifier.clickable(
+            modifier = Modifier.combinedClickable(
                 interactionSource = remember { MutableInteractionSource() },
-                indication = null
-            ) {
-                isMessageClicked = !isMessageClicked
-            },
+                indication = null,
+                onClick = { isMessageClicked = !isMessageClicked },
+                onLongClick = {
+                    layoutCoordinates?.let { coords ->
+                        onLongClick(coords.boundsInWindow())
+                    }
+                }
+            ),
             horizontalAlignment = if (model.isMine) Alignment.End else Alignment.Start,
-            verticalArrangement = Arrangement.spacedBy(8.dp)
+            verticalArrangement = Arrangement.spacedBy(4.dp)
         ) {
-            if (model.annotatedContent.isNotBlank()) {
-                Surface(
-                    color = containerColor,
-                    contentColor = contentColor,
-                    shape = bubbleShape,
-                    modifier = Modifier.widthIn(max = 280.dp)
+            Box(contentAlignment = Alignment.BottomEnd) {
+                Column(
+                    modifier = Modifier.padding(
+                        bottom = if (model.reactions.isNotEmpty()) 4.dp else 0.dp,
+                        end = if (model.reactions.isNotEmpty() && !model.isMine) 8.dp else 0.dp
+                    ),
+                    horizontalAlignment = if (model.isMine) Alignment.End else Alignment.Start,
+                    verticalArrangement = Arrangement.spacedBy(4.dp)
                 ) {
-                    Text(
-                        text = model.annotatedContent,
-                        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
-                        style = MaterialTheme.typography.bodyLarge
+                    if (model.annotatedContent.isNotBlank()) {
+                        Surface(
+                            modifier = Modifier.widthIn(max = 280.dp),
+                            color = containerColor,
+                            contentColor = contentColor,
+                            shape = bubbleShape,
+                        ) {
+                            Text(
+                                text = model.annotatedContent,
+                                modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+                                style = MaterialTheme.typography.bodyLarge
+                            )
+                        }
+                    }
+                    model.images.forEach { imageUrl ->
+                        Surface(
+                            shape = RoundedCornerShape(16.dp),
+                            color = MaterialTheme.colorScheme.surfaceVariant,
+                            modifier = Modifier.widthIn(max = 280.dp)
+                        ) {
+                            AsyncImage(
+                                model = imageUrl,
+                                contentDescription = "Image from chat",
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .clip(RoundedCornerShape(16.dp)),
+                                contentScale = ContentScale.FillWidth
+                            )
+                        }
+                    }
+                }
+
+                if (model.reactions.isNotEmpty()) {
+                    MessageReactions(
+                        reactions = model.reactions,
+                        modifier = Modifier.offset(y = 12.dp)
                     )
                 }
             }
-            model.images.forEach { imageUrl ->
-                Surface(
-                    shape = RoundedCornerShape(16.dp),
-                    color = MaterialTheme.colorScheme.surfaceVariant,
-                    modifier = Modifier.widthIn(max = 280.dp)
-                ) {
-                    AsyncImage(
-                        model = imageUrl,
-                        contentDescription = "Image from chat",
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .clip(RoundedCornerShape(16.dp)),
-                        contentScale = ContentScale.FillWidth
-                    )
-                }
-            }
-            AnimatedVisibility(
-                visible = isMessageClicked,
-                enter = fadeIn() + expandVertically(),
-                exit = fadeOut() + shrinkVertically()
-            ) {
+
+            if (isMessageClicked) {
                 Text(
                     text = model.timestamp,
                     style = MaterialTheme.typography.labelSmall,
                     color = MaterialTheme.colorScheme.outline,
-                    modifier = Modifier.align(
-                        if (model.isMine) Alignment.End else Alignment.Start
-                    )
+                    modifier = Modifier.padding(top = if (model.reactions.isNotEmpty()) 8.dp else 0.dp)
                 )
             }
         }
     }
 }
+
+@Composable
+private fun MessageReactions(
+    reactions: List<ReactionGroup>,
+    modifier: Modifier = Modifier
+) {
+    val totalCount = reactions.sumOf { it.authors.size }
+    val displayEmojis = reactions.take(3).map { it.emoji }
+
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        displayEmojis.forEach { emoji ->
+            Surface(
+                modifier = Modifier.size(24.dp),
+                color = MaterialTheme.colorScheme.surface,
+                shape = CircleShape,
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Text(
+                        text = emoji,
+                        fontSize = 12.sp,
+                    )
+                }
+            }
+        }
+        if (totalCount > 2) {
+            Surface(
+                modifier = Modifier.size(24.dp),
+                color = MaterialTheme.colorScheme.surface,
+                shape = CircleShape,
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Text(
+                        text = totalCount.toString(),
+                        style = MaterialTheme.typography.labelSmall,
+                        fontSize = 10.sp,
+                    )
+                }
+            }
+        }
+    }
+}

composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatScreen.kt

@@ -1,11 +1,17 @@
 package su.reya.coop.screens.chat
 
 import android.app.Activity
+import android.content.ClipData
 import android.content.Intent
 import android.net.Uri
 import android.speech.RecognizerIntent
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -16,24 +22,33 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Badge
 import androidx.compose.material3.BadgedBox
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.DropdownMenuGroup
+import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.LoadingIndicator
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.MenuDefaults
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.ScaffoldDefaults
 import androidx.compose.material3.SnackbarHost
@@ -45,52 +60,72 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.blur
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.ClipEntry
+import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalWindowInfo
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
+import coop.composeapp.generated.resources.ic_copy
+import coop.composeapp.generated.resources.ic_reply
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.jetbrains.compose.resources.painterResource
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.KindStandard
 import rust.nostr.sdk.UnsignedEvent
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
+import su.reya.coop.LocalSettings
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Room
+import su.reya.coop.RoomUiState
 import su.reya.coop.Screen
-import su.reya.coop.formatAsGroupHeader
-import su.reya.coop.rememberUiState
-import su.reya.coop.roomId
+import su.reya.coop.formatAsGroup
 import su.reya.coop.shared.Avatar
+import su.reya.coop.uiStateFlow
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatScreenViewModel
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun ChatScreen(id: Long, screening: Boolean = false) {
+fun ChatScreen(
+    viewModel: ChatScreenViewModel,
+    accountViewModel: AccountViewModel,
+    coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) {
     val context = LocalContext.current
     val snackbarHostState = LocalSnackbarHostState.current
+    val clipboardManager = LocalClipboard.current
     val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
+    val profileCache = LocalProfileCache.current
+    val settings = LocalSettings.current
     val scope = rememberCoroutineScope()
     val listState = rememberLazyListState()
 
-    // Get current user
-    val currentUser by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
-
-    // Get chat room by ID
-    val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()
+    val id = viewModel.id
+    val currentUser by viewModel.currentUser.collectAsStateWithLifecycle()
+    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()
     val room by remember(id) { derivedStateOf { chatRooms.firstOrNull { it.id == id } } }
 
     // Show empty screen
@@ -108,32 +143,73 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
         return
     }
 
-    val roomState by (room as Room).rememberUiState(nostrViewModel, currentUser?.publicKey)
-    var text by remember { mutableStateOf("") }
-    var loading by remember { mutableStateOf(true) }
-    var newOtherMessages by remember { mutableIntStateOf(0) }
-    var requireScreening by remember { mutableStateOf(screening) }
+    val loading = viewModel.loading
+    val newOtherMessages = viewModel.newOtherMessages
+    val requireScreening = viewModel.requireScreening
+    val allEvents = viewModel.messages
+
+    val displayMessages by remember {
+        derivedStateOf { allEvents.filter { it.kind().asStd() != KindStandard.REACTION } }
+    }
+
+    val reactionsByMessage by remember {
+        derivedStateOf {
+            allEvents.filter { it.kind().asStd() == KindStandard.REACTION }
+                .groupBy { it.tags().eventIds().firstOrNull() }
+        }
+    }
 
-    val messages = remember { mutableStateListOf<UnsignedEvent>() }
     val groupedMessages =
-        remember { derivedStateOf { messages.groupBy { it.createdAt().formatAsGroupHeader() } } }
+        remember { derivedStateOf { displayMessages.groupBy { it.createdAt().formatAsGroup() } } }
+
+    val roomState by remember(id, currentUser?.publicKey) {
+        (room as Room).uiStateFlow(profileCache, currentUser?.publicKey)
+    }.collectAsStateWithLifecycle(RoomUiState())
+
+    var text by remember { mutableStateOf("") }
+    var selectedMessage by remember { mutableStateOf<Pair<MessageModel, Rect>?>(null) }
+    var replyingTo by remember { mutableStateOf<MessageModel?>(null) }
+
+    val blurAmount by animateDpAsState(
+        targetValue = if (selectedMessage != null) 8.dp else 0.dp,
+        label = "blurAnimation"
+    )
+
+    val goToMessage = { eventId: EventId? ->
+        if (eventId != null) {
+            scope.launch {
+                var targetIndex = -1
+                var currentIndex = 0
+
+                for (group in groupedMessages.value) {
+                    val msgInGroup = group.value
+                    val idx = msgInGroup.indexOfFirst { it.ensureId().id() == eventId }
+                    if (idx != -1) {
+                        targetIndex = currentIndex + idx
+                        break
+                    }
+                    currentIndex += msgInGroup.size + 1
+                }
+
+                if (targetIndex != -1) {
+                    listState.animateScrollToItem(targetIndex)
+                }
+            }
+        }
+    }
 
     val sendFile = { uri: Uri ->
         scope.launch {
-            try {
-                // Read file
-                val file = withContext(Dispatchers.IO) {
-                    context.contentResolver.openInputStream(uri)?.use { it.readBytes() }
-                }
-
-                // Parse the file content type
-                val type = context.contentResolver.getType(uri)
-
-                // Send message
-                chatViewModel.sendFileMessage(id, file, type)
-            } catch (e: Exception) {
-                snackbarHostState.showSnackbar("Error: ${e.message}")
+            // Read file on IO dispatcher
+            val file = withContext(coroutineDispatcher) {
+                context.contentResolver.openInputStream(uri)?.use { it.readBytes() }
             }
+
+            // Parse the file content type
+            val type = context.contentResolver.getType(uri)
+
+            // Send message (handles errors internally via ViewModel)
+            viewModel.sendFileMessage(file, type)
         }
     }
 
@@ -151,235 +227,491 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
             }
         }
 
-    LaunchedEffect(id) {
-        // Get messages
-        val initialMessages = chatViewModel.getChatRoomMessages(id)
-        messages.clear()
-        messages.addAll(initialMessages)
-
-        // Stop loading spinner
-        loading = false
-
-        // Get msg relays for each member
-        chatViewModel.chatRoomConnect(id)
-
-        // Handle new messages
-        chatViewModel.newEvents.collect { event ->
-            if (event.roomId() == id) {
-                if (event.id() !in messages.map { it.id() }) {
-                    messages.add(0, event)
-                }
-            } else {
-                // If the event is not in the current room, it's a new message from another user
-                newOtherMessages++
-            }
-        }
-    }
-
-    LaunchedEffect(messages.size) {
-        if (messages.isNotEmpty()) {
+    LaunchedEffect(allEvents.size) {
+        if (displayMessages.isNotEmpty()) {
             listState.animateScrollToItem(0)
         }
     }
 
-    Scaffold(
-        contentWindowInsets = ScaffoldDefaults.contentWindowInsets.union(WindowInsets.ime),
-        containerColor = MaterialTheme.colorScheme.surfaceContainer,
-        snackbarHost = { SnackbarHost(snackbarHostState) },
-        topBar = {
-            TopAppBar(
-                title = {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier.clickable {
-                            room?.members?.firstOrNull()?.let { pubkey ->
-                                navigator.navigate(Screen.Profile(pubkey.toBech32()))
-                            }
-                        }
-                    ) {
-                        if (loading) {
-                            LoadingIndicator(modifier = Modifier.size(32.dp))
-                        } else {
-                            Avatar(
-                                picture = roomState.picture,
-                                description = roomState.name,
-                                size = 32.dp,
-                            )
-                        }
-                        Spacer(modifier = Modifier.size(8.dp))
-                        Text(
-                            text = roomState.name,
-                            style = MaterialTheme.typography.titleMediumEmphasized,
-                        )
-                    }
-                },
-                navigationIcon = {
-                    BadgedBox(
-                        badge = {
-                            if (newOtherMessages > 0) {
-                                Badge {
-                                    Text(newOtherMessages.toString())
+    Box(modifier = Modifier.fillMaxSize()) {
+        Scaffold(
+            modifier = Modifier.blur(blurAmount),
+            contentWindowInsets = ScaffoldDefaults.contentWindowInsets.union(WindowInsets.ime),
+            containerColor = MaterialTheme.colorScheme.surfaceContainer,
+            snackbarHost = { SnackbarHost(snackbarHostState) },
+            topBar = {
+                TopAppBar(
+                    title = {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier.clickable {
+                                room?.members?.firstOrNull()?.let { pubkey ->
+                                    navigator.navigate(Screen.Profile(pubkey.toBech32()))
                                 }
                             }
-                        }
-                    ) {
-                        IconButton(onClick = { navigator.goBack() }) {
-                            Icon(
-                                painter = painterResource(Res.drawable.ic_arrow_back),
-                                contentDescription = "Back"
+                        ) {
+                            if (loading) {
+                                LoadingIndicator(modifier = Modifier.size(32.dp))
+                            } else {
+                                Avatar(
+                                    picture = roomState.picture,
+                                    description = roomState.name,
+                                    size = 32.dp,
+                                )
+                            }
+                            Spacer(modifier = Modifier.size(8.dp))
+                            Text(
+                                text = roomState.name,
+                                style = MaterialTheme.typography.titleMediumEmphasized,
                             )
                         }
-                    }
-                },
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = MaterialTheme.colorScheme.surfaceContainer,
+                    },
+                    navigationIcon = {
+                        BadgedBox(
+                            badge = {
+                                if (newOtherMessages > 0) {
+                                    Badge {
+                                        Text(newOtherMessages.toString())
+                                    }
+                                }
+                            }
+                        ) {
+                            IconButton(onClick = { navigator.goBack() }) {
+                                Icon(
+                                    painter = painterResource(Res.drawable.ic_arrow_back),
+                                    contentDescription = "Back"
+                                )
+                            }
+                        }
+                    },
+                    colors = TopAppBarDefaults.topAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+                    )
                 )
-            )
-        },
-        content = { innerPadding ->
-            Surface(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(top = innerPadding.calculateTopPadding()),
-                color = MaterialTheme.colorScheme.surface,
-                shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
-            ) {
-                Column(
+            },
+            content = { innerPadding ->
+                Surface(
                     modifier = Modifier
                         .fillMaxSize()
-                        .padding(bottom = innerPadding.calculateBottomPadding())
+                        .padding(top = innerPadding.calculateTopPadding()),
+                    color = MaterialTheme.colorScheme.surface,
+                    shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
                 ) {
-                    if (requireScreening) {
-                        room?.let { ScreenerCard(it) }
-                    }
+                    Column(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(bottom = innerPadding.calculateBottomPadding())
+                    ) {
+                        if (requireScreening && settings.screening) {
+                            room?.let { ScreenerCard(accountViewModel, it) }
+                        }
 
-                    val mineColor = MaterialTheme.colorScheme.onPrimaryContainer
-                    val otherColor = MaterialTheme.colorScheme.onSurface
+                        when (displayMessages.isNotEmpty()) {
+                            true -> {
+                                LazyColumn(
+                                    modifier = Modifier
+                                        .weight(1f)
+                                        .fillMaxWidth(),
+                                    state = listState,
+                                    reverseLayout = true,
+                                    contentPadding = PaddingValues(16.dp),
+                                ) {
+                                    groupedMessages.value.forEach { (dateHeader, messagesInGroup) ->
+                                        items(
+                                            items = messagesInGroup,
+                                            key = { it.ensureId().id()?.toHex()!! }
+                                        ) { event ->
+                                            val msgReactions = reactionsByMessage[event.id()] ?: emptyList()
+                                            val model =
+                                                rememberMessageModel(event, msgReactions, currentUser?.publicKey)
 
-                    when (messages.isNotEmpty()) {
-                        true -> {
-                            LazyColumn(
-                                modifier = Modifier
-                                    .weight(1f)
-                                    .fillMaxWidth(),
-                                contentPadding = PaddingValues(16.dp),
-                                reverseLayout = true,
-                                state = listState,
-                            ) {
-                                groupedMessages.value.forEach { (dateHeader, messagesInGroup) ->
-                                    items(
-                                        items = messagesInGroup,
-                                        key = { it.id()?.toHex() ?: it.hashCode().toString() }
-                                    ) { event ->
-                                        val isMine = currentUser?.publicKey == event.author()
-                                        val uiModel = rememberMessageUiModel(
-                                            event = event,
-                                            currentUserPublicKey = currentUser?.publicKey,
-                                            contentColor = if (isMine) mineColor else otherColor
+                                            val replyPreview =
+                                                remember(model.replyEventIds, displayMessages.size) {
+                                                    model.replyEventIds.firstOrNull()
+                                                        ?.let { replyId ->
+                                                            displayMessages.find { it.ensureId().id() == replyId }
+                                                        }
+                                                }
+
+                                            Column(
+                                                modifier = Modifier
+                                                    .fillMaxWidth()
+                                                    .animateItem(),
+                                                verticalArrangement = Arrangement.spacedBy(2.dp)
+                                            ) {
+                                                replyPreview?.let { previewEvent ->
+                                                    ReplyPreview(
+                                                        event = previewEvent,
+                                                        isMine = model.isMine,
+                                                        onClick = { goToMessage(previewEvent.id()) }
+                                                    )
+                                                }
+                                                ChatMessage(
+                                                    model = model,
+                                                    modifier = Modifier.graphicsLayer {
+                                                        alpha =
+                                                            if (selectedMessage?.first?.id == model.id) 0f else 1f
+                                                    },
+                                                    onLongClick = { rect ->
+                                                        selectedMessage = model to rect
+                                                    }
+                                                )
+                                            }
+                                        }
+                                        item {
+                                            DateSeparator(dateHeader)
+                                        }
+                                    }
+                                }
+                            }
+
+                            false -> {
+                                Box(
+                                    modifier = Modifier
+                                        .weight(1f)
+                                        .fillMaxWidth(),
+                                    contentAlignment = Alignment.Center
+                                ) {
+                                    Column(
+                                        horizontalAlignment = Alignment.CenterHorizontally,
+                                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                                    ) {
+                                        Text(
+                                            text = "No messages yet",
+                                            style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                                                fontWeight = FontWeight.SemiBold
+                                            ),
+                                            color = MaterialTheme.colorScheme.onSurface
+                                        )
+                                        Text(
+                                            text = "Your conversations will appear here.",
+                                            style = MaterialTheme.typography.bodyMedium,
+                                            color = MaterialTheme.colorScheme.outline
                                         )
-                                        ChatMessage(model = uiModel)
-                                    }
-                                    item {
-                                        DateSeparator(dateHeader)
                                     }
                                 }
                             }
                         }
 
-                        false -> {
-                            Box(
-                                modifier = Modifier
-                                    .weight(1f)
-                                    .fillMaxWidth(),
-                                contentAlignment = Alignment.Center
-                            ) {
-                                Column(
-                                    horizontalAlignment = Alignment.CenterHorizontally,
-                                    verticalArrangement = Arrangement.spacedBy(4.dp),
+                        when (requireScreening && settings.screening) {
+                            true -> {
+                                Row(
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .padding(horizontal = 16.dp, vertical = 8.dp),
+                                    horizontalArrangement = Arrangement.spacedBy(8.dp),
                                 ) {
-                                    Text(
-                                        text = "No messages yet",
-                                        style = MaterialTheme.typography.titleLargeEmphasized.copy(
-                                            fontWeight = FontWeight.SemiBold
-                                        ),
-                                        color = MaterialTheme.colorScheme.onSurface
-                                    )
-                                    Text(
-                                        text = "Your conversations will appear here.",
-                                        style = MaterialTheme.typography.bodyMedium,
-                                        color = MaterialTheme.colorScheme.outline
-                                    )
+                                    Button(
+                                        onClick = { navigator.goBack() },
+                                        modifier = Modifier
+                                            .weight(1f)
+                                            .size(ButtonDefaults.MediumContainerHeight)
+                                    ) {
+                                        Text(
+                                            text = "Reject",
+                                            style = MaterialTheme.typography.titleMedium,
+                                        )
+                                    }
+                                    FilledTonalButton(
+                                        onClick = { viewModel.requireScreening = false },
+                                        modifier = Modifier
+                                            .weight(1f)
+                                            .size(ButtonDefaults.MediumContainerHeight)
+                                    ) {
+                                        Text(
+                                            text = "Accept",
+                                            style = MaterialTheme.typography.titleMedium,
+                                        )
+                                    }
                                 }
                             }
-                        }
-                    }
 
-                    when (requireScreening) {
-                        true -> {
-                            Row(
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .padding(horizontal = 16.dp, vertical = 8.dp),
-                                horizontalArrangement = Arrangement.spacedBy(8.dp),
-                            ) {
-                                Button(
-                                    onClick = { navigator.goBack() },
-                                    modifier = Modifier
-                                        .weight(1f)
-                                        .size(ButtonDefaults.MediumContainerHeight)
-                                ) {
-                                    Text(
-                                        text = "Reject",
-                                        style = MaterialTheme.typography.titleMedium,
-                                    )
+                            else -> {
+                                AnimatedVisibility(visible = replyingTo != null) {
+                                    replyingTo?.let {
+                                        ReplyBox(it) { replyingTo = null }
+                                    }
                                 }
-                                FilledTonalButton(
-                                    onClick = { requireScreening = false },
-                                    modifier = Modifier
-                                        .weight(1f)
-                                        .size(ButtonDefaults.MediumContainerHeight)
-                                ) {
-                                    Text(
-                                        text = "Accept",
-                                        style = MaterialTheme.typography.titleMedium,
-                                    )
-                                }
-                            }
-                        }
-
-                        else -> {
-                            ChatInput(
-                                value = text,
-                                onValueChange = { text = it },
-                                onSend = {
-                                    chatViewModel.sendMessage(id, text)
-                                    text = ""
-                                },
-                                onUpload = {
-                                    fileLauncher.launch("image/*")
-                                },
-                                onMicClick = {
-                                    val intent =
-                                        Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
-                                            putExtra(
-                                                RecognizerIntent.EXTRA_LANGUAGE_MODEL,
-                                                RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
-                                            )
-                                            putExtra(RecognizerIntent.EXTRA_PROMPT, "Speak now...")
-                                        }
-                                    try {
-                                        sttLauncher.launch(intent)
-                                    } catch (e: Exception) {
-                                        scope.launch {
-                                            snackbarHostState.showSnackbar("Speech recognition not available")
+                                ChatInput(
+                                    value = text,
+                                    onValueChange = { text = it },
+                                    onSend = {
+                                        viewModel.sendMessage(text, replyingTo?.id)
+                                        text = ""
+                                        replyingTo = null
+                                    },
+                                    onUpload = {
+                                        fileLauncher.launch("image/*")
+                                    },
+                                    onMicClick = {
+                                        val intent =
+                                            Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+                                                putExtra(
+                                                    RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+                                                    RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+                                                )
+                                                putExtra(
+                                                    RecognizerIntent.EXTRA_PROMPT,
+                                                    "Speak now..."
+                                                )
+                                            }
+                                        try {
+                                            sttLauncher.launch(intent)
+                                        } catch (e: Exception) {
+                                            scope.launch {
+                                                snackbarHostState.showSnackbar("Speech recognition not available")
+                                            }
                                         }
                                     }
-                                }
-                            )
+                                )
+                            }
                         }
                     }
                 }
             }
+        )
+        AnimatedVisibility(
+            visible = selectedMessage != null,
+            enter = fadeIn(),
+            exit = fadeOut()
+        ) {
+            val (model, bounds) = selectedMessage ?: return@AnimatedVisibility
+
+            val density = LocalDensity.current
+            val scrollState = rememberScrollState()
+
+            var menuHeight by remember { mutableFloatStateOf(0f) }
+            var toolbarHeight by remember { mutableFloatStateOf(0f) }
+            val spacing = with(density) { 6.dp.toPx() }
+
+            Box(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .background(Color.Black.copy(alpha = 0.4f))
+                    .clickable { selectedMessage = null }
+                    .verticalScroll(scrollState),
+            ) {
+                val totalExtraHeight = (if (menuHeight > 0) menuHeight + spacing else 300f) +
+                        (if (toolbarHeight > 0) toolbarHeight + spacing else 100f)
+                val contentBottom = with(density) { (bounds.bottom + totalExtraHeight).toDp() }
+
+                Spacer(modifier = Modifier.height(contentBottom + 200.dp))
+
+                // Reaction Toolbar (Above)
+                Box(
+                    modifier = Modifier
+                        .offset { IntOffset(0, (bounds.top - toolbarHeight - spacing).toInt().coerceAtLeast(0)) }
+                        .onGloballyPositioned { toolbarHeight = it.size.height.toFloat() }
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp),
+                    contentAlignment = if (model.isMine) Alignment.CenterEnd else Alignment.CenterStart
+                ) {
+                    ReactionToolbar(
+                        onReaction = { reaction ->
+                            viewModel.sendReaction(model.id, reaction)
+                            selectedMessage = null
+                        }
+                    )
+                }
+
+                // Message Preview
+                ChatMessage(
+                    model = model,
+                    modifier = Modifier
+                        .offset { IntOffset(0, bounds.top.toInt()) }
+                        .padding(horizontal = 16.dp)
+                )
+
+                // Action Menu (Below)
+                Box(
+                    modifier = Modifier
+                        .offset { IntOffset(0, (bounds.bottom + spacing).toInt()) }
+                        .onGloballyPositioned { menuHeight = it.size.height.toFloat() }
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp),
+                    contentAlignment = if (model.isMine) Alignment.CenterEnd else Alignment.CenterStart
+                ) {
+                    ContextMenu(
+                        onAction = { action ->
+                            when (action) {
+                                "Copy" -> {
+                                    scope.launch {
+                                        val content = model.annotatedContent
+                                        val data = ClipData.newPlainText(content, content)
+                                        clipboardManager.setClipEntry(ClipEntry(data))
+                                    }
+                                }
+
+                                "Reply" -> {
+                                    replyingTo = model
+                                }
+
+                                else -> {}
+                            }
+                            selectedMessage = null
+                        }
+                    )
+                }
+            }
         }
+    }
+}
+
+@Composable
+private fun ReplyBox(model: MessageModel, onDismiss: () -> Unit) {
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(model) { profileCache.getMetadata(model.author) }
+    val profile by profileFlow.collectAsStateWithLifecycle()
+
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp),
+    ) {
+        Surface(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { onDismiss() },
+            color = MaterialTheme.colorScheme.tertiaryContainer,
+            shape = RoundedCornerShape(16.dp),
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+            ) {
+                Text(
+                    text = "Replying to ${profile?.name}",
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onTertiaryContainer.copy(
+                        alpha = 0.6f
+                    ),
+                )
+                Text(
+                    text = model.annotatedContent.toString().ifBlank {
+                        if (model.images.isNotEmpty()) "[Image]" else ""
+                    },
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onTertiaryContainer,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun ReplyPreview(
+    event: UnsignedEvent,
+    isMine: Boolean = false,
+    onClick: () -> Unit
+) {
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(event) { profileCache.getMetadata(event.author()) }
+    val profile by profileFlow.collectAsStateWithLifecycle()
+
+    val bubbleShape = if (isMine) {
+        RoundedCornerShape(topStart = 20.dp, topEnd = 20.dp, bottomStart = 20.dp, bottomEnd = 4.dp)
+    } else {
+        RoundedCornerShape(topStart = 20.dp, topEnd = 20.dp, bottomStart = 4.dp, bottomEnd = 20.dp)
+    }
+
+    Box(
+        modifier = Modifier.fillMaxWidth(),
+        contentAlignment = if (isMine) Alignment.CenterEnd else Alignment.CenterStart
+    ) {
+        Surface(
+            modifier = Modifier
+                .widthIn(max = 280.dp)
+                .clickable(onClick = onClick),
+            color = MaterialTheme.colorScheme.tertiaryContainer,
+            shape = bubbleShape,
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                verticalArrangement = Arrangement.spacedBy(2.dp)
+            ) {
+                Text(
+                    text = profile?.name ?: "Unknown",
+                    style = MaterialTheme.typography.bodyMedium,
+                    fontWeight = FontWeight.SemiBold,
+                    color = MaterialTheme.colorScheme.onTertiaryContainer,
+                )
+                Text(
+                    text = event.content(),
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onTertiaryContainer,
+                    maxLines = 1,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun ReactionToolbar(
+    onReaction: (String) -> Unit
+) {
+    val reactionEmojis = listOf("👍", "❤️", "😂", "😮", "😢", "😡", "🎉")
+
+    Surface(
+        color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        shape = RoundedCornerShape(24.dp),
+        shadowElevation = 1.dp
+    ) {
+        Row(
+            modifier = Modifier
+                .padding(horizontal = 12.dp, vertical = 8.dp),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            reactionEmojis.forEach { emoji ->
+                Text(
+                    text = emoji,
+                    modifier = Modifier
+                        .clickable { onReaction(emoji) }
+                        .padding(4.dp),
+                    fontSize = 24.sp
+                )
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun ContextMenu(
+    onAction: (String) -> Unit
+) {
+    val menuItems = listOf(
+        "Copy" to Res.drawable.ic_copy,
+        "Reply" to Res.drawable.ic_reply
     )
+
+    DropdownMenuGroup(
+        shapes = MenuDefaults.groupShape(1, 1),
+        containerColor = MenuDefaults.groupVibrantContainerColor,
+        tonalElevation = 1.dp,
+        shadowElevation = 1.dp,
+        modifier = Modifier.width(220.dp)
+    ) {
+        val itemCount = menuItems.size
+
+        menuItems.forEachIndexed { index, (label, icon) ->
+            DropdownMenuItem(
+                shapes = MenuDefaults.itemShape(index, itemCount),
+                colors = MenuDefaults.selectableItemVibrantColors(),
+                text = { Text(label) },
+                leadingIcon = {
+                    Icon(
+                        painter = painterResource(icon),
+                        contentDescription = label,
+                    )
+                },
+                checked = false,
+                onCheckedChange = { _ -> onAction(label) },
+            )
+        }
+    }
 }

composeApp/src/androidMain/kotlin/su/reya/coop/shared/Avatar.kt

@@ -1,5 +1,6 @@
 package su.reya.coop.shared
 
+import androidx.compose.foundation.Image
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.runtime.Composable
@@ -13,6 +14,9 @@ import coil3.compose.AsyncImage
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.avatar
 import org.jetbrains.compose.resources.painterResource
+import su.reya.coop.LocalConnectivity
+import su.reya.coop.LocalSettings
+import su.reya.coop.MediaConfig
 
 @Composable
 fun Avatar(
@@ -22,17 +26,36 @@ fun Avatar(
     size: Dp = 48.dp,
     shape: Shape = CircleShape
 ) {
+    val settings = LocalSettings.current
+    val isMobileData = LocalConnectivity.current
     val placeholder = painterResource(Res.drawable.avatar)
 
-    AsyncImage(
-        model = picture,
-        contentDescription = description,
-        modifier = modifier
-            .size(size)
-            .clip(shape),
-        contentScale = ContentScale.Crop,
-        fallback = placeholder,
-        error = placeholder,
-        placeholder = placeholder
-    )
+    val showMedia = when (settings.media) {
+        MediaConfig.AlwaysEnabled -> true
+        MediaConfig.Disabled -> false
+        MediaConfig.DisabledForMobileData -> !isMobileData
+    }
+
+    if (showMedia) {
+        AsyncImage(
+            model = picture,
+            contentDescription = description,
+            modifier = modifier
+                .size(size)
+                .clip(shape),
+            contentScale = ContentScale.Crop,
+            fallback = placeholder,
+            error = placeholder,
+            placeholder = placeholder
+        )
+    } else {
+        Image(
+            painter = placeholder,
+            contentDescription = description,
+            modifier = modifier
+                .size(size)
+                .clip(shape),
+            contentScale = ContentScale.Crop
+        )
+    }
 }

composeApp/src/androidMain/kotlin/su/reya/coop/shared/ProfileEditor.kt

@@ -54,6 +54,7 @@ import coil3.compose.AsyncImage
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_plus
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -68,8 +69,10 @@ fun ProfileEditor(
     initialName: String = "",
     initialBio: String = "",
     initialPicture: Any? = null, // Accepts Uri (picked) or String (current URL)
+    isBusy: Boolean = false,
     onBack: () -> Unit,
-    onConfirm: suspend (name: String, bio: String, pictureBytes: ByteArray?, contentType: String?) -> Unit
+    onConfirm: (name: String, bio: String, pictureBytes: ByteArray?, contentType: String?) -> Unit,
+    ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
 ) {
     val context = LocalContext.current
     val snackbarHostState = LocalSnackbarHostState.current
@@ -79,7 +82,6 @@ fun ProfileEditor(
     var name by remember(initialName) { mutableStateOf(initialName) }
     var bio by remember(initialBio) { mutableStateOf(initialBio) }
     var picture by remember(initialPicture) { mutableStateOf(initialPicture) }
-    var isBusy by remember { mutableStateOf(false) }
 
     val hasPicture = remember(picture) {
         when (picture) {
@@ -267,9 +269,8 @@ fun ProfileEditor(
                             .size(ButtonDefaults.MediumContainerHeight),
                         onClick = {
                             scope.launch {
-                                isBusy = true
                                 try {
-                                    val bytes = withContext(Dispatchers.IO) {
+                                    val bytes = withContext(ioDispatcher) {
                                         (picture as? Uri)?.let {
                                             context.contentResolver.openInputStream(it)?.readBytes()
                                         }
@@ -280,7 +281,6 @@ fun ProfileEditor(
                                 } catch (e: Exception) {
                                     snackbarHostState.showSnackbar(e.message ?: "Error")
                                 }
-                                isBusy = false
                             }
                         },
                         enabled = name.isNotBlank() && !isBusy

composeApp/src/androidMain/kotlin/su/reya/coop/storage/SecretStore.kt

@@ -1,43 +0,0 @@
-package su.reya.coop.coop.storage
-
-import android.content.Context
-import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
-import kotlinx.coroutines.flow.first
-import su.reya.coop.storage.SecretStorage
-
-private val Context.dataStore by preferencesDataStore("secret_store")
-
-class SecretStore(private val context: Context) : SecretStorage {
-    private val crypto = SecretCrypto()
-
-    override suspend fun set(key: String, value: String) {
-        val entry = crypto.encrypt(value)
-
-        context.dataStore.edit { prefs ->
-            prefs[stringPreferencesKey("${key}_encrypted")] = entry.encrypted
-            prefs[stringPreferencesKey("${key}_iv")] = entry.iv
-        }
-    }
-
-    override suspend fun get(key: String): String? {
-        val prefs = context.dataStore.data.first()
-        val encrypted = prefs[stringPreferencesKey("${key}_encrypted")] ?: return null
-        val iv = prefs[stringPreferencesKey("${key}_iv")] ?: return null
-
-        return crypto.decrypt(SecretEntry(encrypted, iv))
-    }
-
-    override suspend fun clear(key: String) {
-        context.dataStore.edit { prefs ->
-            prefs.remove(stringPreferencesKey("${key}_encrypted"))
-            prefs.remove(stringPreferencesKey("${key}_iv"))
-        }
-    }
-
-    override suspend fun has(key: String): Boolean {
-        val prefs = context.dataStore.data.first()
-        return prefs[stringPreferencesKey("${key}_encrypted")] != null
-    }
-}

shared/build.gradle.kts

@@ -33,6 +33,8 @@ kotlin {
             implementation(libs.ktor.serialization.kotlinx.json)
             implementation(libs.androidx.lifecycle.viewmodelCompose)
             implementation(libs.androidx.lifecycle.runtimeCompose)
+            implementation(libs.androidx.datastore.preferences)
+            implementation(libs.androidx.datastore)
             implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.11.0")
             implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.8.0")
             implementation("su.reya:nostr-sdk-kmp:0.3.2")

shared/src/commonMain/kotlin/su/reya/coop/AppStorage.kt

@@ -0,0 +1,14 @@
+package su.reya.coop
+
+interface AppStorage {
+    // Plain text storage
+    suspend fun get(key: String): String?
+    suspend fun set(key: String, value: String)
+
+    // Encrypted storage
+    suspend fun getSecret(key: String): String?
+    suspend fun setSecret(key: String, value: String)
+
+    suspend fun clear(key: String)
+    suspend fun has(key: String): Boolean
+}

shared/src/commonMain/kotlin/su/reya/coop/ConnectivityMonitor.kt

@@ -0,0 +1,7 @@
+package su.reya.coop
+
+import kotlinx.coroutines.flow.StateFlow
+
+interface ConnectivityMonitor {
+    val isMobileData: StateFlow<Boolean>
+}

shared/src/commonMain/kotlin/su/reya/coop/Extensions.kt

@@ -2,25 +2,23 @@ package su.reya.coop
 
 import rust.nostr.sdk.PublicKey
 
-fun PublicKey.short(): String {
-    val bech32 = toBech32()
-    return bech32.substring(0, 6) + "..." + bech32.substring(bech32.length - 4)
-}
-
 val URL_REGEX = Regex("(https?://\\S+)", RegexOption.IGNORE_CASE)
-private val imageExtensions = setOf("jpg", "jpeg", "png", "gif", "webp", "bmp")
-
-fun String.extractUrls(): List<String> {
-    return URL_REGEX.findAll(this).map { it.value }.toList()
-}
+private val imageExtensions = setOf("jpg", "jpeg", "png", "gif", "webp", "bmp", "avif")
 
 fun String.removeImageUrls(): String {
-    return URL_REGEX.replace(this) { result ->
-        if (result.value.isImageUrl()) "" else result.value
-    }.replace(Regex("\\s+"), " ").trim()
+    return URL_REGEX.replace(this) { if (it.value.isImageUrl()) "" else it.value }.trim()
 }
 
 fun String.isImageUrl(): Boolean {
     val extension = this.substringAfterLast('.', "").lowercase()
     return extension in imageExtensions
 }
+
+fun String.sanitizeName(): String {
+    return this.replace("\n", " ").replace("\r", " ").trim()
+}
+
+fun PublicKey.short(): String {
+    val bech32 = toBech32()
+    return bech32.substring(0, 6) + "..." + bech32.substring(bech32.length - 4)
+}

shared/src/commonMain/kotlin/su/reya/coop/Profile.kt

@@ -10,8 +10,8 @@ data class Profile(
     private val record by lazy { metadata.asRecord() }
 
     val name: String
-        get() = record.displayName ?: record.name ?: publicKey.short()
-    
+        get() = record.displayName?.sanitizeName() ?: record.name ?: publicKey.short()
+
     val picture: String?
         get() = record.picture
 

shared/src/commonMain/kotlin/su/reya/coop/Room.kt

@@ -1,9 +1,5 @@
 package su.reya.coop
 
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.State
-import androidx.compose.runtime.remember
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flowOf
@@ -15,7 +11,7 @@ import kotlinx.datetime.toLocalDateTime
 import rust.nostr.sdk.PublicKey
 import rust.nostr.sdk.Timestamp
 import rust.nostr.sdk.UnsignedEvent
-import su.reya.coop.viewmodel.NostrViewModel
+import su.reya.coop.viewmodel.ProfileCache
 import kotlin.time.Clock
 import kotlin.time.Instant
 
@@ -34,15 +30,15 @@ data class Room(
     val subject: String?,
     val members: Set<PublicKey>,
     val kind: RoomKind = RoomKind.default(),
-    val lastMessage: String? = null
+    val lastMessage: String? = null,
+    val unreadCount: Int = 0
 ) : Comparable<Room> {
     override fun compareTo(other: Room): Int {
         return this.createdAt.asSecs().compareTo(other.createdAt.asSecs())
     }
 
     companion object {
-        fun new(rumor: UnsignedEvent, userPubkey: PublicKey): Room {
-            val id = rumor.roomId()
+        fun new(rumor: UnsignedEvent, userPubkey: PublicKey, id: Long = rumor.roomId()): Room {
             val createdAt = rumor.createdAt()
             val subject = rumor.tags().toVec().find { it.kind() == "subject" }?.content()
 
@@ -67,22 +63,6 @@ data class Room(
         }
     }
 
-    fun setKind(kind: RoomKind): Room {
-        return this.copy(kind = kind)
-    }
-
-    fun setCreatedAt(createdAt: Timestamp): Room {
-        return this.copy(createdAt = createdAt)
-    }
-
-    fun setSubject(subject: String?): Room {
-        return this.copy(subject = subject)
-    }
-
-    fun setLastMessage(message: String?): Room {
-        return this.copy(lastMessage = message)
-    }
-
     fun isGroup(): Boolean = members.size > 1
 }
 
@@ -93,17 +73,19 @@ data class RoomUiState(
 )
 
 fun Room.uiStateFlow(
-    nostrViewModel: NostrViewModel,
+    profileCache: ProfileCache,
     currentUser: PublicKey? = null
 ): Flow<RoomUiState> {
     val displayMembers = if (isGroup()) members.take(2) else members.take(1)
 
     if (!subject.isNullOrBlank()) {
-        return flowOf(RoomUiState(name = subject, isGroup = isGroup()))
+        return flowOf(RoomUiState(name = subject.sanitizeName(), isGroup = isGroup()))
     }
 
-    return combine(displayMembers.map { nostrViewModel.getMetadata(it) }) { profiles ->
-        val names = profiles.mapIndexed { i, profile -> profile?.name ?: displayMembers[i].short() }
+    return combine(displayMembers.map { profileCache.getMetadata(it) }) { profiles ->
+        val names = profiles.mapIndexed { i, profile ->
+            profile?.name?.sanitizeName() ?: displayMembers[i].short()
+        }
 
         val name = when {
             isGroup() -> {
@@ -126,31 +108,13 @@ fun Room.uiStateFlow(
     }
 }
 
-@Composable
-fun Room.rememberUiState(
-    viewModel: NostrViewModel,
-    currentUser: PublicKey? = null
-): State<RoomUiState> {
-    return remember(this, currentUser) {
-        uiStateFlow(
-            viewModel,
-            currentUser
-        )
-    }.collectAsStateWithLifecycle(RoomUiState())
-}
-
 fun UnsignedEvent.roomId(): Long {
     // Collect the author's public key and all public keys from tags
     val pubkeys: MutableList<PublicKey> = mutableListOf()
     pubkeys.add(this.author())
     pubkeys.addAll(this.tags().publicKeys())
-
-    // Sort and hash the list of public keys
-    val sortedUniqueKeys = pubkeys
-        .distinctBy { it.toBech32() }
-        .sortedBy { it.toBech32() }
-
-    return sortedUniqueKeys.hashCode().toLong()
+    
+    return pubkeys.map { it.toBech32() }.distinct().sorted().hashCode().toLong()
 }
 
 fun Timestamp.formatAsTime(): String {
@@ -182,7 +146,7 @@ fun Timestamp.ago(): String {
     }
 }
 
-fun Timestamp.formatAsGroupHeader(): String {
+fun Timestamp.formatAsGroup(): String {
     val timeZone = TimeZone.currentSystemDefault()
     val inputInstant = Instant.fromEpochSeconds(this.asSecs().toLong())
     val inputDate = inputInstant.toLocalDateTime(timeZone).date

shared/src/commonMain/kotlin/su/reya/coop/Settings.kt

@@ -0,0 +1,22 @@
+package su.reya.coop
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Settings(
+    val theme: Theme = Theme.System,
+    val dynamicColor: Boolean = true,
+    val media: MediaConfig = MediaConfig.AlwaysEnabled,
+    val screening: Boolean = true,
+    val blossomServer: String? = "https://blossom.band",
+)
+
+@Serializable
+enum class Theme {
+    Light, Dark, System
+}
+
+@Serializable
+enum class MediaConfig {
+    Disabled, DisabledForMobileData, AlwaysEnabled
+}

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordControl.kt

@@ -0,0 +1,138 @@
+package su.reya.coop.concord
+
+import kotlinx.serialization.decodeFromString
+import rust.nostr.sdk.UnsignedEvent
+import kotlin.time.Instant
+
+/**
+ * Folding the Control Plane (CORD-04 §1).
+ *
+ * The Control Plane carries the Community's authoritative state as **editions**: each is a
+ * `kind 3308` rumor naming its entity (`vsk`), that entity's stable coordinate (`eid`), this
+ * edition's version (`ev`) and the hash of the previous one (`ep`). Every member folds the whole
+ * chain and reaches the same verdict, so authority is arithmetic rather than a server's say-so.
+ *
+ * v1 folds only two entity types: Community metadata (`vsk 0`) and Channel metadata (`vsk 2`).
+ *
+ * ## What v1 does not do
+ *
+ * **The fold is not gated on authority.** CORD-04 judges every edition by its actor's rank in the
+ * owner-rooted Roster, via the `vac` citation. v1 has no Roster, so a `control_root` holder could
+ * publish a forged metadata or Channel edition and v1 would display it.
+ *
+ * That gap is bounded rather than open — only the owner and staff hold `control_root` (CORD-02 §2),
+ * and the spec itself calls that secret "a spam gate, never authority" — but it is real. It is the
+ * reason the feature ships labelled beta. Closing it is CORD-04's job: fold `vsk 1` (Roles) and
+ * `vsk 3` (Grants), then require every edition's `vac` to cite a Grant whose actor strictly
+ * outranks the entity it edits.
+ */
+object ConcordControl {
+
+    /**
+     * Parses one Control rumor into an edition, or null when it is not a foldable edition.
+     *
+     * A `vsk 10` Dissolution tombstone is refused here: it is chainless (no `ev`, no `ep`) and v1
+     * does not implement dissolution, so treating it as an ordinary edition would misread it.
+     */
+    fun editionOf(rumor: UnsignedEvent): ControlEdition? {
+        if (rumor.kind().asU16() != ConcordKind.CONTROL_EDITION.toUShort()) return null
+
+        val tags = rumor.tags().toVec()
+        val vsk = tags.firstOrNull { it.kind() == ConcordTag.VSK }?.content()?.toIntOrNull() ?: return null
+        if (vsk == ConcordVsk.DISSOLVED) return null
+
+        val eidHex = tags.firstOrNull { it.kind() == ConcordTag.EID }?.content() ?: return null
+        if (eidHex.hex32() == null) return null
+
+        val version = tags.firstOrNull { it.kind() == ConcordTag.EV }?.content()?.toULongOrNull() ?: return null
+        // CORD-04: versions climb from 1. A zero version has no place in the chain.
+        if (version == 0uL) return null
+
+        val prev = tags.firstOrNull { it.kind() == ConcordTag.EP }?.content()
+        if (prev != null && prev.hex32() == null) return null
+
+        return ControlEdition(
+            vsk = vsk,
+            eidHex = eidHex.lowercase(),
+            version = version,
+            prevHashHex = prev?.lowercase(),
+            content = rumor.content(),
+            actorHex = rumor.author().toHex(),
+            rumorIdHex = rumor.id()?.toHex() ?: return null,
+            createdAt = Instant.fromEpochSeconds(rumor.createdAt().asSecs().toLong()),
+        )
+    }
+
+    /**
+     * Projects the editions into the metadata and Channel list v1 renders.
+     *
+     * Entities are folded independently: each `(vsk, eid)` group resolves to its own winner, so a
+     * broken chain on one Channel never takes the Community's metadata down with it.
+     */
+    fun fold(editions: List<ControlEdition>, communityIdHex: String): ControlFold {
+        var meta: CommunityMeta? = null
+        val channels = mutableMapOf<String, ChannelMeta>()
+
+        editions.groupBy { it.vsk to it.eidHex }.forEach { (entity, group) ->
+            val (vsk, eidHex) = entity
+            if (vsk != ConcordVsk.METADATA && vsk != ConcordVsk.CHANNEL) return@forEach
+            // The metadata entity *is* the Community, so its coordinate must be the community_id;
+            // an edition naming anything else is not this Community's metadata.
+            if (vsk == ConcordVsk.METADATA && eidHex != communityIdHex) return@forEach
+
+            val winner = winner(group) ?: return@forEach
+            when (vsk) {
+                ConcordVsk.METADATA -> meta = decode(winner.content)
+                else -> decode<ChannelMeta>(winner.content)?.let { channels[eidHex] = it }
+            }
+        }
+
+        return ControlFold(meta = meta, channels = channels)
+    }
+
+    /**
+     * Picks the highest version whose `ep` chain reaches all the way back to version 1.
+     *
+     * "Highest" is not simply `max(ev)`: CORD-04 lets a client refuse to downgrade, so we walk down
+     * from the top and take the first version we can actually verify. A missing predecessor or a
+     * broken link disqualifies that version, not the entity.
+     *
+     * Ties on the same version break on the **lower rumor id**, never on `created_at`, so two
+     * clients folding the same two candidates always agree.
+     */
+    private fun winner(group: List<ControlEdition>): ControlEdition? {
+        val byVersion = group
+            .groupBy { it.version }
+            .mapValues { (_, candidates) -> candidates.minByOrNull { it.rumorIdHex } ?: return null }
+
+        val eid = byVersion.values.firstOrNull()?.eidHex?.hex32() ?: return null
+
+        for (top in byVersion.keys.sortedDescending()) {
+            var prev: ByteArray? = null
+            var candidate: ControlEdition? = null
+            var intact = true
+
+            for (version in 1uL..top) {
+                val edition = byVersion[version]
+                if (edition == null) {
+                    intact = false
+                    break
+                }
+                // The first edition has no predecessor; every later one must chain to the last.
+                val expected = if (version == 1uL) null else prev?.toHex()
+                if (edition.prevHashHex != expected) {
+                    intact = false
+                    break
+                }
+                prev = editionHash(eid, version, prev, edition.content.encodeToByteArray())
+                candidate = edition
+            }
+
+            if (intact) return candidate
+        }
+        return null
+    }
+
+    private inline fun <reified T> decode(content: String): T? =
+        runCatching { concordJson.decodeFromString<T>(content) }.getOrNull()
+}

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordCrypto.kt

@@ -0,0 +1,250 @@
+package su.reya.coop.concord
+
+import okio.Buffer
+import okio.ByteString
+import okio.ByteString.Companion.decodeHex
+import okio.ByteString.Companion.toByteString
+import rust.nostr.sdk.Keys
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.SecretKey
+
+/**
+ * Byte-exact cryptographic primitives from Concord (CORD-02 Appendix A).
+ *
+ * Everything here is frozen by the spec, and a single wrong byte breaks interop silently
+ * rather than loudly — so each function quotes the CORD section that governs it, and each was
+ * checked against RFC 5869 vectors and independently computed digests before it was written.
+ * Concord ships no test vectors of its own ("Examples are illustrative, not verifiable test
+ * vectors"), and no test file is kept — see PLAN.md §14.
+ *
+ * Only HMAC-SHA256 and SHA-256 come from outside: both are Okio `ByteString` members that
+ * are available on every target this module builds for, so no new crypto dependency is
+ * needed. Everything else is composition of the existing nostr SDK.
+ */
+
+/**
+ * HKDF-SHA256 (RFC 5869), Extract then Expand.
+ *
+ * Concord always calls this with no salt (CORD-02 A.1 specifies a zero-length salt, not 32
+ * zero bytes), so [salt] defaults to empty. It is exposed only so the RFC's known-answer
+ * vectors — which do use a salt — can be re-checked by hand; Concord publishes none.
+ *
+ * @param length output length in octets, `1..255 * 32` per RFC 5869.
+ */
+fun hkdfSha256(
+    ikm: ByteArray,
+    info: ByteArray,
+    salt: ByteArray = ByteArray(0),
+    length: Int = 32,
+): ByteArray {
+    require(length in 1..255 * 32) { "HKDF output length must be 1..8160, was $length" }
+
+    // Extract: PRK = HMAC-SHA256(salt, IKM). Note IKM is the HMAC *message*, not the key.
+    // Okio refuses a zero-length HMAC key, while RFC 5869 treats an absent salt as HashLen
+    // (32) zero octets — and HMAC zero-pads any key shorter than its 64-octet block, so the
+    // two are literally the same key. Substituting is exact, not a workaround; the RFC's own
+    // zero-length-salt vector was checked against it.
+    val saltKey = if (salt.isEmpty()) ByteArray(32).toByteString() else salt.toByteString()
+    val prk = ikm.toByteString().hmacSha256(saltKey)
+
+    // Expand: T(n) = HMAC-SHA256(PRK, T(n-1) | info | n), counter being one octet.
+    val out = Buffer()
+    var t = ByteString.EMPTY
+    var counter = 1
+    while (out.size < length) {
+        t = Buffer()
+            .write(t)
+            .write(info)
+            .writeByte(counter)
+            .readByteString()
+            .hmacSha256(prk)
+        out.write(t)
+        counter++
+    }
+    return out.readByteArray(length.toLong())
+}
+
+/**
+ * Builds the HKDF `info` for a Concord label (CORD-02 A.1):
+ *
+ * ```
+ * info = utf8(label) | 0x00 | id[32] | epoch_be[8]   // epoch omitted for labels marked "—"
+ * ```
+ *
+ * [id] is always present and always 32 bytes, all-zeroes where a label has no meaningful
+ * id. The epoch is the only omittable field.
+ */
+fun hkdfInfo(label: String, id: ByteArray, epoch: ULong? = null): ByteArray {
+    require(id.size == 32) { "Concord HKDF id must be 32 bytes, was ${id.size}" }
+    return Buffer().apply {
+        writeUtf8(label)
+        writeByte(0)
+        write(id)
+        if (epoch != null) writeLong(epoch.toLong())
+    }.readByteArray()
+}
+
+/** A plane's derived keypair: `(sk, xonly(sk))` from CORD-02 A.2 `group_key`. */
+data class GroupKey(val secretKey: SecretKey, val publicKey: PublicKey)
+
+/**
+ * The secret-key material of a plane's group key: CORD-02 A.2's `group_key` up to and
+ * including A.3's `scalar_normalize`.
+ *
+ * ```
+ * info = hkdfInfo(label, id, epoch)
+ * seed = hkdf(secret, info)
+ * while (!isValidScalar(seed)) { info = info | counter++; seed = hkdf(secret, info) }
+ * ```
+ *
+ * A.3 only bites when the HKDF output is not a secp256k1 scalar, which is ~2⁻¹²⁸ rare, so
+ * [isValid] exists as a seam for tests; production callers pass the default.
+ *
+ * This is deliberately split from [groupKey]: it is pure byte manipulation and so is
+ * unit-testable, whereas the secp256k1 half needs the nostr SDK, whose native library
+ * cannot be loaded by a host JVM unit test (see PLAN.md §13.2).
+ */
+fun groupSeed(
+    label: String,
+    secret: ByteArray,
+    id: ByteArray,
+    epoch: ULong? = null,
+    isValid: (ByteArray) -> Boolean = ::isValidScalar,
+): ByteArray {
+    val base = hkdfInfo(label, id, epoch)
+    var counter = -1 // -1 means "no counter byte", i.e. the first attempt
+    while (counter <= 255) {
+        val info = if (counter < 0) base else base + byteArrayOf(counter.toByte())
+        val seed = hkdfSha256(secret, info)
+        if (isValid(seed)) return seed
+        counter++ // A.3: the counter starts at 0 on the first retry
+    }
+    error("Concord group_key: scalar_normalize exhausted for label $label")
+}
+
+/**
+ * A secp256k1 secret key is any integer in `[1, n-1]`, so CORD-02 A.3's validity test rejects
+ * exactly the all-zeroes seed and any seed not below the group order.
+ */
+fun isValidScalar(seed: ByteArray): Boolean {
+    if (seed.size != 32) return false
+    var anyNonZero = false
+    for (byte in seed) {
+        if (byte != 0.toByte()) {
+            anyNonZero = true
+            break
+        }
+    }
+    if (!anyNonZero) return false
+    for (i in 0 until 32) {
+        val candidate = seed[i].toInt() and 0xff
+        val order = SECP256K1_ORDER[i].toInt() and 0xff
+        if (candidate != order) return candidate < order
+    }
+    return false // exactly n, also out of range
+}
+
+private val SECP256K1_ORDER =
+    "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141".hexToBytes()
+
+/**
+ * `group_key` (CORD-02 A.2): a plane's keypair, `(scalar_normalize(seed), xonly_pubkey(sk))`.
+ *
+ * The `conv_key` of A.2 needs no implementation of its own — it *is* the NIP-44 conversation
+ * key, which the SDK derives from the pair returned here, so nothing here hand-rolls ECDH.
+ */
+fun groupKey(label: String, secret: ByteArray, id: ByteArray, epoch: ULong? = null): GroupKey {
+    val secretKey = SecretKey.fromBytes(groupSeed(label, secret, id, epoch))
+    return GroupKey(secretKey, Keys(secretKey).publicKey())
+}
+
+/**
+ * `community_id` (CORD-02 A.4), which is also the community's self-certification:
+ *
+ * ```
+ * community_id = sha256( utf8("concord/community") | owner_xonly[32] | owner_salt[32] )
+ * ```
+ *
+ * Note this is a plain SHA-256 commitment with **no** `0x00` separator and no length
+ * prefix — it is deliberately *not* the HKDF construction of A.1, despite looking like it.
+ */
+fun communityId(ownerXonly: ByteArray, ownerSalt: ByteArray): ByteArray {
+    require(ownerXonly.size == 32) { "owner_xonly must be 32 bytes, was ${ownerXonly.size}" }
+    require(ownerSalt.size == 32) { "owner_salt must be 32 bytes, was ${ownerSalt.size}" }
+    return Buffer().apply {
+        writeUtf8(ConcordLabel.COMMUNITY)
+        write(ownerXonly)
+        write(ownerSalt)
+    }.readByteString().sha256().toByteArray()
+}
+
+/**
+ * `prevcommit` (CORD-02 A.8) — the commitment to the previous epoch's key, published when
+ * an epoch rolls so that members can verify the rotation chained from what they held:
+ *
+ * ```
+ * prevcommit = sha256( utf8("concord/epoch-key-commitment") | prev_epoch_be[8] | prev_key[32] )
+ * ```
+ */
+fun prevCommit(prevEpoch: ULong, prevKey: ByteArray): ByteArray {
+    require(prevKey.size == 32) { "prev_key must be 32 bytes, was ${prevKey.size}" }
+    return Buffer().apply {
+        writeUtf8(ConcordLabel.EPOCH_KEY_COMMITMENT)
+        writeLong(prevEpoch.toLong())
+        write(prevKey)
+    }.readByteString().sha256().toByteArray()
+}
+
+/**
+ * `edition_hash` (CORD-02 A.8) — links a Control edition to its predecessor, so a client
+ * folding the Control plane can detect a rewritten chain:
+ *
+ * ```
+ * edition_hash = sha256(
+ *     len64(label) | label                      // label = ConcordLabel.EDITION_HASH
+ *     | entity_id[32]
+ *     | version_be[8]
+ *     | (prev ? 0x01 | prev[32] : 0x00 | zero[32])
+ *     | len64(content) | content )              // content bytes verbatim, never re-serialized
+ * ```
+ *
+ * [content] must be the exact bytes that were signed — re-serializing the JSON would change
+ * the hash.
+ */
+fun editionHash(entityId: ByteArray, version: ULong, prev: ByteArray?, content: ByteArray): ByteArray {
+    require(entityId.size == 32) { "entity_id must be 32 bytes, was ${entityId.size}" }
+    require(prev == null || prev.size == 32) { "prev must be 32 bytes" }
+    val label = ConcordLabel.EDITION_HASH.encodeToByteArray()
+    return Buffer().apply {
+        writeLong(label.size.toLong())
+        write(label)
+        write(entityId)
+        writeLong(version.toLong())
+        if (prev != null) {
+            writeByte(1)
+            write(prev)
+        } else {
+            writeByte(0)
+            write(ByteArray(32))
+        }
+        writeLong(content.size.toLong())
+        write(content)
+    }.readByteString().sha256().toByteArray()
+}
+
+/** 64 lowercase hex chars, the encoding CORD-01 mandates for every 32-byte value on the wire. */
+internal fun ByteArray.toHex(): String = toByteString().hex()
+
+/** Inverse of [toHex]. Throws on odd length or a non-hex character. */
+internal fun String.hexToBytes(): ByteArray = decodeHex().toByteArray()
+
+/** Inverse of [toHex], returning null instead of throwing — for reading untrusted input. */
+internal fun String.hexToBytesOrNull(): ByteArray? = runCatching { hexToBytes() }.getOrNull()
+
+/**
+ * A 32-byte value read from hex, or null when it is not exactly 32 bytes.
+ *
+ * The length check is the point: most of Concord's ids and keys are 32 bytes, and a short or long
+ * value must be rejected before it reaches a derivation that assumes a fixed width.
+ */
+internal fun String.hex32(): ByteArray? = if (length == 64) hexToBytesOrNull() else null

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordInvite.kt

@@ -0,0 +1,253 @@
+package su.reya.coop.concord
+
+import kotlin.io.encoding.Base64
+import rust.nostr.sdk.Nip19Coordinate
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.nip44Decrypt
+
+/**
+ * CORD-05: redeeming an invite.
+ *
+ * Two ways to be handed the keys, one bundle:
+ *
+ * - **Public link** — `$BASE/invite/<naddr>#<fragment>`. The naddr names where the encrypted
+ *   bundle sits on relays; the fragment carries an off-network unlock token and never reaches a
+ *   server. The bundle is fetched, then decrypted with a key derived from the token.
+ * - **Direct Invite** — the same bundle, giftwrapped straight to an npub. Nothing to fetch. That
+ *   path needs only [decryptInviteBundle]; the arrival is handled in `ConcordManager.onInboxRumor`.
+ *
+ * Minting is out of v1's scope, so this file only decodes.
+ *
+ * A bundle is attacker-crafted input reached by following a link, so nothing here allocates on the
+ * strength of what the bundle claims (CORD-05 §1).
+ */
+
+/** The stock relay dictionary (CORD-05 §3). Referenced by one byte so links stay short. */
+internal object ConcordRelayDictionary {
+    val STOCK = listOf(
+        "wss://jskitty.com/nostr",
+        "wss://asia.vectorapp.io/nostr",
+        "wss://relay.ditto.pub",
+        "wss://relay.dreamith.to",
+    )
+}
+
+/** The link's secret half: `[version][flags][relays?][token:16]`, base64url without padding. */
+data class InviteFragment(
+    val version: Int,
+    val relays: List<String>,
+    /** The 16-byte unlock token, hex. Derives exactly one thing: the bundle key. */
+    val tokenHex: String,
+)
+
+/** A parsed invite link: the public locator plus the secret fragment. */
+data class ParsedInvite(
+    val signerHex: String,
+    val identifier: String,
+    /** Relays the naddr itself names. Usually empty; the compact form travels in the fragment. */
+    val naddrRelays: List<RelayUrl>,
+    val fragment: InviteFragment,
+)
+
+private const val FRAGMENT_VERSION = 4
+
+/** The one flag v1 knows: the stock set is in use, so zero relay bytes follow. */
+private const val FLAG_STOCK_RELAYS = 1
+private const val TOKEN_BYTES = 16
+
+/** CORD-05 §3: the fragment only needs to *find* the bundle; the bundle carries the real set. */
+private const val MAX_BOOTSTRAP_RELAYS = 3
+
+/** CORD-05 §1: the spec's reference ceiling on a bundle's Channel list. */
+private const val MAX_INVITE_CHANNELS = 256
+
+/** CORD-02 §6: five stable relays is the recommendation, not a rule; a client may truncate. */
+private const val MAX_COMMUNITY_RELAYS = 5
+
+/** The fragment is unpadded base64url; ABSENT_OPTIONAL also tolerates a padded paste. */
+private val fragmentBase64 = Base64.UrlSafe.withPadding(Base64.PaddingOption.ABSENT_OPTIONAL)
+
+/**
+ * Decodes a link into its locator and fragment, or null when it is not a Concord invite.
+ *
+ * The base domain is deliberately ignored — CORD-05 §2 makes the base interchangeable and says any
+ * client recognizing an invite must respect the naddr and fragment verbatim — so only the last path
+ * segment and the `#` fragment are read.
+ */
+fun parseInviteLink(text: String): ParsedInvite? {
+    val trimmed = text.trim()
+    val hash = trimmed.indexOf('#')
+    if (hash <= 0 || hash == trimmed.lastIndex) return null
+
+    val naddr = trimmed.substring(0, hash).substringAfterLast('/')
+    val fragment = decodeInviteFragment(trimmed.substring(hash + 1)) ?: return null
+
+    val coordinate = runCatching { Nip19Coordinate.fromBech32(naddr) }.getOrNull() ?: return null
+    if (coordinate.coordinate().kind().asU16() != ConcordKind.INVITE_BUNDLE.toUShort()) return null
+
+    return ParsedInvite(
+        signerHex = coordinate.coordinate().publicKey().toHex(),
+        identifier = coordinate.coordinate().identifier(),
+        naddrRelays = coordinate.relays(),
+        fragment = fragment,
+    )
+}
+
+/**
+ * CORD-05 §3's fragment layout:
+ *
+ * ```
+ * [version=4][flags][relays?][token:16]
+ * ```
+ *
+ * With the stock flag set no relay bytes follow. Otherwise a count byte precedes that many entries,
+ * each a leading byte selecting a dictionary id, a host with `wss://` implied, or a verbatim URL.
+ */
+fun decodeInviteFragment(fragment: String): InviteFragment? {
+    val bytes = runCatching { fragmentBase64.decode(fragment) }.getOrNull() ?: return null
+    // Two header bytes plus the token at minimum.
+    if (bytes.size < 2 + TOKEN_BYTES) return null
+
+    val reader = FragmentReader(bytes)
+    if (reader.byte() != FRAGMENT_VERSION) return null
+
+    val flags = reader.byte() ?: return null
+    // The stock flag selects the whole dictionary, so nothing extra is carried and the cap on
+    // explicit entries does not apply to it.
+    val relays = if (flags and FLAG_STOCK_RELAYS != 0) {
+        ConcordRelayDictionary.STOCK
+    } else {
+        val count = reader.byte() ?: return null
+        buildList {
+            repeat(count) {
+                val lead = reader.byte() ?: return null
+                val relay = when (lead) {
+                    0 -> reader.slice(reader.byte() ?: return null)?.let { "wss://$it" }
+                    255 -> reader.slice(reader.byte() ?: return null)
+                    else -> ConcordRelayDictionary.STOCK.getOrNull(lead - 1)
+                } ?: return null
+                add(relay)
+            }
+        }.take(MAX_BOOTSTRAP_RELAYS)
+    }
+
+    // Whatever is left must be exactly the token: a short one silently weakens the link.
+    val token = bytes.copyOfRange(reader.index, bytes.size)
+    if (token.size != TOKEN_BYTES) return null
+
+    return InviteFragment(
+        version = FRAGMENT_VERSION,
+        relays = relays,
+        tokenHex = token.toHex(),
+    )
+}
+
+/**
+ * `bundle_key = hkdf(token, "concord/invite-key")` (CORD-05 §2). The token derives exactly this one
+ * thing — decrypting the bundle — and nothing else.
+ *
+ * Modelled as a `group_key` with an all-zero `id` and no epoch, per CORD-02 A.6, because the spec's
+ * `nip44_encrypt(bundle_key, …)` is the same self-ECDH conversation key every other Concord
+ * `nip44_encrypt` call uses (CORD-01). Encoding it as a keypair rather than a raw conversation key
+ * is what lets the existing SDK do the encryption instead of hand-rolling NIP-44.
+ */
+fun inviteBundleKey(tokenHex: String): GroupKey? =
+    tokenHex.hexToBytesOrNull()?.let { groupKey(ConcordLabel.INVITE_KEY, it, ByteArray(32)) }
+
+/** Decrypts a `kind 33301` bundle's content into [CommunityInvite], or null on any failure. */
+fun decryptInviteBundle(content: String, key: GroupKey): CommunityInvite? {
+    val plaintext = runCatching { nip44Decrypt(key.secretKey, key.publicKey, content) }.getOrNull()
+        ?: return null
+    return runCatching { concordJson.decodeFromString<CommunityInvite>(plaintext) }.getOrNull()
+}
+
+/** CORD-05 §2: a link is retired by re-posting its coordinate as a `vsk 9` tombstone. */
+fun isInviteTombstone(vsk: String?): Boolean = vsk == ConcordVsk.INVITE_TOMBSTONE.toString()
+
+/**
+ * CORD-05 §1's required checks, in the order the spec gives them. Returns every problem found so
+ * the preview can explain itself rather than silently refusing.
+ *
+ * The first one is the load-bearing one: `community_id == sha256("concord/community" ‖ owner ‖
+ * owner_salt)` is what stops a bundle smuggling a false owner or a fake key for a real Community.
+ */
+fun CommunityInvite.problems(): List<String> {
+    val problems = mutableListOf<String>()
+
+    val ownerBytes = owner.hex32()
+    val saltBytes = ownerSalt.hex32()
+    val rootBytes = communityRoot.hex32()
+    if (ownerBytes == null) problems += "The invite's owner key is malformed"
+    if (saltBytes == null) problems += "The invite's owner salt is malformed"
+    if (rootBytes == null) problems += "The invite's community key is malformed"
+
+    if (ownerBytes != null && saltBytes != null) {
+        if (communityId(ownerBytes, saltBytes).toHex() != communityId.lowercase()) {
+            problems += "The invite does not prove its community id"
+        }
+    }
+    if (communityId.hex32() == null) problems += "The invite's community id is malformed"
+    if (controlPk != null && controlPk.hex32() == null) problems += "The invite's control key is malformed"
+
+    if (channels.size > MAX_INVITE_CHANNELS) {
+        problems += "The invite carries ${channels.size} channels (max $MAX_INVITE_CHANNELS)"
+    }
+    channels.forEachIndexed { index, channel ->
+        if (channel.id.hex32() == null) problems += "Channel $index has a malformed id"
+        if (channel.key.hex32() == null) problems += "Channel $index has a malformed key"
+    }
+
+    return problems
+}
+
+/** CORD-05 §1: an expired bundle still previews, but joining refuses. */
+fun CommunityInvite.isExpired(nowMs: Long): Boolean = expiresAt != null && expiresAt <= nowMs
+
+/**
+ * The Community's relay set as the invite names it. [fallback] is the link's bootstrap relays,
+ * used only when the bundle lists none: the bootstrap set exists to *find* the bundle, and the
+ * bundle's copy is the join-time snapshot of the real set (CORD-02 §6).
+ */
+fun CommunityInvite.relaySet(fallback: List<String> = emptyList()): List<String> {
+    val source = relays.ifEmpty { fallback }
+    return source.map { it.trim() }.filter { it.isNotEmpty() }.distinct().take(MAX_COMMUNITY_RELAYS)
+}
+
+/** Turns a validated bundle into the membership we persist. */
+fun CommunityInvite.toMembership(relays: List<String>): Membership = Membership(
+    communityId = communityId.lowercase(),
+    owner = owner.lowercase(),
+    ownerSalt = ownerSalt.lowercase(),
+    communityRoot = communityRoot.lowercase(),
+    rootEpoch = rootEpoch,
+    controlPk = controlPk?.lowercase(),
+    controlRoot = null,
+    relays = relays,
+    name = name,
+    channels = channels.map { channel ->
+        StoredChannelKey(
+            id = channel.id.lowercase(),
+            key = channel.key.lowercase(),
+            epoch = channel.epoch,
+            name = channel.name,
+            // A Public Channel is one whose key *is* the community_root (CORD-03 §1), which is the
+            // only reading the bundle supports. The Control fold overrides this for display.
+            private = !channel.key.equals(communityRoot, ignoreCase = true),
+        )
+    },
+)
+
+/** Reads the fragment's length-prefixed fields, refusing to run past the end. */
+private class FragmentReader(private val bytes: ByteArray) {
+    var index = 0
+        private set
+
+    fun byte(): Int? = if (index < bytes.size) bytes[index++].toInt() and 0xff else null
+
+    fun slice(length: Int): String? {
+        if (length < 0 || index + length > bytes.size) return null
+        val value = bytes.decodeToString(index, index + length)
+        index += length
+        return value
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordKind.kt

@@ -0,0 +1,282 @@
+package su.reya.coop.concord
+
+/**
+ * Frozen constants from the Concord specification.
+ *
+ * Concord is defined by the CORD documents (github.com/concord-protocol/concord); the
+ * numbers, labels and permission bits below are normative and must match byte for byte
+ * or nothing interoperates. They are collected in this one file so that a spec revision
+ * is a one-file change and so that no literal kind number ever appears at a call site.
+ *
+ * References are to the CORD section that defines each value. See `PLAN.md` Appendix A
+ * for the same tables with prose.
+ */
+
+/**
+ * Event kinds, either the outer wrap or the inner rumor it carries (CORD-01, CORD-02 §5,
+ * CORD-02 Appendix B).
+ */
+object ConcordKind {
+    /** NIP-59 gift wrap. Concord reuses it but reverses the roles: fixed author, ephemeral `p`. */
+    const val WRAP = 1059
+
+    /** Ephemeral wrap for kinds that must never be stored (typing, voice presence). */
+    const val EPHEMERAL_WRAP = 21059
+
+    /**
+     * Sealed content for everything that must stay secret: Chat, Guestbook, rekey blobs
+     * and Direct Invites. CORD-02 §5 makes this choice normative, never stylistic.
+     */
+    const val SEAL = 20013
+
+    /**
+     * Plaintext seal. **Control plane only** (CORD-02 §5) — the roster is public by design
+     * so that membership, and therefore authority, is verifiable by anyone.
+     */
+    const val PLAINTEXT_SEAL = 20014
+
+    /** Channel message (NIP-C7 shape). Chat plane. */
+    const val MESSAGE = 9
+
+    /** Threaded reply (NIP-22 shape). Chat plane. */
+    const val REPLY = 1111
+
+    /** Reaction (NIP-25 shape). Chat plane. */
+    const val REACTION = 7
+
+    /** Delete (NIP-09 shape). Chat plane. */
+    const val DELETE = 5
+
+    /** Disappearing-message timer notice (CORD-08 §4). Chat plane. */
+    const val TIMER_NOTICE = 1740
+
+    /** Edit. Chat plane. */
+    const val EDIT = 3302
+
+    /** Rekey blobs (CORD-06). Rekey addresses. */
+    const val REKEY = 3303
+
+    /** Join / Leave. Guestbook plane. */
+    const val JOIN_LEAVE = 3306
+
+    /** Control edition — sub-kinded by [ConcordVsk]. Control plane. */
+    const val CONTROL_EDITION = 3308
+
+    /** Kick. Guestbook plane. */
+    const val KICK = 3309
+
+    /** WebXDC peer signal. Chat plane. */
+    const val WEBXDC_SIGNAL = 3310
+
+    /** Guestbook snapshot, chunked, refounder-signed. Guestbook plane. */
+    const val GUESTBOOK_SNAPSHOT = 3312
+
+    /** Typing indicator. Chat plane, ephemeral. */
+    const val TYPING = 23311
+
+    /** Voice presence (CORD-07). Chat plane, ephemeral. */
+    const val VOICE_PRESENCE = 23313
+
+    /** Direct Invite — giftwrapped straight to an npub. Rides a standard wrap, not a stream. */
+    const val DIRECT_INVITE = 3313
+
+    /** Public invite bundle. Addressable, signed by its per-link keypair at an empty `d`. */
+    const val INVITE_BUNDLE = 33301
+
+    /** Community List — one addressable event per fragment, NIP-44 to self. */
+    const val COMMUNITY_LIST = 33302
+
+    /** Invite List — replaceable, NIP-44 to self. */
+    const val INVITE_LIST = 13303
+}
+
+/** Control edition sub-kinds, the `vsk` tag on [ConcordKind.CONTROL_EDITION] (CORD-02 Appendix A). */
+object ConcordVsk {
+    /** Community metadata. */
+    const val METADATA = 0
+
+    /** Role. */
+    const val ROLE = 1
+
+    /** Channel metadata — the only other edition v1 folds. */
+    const val CHANNEL = 2
+
+    /** Grant. */
+    const val GRANT = 3
+
+    /** Banlist. */
+    const val BANLIST = 4
+
+    /** Reserved for role ordering. */
+    const val RESERVED_ROLE_ORDER = 5
+
+    /** Claimed by the invite bundle's live marker. */
+    const val INVITE_LIVE = 6
+
+    /** Retired (was the v1 owner attestation). */
+    const val RETIRED_OWNER_ATTESTATION = 7
+
+    /** Invite-link registry. */
+    const val INVITE_REGISTRY = 8
+
+    /** Claimed by the invite bundle's revocation tombstone. */
+    const val INVITE_TOMBSTONE = 9
+
+    /** Dissolved tombstone — chainless, exempt from version discipline. */
+    const val DISSOLVED = 10
+
+    /** Pin List. */
+    const val PIN_LIST = 11
+}
+
+/**
+ * Permission bits (CORD-04 §3). Rank ordering is separate: `position` orders authority and
+ * **lower is higher**, with the owner at position 0.
+ */
+object ConcordPermission {
+    const val MANAGE_ROLES = 1 shl 0
+    const val MANAGE_CHANNELS = 1 shl 1
+    const val MANAGE_METADATA = 1 shl 2
+    const val KICK = 1 shl 3
+    const val BAN = 1 shl 4
+    const val MANAGE_MESSAGES = 1 shl 5
+    const val CREATE_INVITE = 1 shl 6
+
+    /** Retired (was `MANAGE_INVITES`). Never grant it. */
+    const val RETIRED_MANAGE_INVITES = 1 shl 7
+
+    const val VIEW_AUDIT_LOG = 1 shl 8
+    const val MENTION_EVERYONE = 1 shl 9
+
+    // 1 shl 10 is reserved.
+
+    const val PIN_MESSAGES = 1 shl 11
+
+    // 1 shl 12 is reserved.
+
+    /**
+     * Staff = anyone holding a staff bit, plus the owner. Staff are the ones who hold
+     * `control_root` and can therefore write to the Control plane.
+     */
+    const val STAFF = MANAGE_ROLES or MANAGE_CHANNELS or MANAGE_METADATA or
+        BAN or CREATE_INVITE or PIN_MESSAGES
+}
+
+/**
+ * HKDF label registry (CORD-02 Appendix A.6). The label is the *first* field of the HKDF
+ * `info` (see `hkdfInfo`), so these strings are on the wire and must not be edited.
+ */
+object ConcordLabel {
+    /** A Channel's group key. `secret` = channel key, or `community_root` for a public channel. */
+    const val CHANNEL = "concord/channel"
+
+    /** Control Plane **read** key. `secret` = `community_root`. */
+    const val CONTROL = "concord/control"
+
+    /** Control Plane signer, held by staff only. `secret` = `control_root`. */
+    const val CONTROL_SIGNER = "concord/control-signer"
+
+    /** Guestbook Plane group key. `secret` = `community_root`. */
+    const val GUESTBOOK = "concord/guestbook"
+
+    /** Dissolution tombstone address. `secret` = `community_id`, id = 32 zero bytes, no epoch. */
+    const val DISSOLVED = "concord/dissolved"
+
+    /** A channel rekey address. `secret` = the prior `community_root`. */
+    const val REKEY_PSEUDONYM = "concord/rekey-pseudonym"
+
+    /** A base (community-wide) rekey address. `secret` = the prior `community_root`. */
+    const val BASE_REKEY_PSEUDONYM = "concord/base-rekey-pseudonym"
+
+    /** A rekey blob locator. `secret` = `rotator_xonly ‖ recipient_xonly`. */
+    const val RECIPIENT_PSEUDONYM = "concord/recipient-pseudonym"
+
+    /** SFU room keypair (CORD-07). */
+    const val VOICE_SIGNER = "concord/voice-signer"
+
+    /** 32-byte call media key (CORD-07). */
+    const val VOICE_MEDIA = "concord/voice-media"
+
+    /** Per-sender frame key (CORD-07). id = `sha256(identity)`, no epoch. */
+    const val VOICE_SENDER = "concord/voice-sender"
+
+    /** A member's Grant coordinate. no epoch. */
+    const val GRANT = "concord/grant"
+
+    /** Banlist coordinate. no epoch. */
+    const val BANLIST = "concord/banlist"
+
+    /** A Channel's Pin List coordinate. no epoch. */
+    const val PINS = "concord/pins"
+
+    /** A creator's invite-link registry coordinate. no epoch. */
+    const val INVITE_LINKS = "concord/invite-links"
+
+    /** Public-invite decrypt key. `secret` = the link's unlock token, no epoch. */
+    const val INVITE_KEY = "concord/invite-key"
+
+    /**
+     * Prefix for the `community_id` commitment (CORD-02 A.4). Not an HKDF label — it is
+     * hashed directly, with no `0x00` separator and no length prefix.
+     */
+    const val COMMUNITY = "concord/community"
+
+    /** Prefix for `prevcommit` (CORD-02 A.8). Also hashed directly, not through HKDF. */
+    const val EPOCH_KEY_COMMITMENT = "concord/epoch-key-commitment"
+
+    /**
+     * Label for `edition_hash` (CORD-02 A.8).
+     *
+     * Deliberately **not** under the `concord/` prefix: the spec pins the reference
+     * implementation's own `vector` label here. Reproduce it exactly.
+     */
+    const val EDITION_HASH = "vector-community/v1/edition"
+}
+
+/** Tag names (CORD-01, CORD-02 §5 and the per-kind sections). */
+object ConcordTag {
+    /** `["ms", "<0..999>"]` — sub-second ordering. True time = `created_at * 1000 + ms`. */
+    const val MS = "ms"
+
+    /** `["p", "<ephemeral pubkey>"]` — the one tag a stream wrap carries (NIP-59 reversed). */
+    const val P = "p"
+
+    /** `["channel", "<channel_id>"]` — MUST also be committed inside the author-signed rumor. */
+    const val CHANNEL = "channel"
+
+    /** `["epoch", "<n>"]` — MUST also be committed inside the author-signed rumor. */
+    const val EPOCH = "epoch"
+
+    /** `["q", "<rumor id>", "", "<author>"]` — NIP-C7 inline quote. */
+    const val QUOTE = "q"
+
+    /** `["vsk", "<n>"]` — Control edition entity type. */
+    const val VSK = "vsk"
+
+    /** `["eid", "<hex32>"]` — stable coordinate of a Control edition's entity. */
+    const val EID = "eid"
+
+    /** `["ev", "<n>"]` — this edition's version, climbing from 1. */
+    const val EV = "ev"
+
+    /** `["ep", "<hash hex>"]` — previous edition hash. Absent on the first edition. */
+    const val EP = "ep"
+
+    /** `["vac", "<grant eid>", "<version>", "<hash>"]` — authority citation. Absent when the owner acts. */
+    const val VAC = "vac"
+
+    /** `["expiration", "<secs>"]` — NIP-40. MUST be on both wrap and rumor, same value. */
+    const val EXPIRATION = "expiration"
+
+    /** `["d", ""]` / `["d", "<index>"]` — addressable coordinate. */
+    const val D = "d"
+
+    /** `["snap", "<id>", "<i>", "<n>"]` — Guestbook snapshot chunk. */
+    const val SNAP = "snap"
+
+    /** `["invite", "<creator hex>", "<label>"]` — optional invite attribution on a join. */
+    const val INVITE = "invite"
+
+    /** `["k", "3313"]` — the one deliberate outer-tag exception on a Direct Invite wrap. */
+    const val K = "k"
+}

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordManager.kt

@@ -0,0 +1,584 @@
+package su.reya.coop.concord
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.serialization.decodeFromString
+import rust.nostr.sdk.AckPolicy
+import rust.nostr.sdk.Event
+import rust.nostr.sdk.Filter
+import rust.nostr.sdk.Kind
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.ReqTarget
+import rust.nostr.sdk.SendEventTarget
+import rust.nostr.sdk.Tag
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.AppStorage
+import su.reya.coop.nostr.Nostr
+import kotlin.concurrent.Volatile
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Concord's read path: which planes we hold keys for, what we fold out of them, and how an invite
+ * turns into membership.
+ *
+ * ## Why this lives on [Nostr]
+ *
+ * The client has exactly **one** notification pump. `client.notifications()` is called once, inside
+ * [Nostr.handleNotifications], and a second consumer would silently split the stream — so Concord
+ * routes through that pump rather than subscribing to its own (see [isPlaneAddress] and [onInboxRumor]).
+ *
+ * ## The two phases
+ *
+ * [restore] is local and fast: it reads memberships from storage and folds whatever the Control
+ * plane has already cached, so routing is meaningful before anything hits the network. [sync] is
+ * the network half: connect the Community's relays and subscribe to its plane addresses. The pump
+ * calls them in that order, so the first event that arrives already knows where it belongs.
+ */
+class ConcordManager(private val nostr: Nostr) {
+
+    /**
+     * Concord's plane pubkeys, keyed by hex. Every incoming `kind 1059` is routed by author: a
+     * Concord wrap is signed by a plane's *derived* stream key and can never be read by the NIP-17
+     * path, which assumes an ephemeral author and a `p`-tagged recipient.
+     *
+     * Replaced wholesale rather than mutated, and read from the notification pump's thread while a
+     * worker coroutine rewrites it, so the reference is volatile.
+     */
+    @Volatile
+    private var planes: Map<String, Plane> = emptyMap()
+
+    /** Latest Control fold per community id. Replaced wholesale; see [planes]. */
+    @Volatile
+    private var folds: Map<String, ControlFold> = emptyMap()
+
+    /**
+     * Unread badges by Channel id. Replaced wholesale; see [planes]. In memory only, mirroring
+     * `Room.unreadCount` in the chat layer, so a restart begins with every badge cleared.
+     */
+    @Volatile
+    private var unread: Map<String, Int> = emptyMap()
+
+    /**
+     * Bumped whenever a plane rumor is cached or a message is sent, so a screen showing a Channel
+     * has something to re-query on. A counter rather than a set of changed scopes, because two
+     * messages to the same Channel must both be observable.
+     */
+    private val _revision = MutableStateFlow(0L)
+    val revision: StateFlow<Long> = _revision.asStateFlow()
+
+    private val _memberships = MutableStateFlow<List<Membership>>(emptyList())
+    val memberships: StateFlow<List<Membership>> = _memberships.asStateFlow()
+
+    private val _communities = MutableStateFlow<List<CommunityState>>(emptyList())
+    val communities: StateFlow<List<CommunityState>> = _communities.asStateFlow()
+
+    /** Direct Invites that arrived giftwrapped to us and have not been accepted or dismissed. */
+    private val _directInvites = MutableStateFlow<List<CommunityInvite>>(emptyList())
+    val directInvites: StateFlow<List<CommunityInvite>> = _directInvites.asStateFlow()
+
+    private var store: ConcordStore? = null
+
+    /**
+     * Hands over the encrypted storage [Nostr] cannot reach on its own.
+     *
+     * [Nostr] is a Context-free singleton, so the Android layer passes [AppStorage] in through
+     * [Nostr.init]. Until this is called nothing can be persisted or restored, and the manager
+     * simply routes nothing.
+     */
+    internal fun attach(storage: AppStorage) {
+        store = ConcordStore(storage, nostr)
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // Routing
+    // -----------------------------------------------------------------------------------------
+
+    /** True when a wrap's author is one of our planes' stream keys. */
+    fun isPlaneAddress(authorHex: String): Boolean = planes.containsKey(authorHex)
+
+    /**
+     * Handles one stream wrap from a plane we hold a key for.
+     *
+     * [PlaneKey.unwrap] runs every check a reader must make and returns null on any failure, so a
+     * forged, unverifiable, mis-bound or undecryptable wrap is dropped here without ever being
+     * rendered. What survives is stored under its logical scope and, for Control, re-folded.
+     */
+    suspend fun handlePlaneEvent(event: Event) {
+        val plane = planes[event.author().toHex()] ?: return
+        val rumor = plane.key.unwrap(event) ?: return
+        val store = store ?: return
+
+        store.cacheRumor(plane.scopeIdHex, event.id().toHex(), rumor)
+        _revision.update { it + 1 }
+
+        // A message from someone else is the only thing a badge counts. Our own wraps come back
+        // through the same subscription and so does a re-fetch, so the check is on the rumor's
+        // author rather than on the arrival.
+        if (plane.role == PlaneRole.Channel) countUnread(plane.scopeIdHex, rumor)
+
+        // Control carries consensus state, so every edition changes what we can read: a new
+        // Channel means a new plane address, and therefore a new subscription.
+        if (plane.role == PlaneRole.Control) refreshControl(plane.communityIdHex)
+    }
+
+    /**
+     * Intercepts rumors that arrive through the ordinary NIP-17 giftwrap pipeline and belong to
+     * Concord instead.
+     *
+     * Returns true when Concord consumed the rumor. A Direct Invite (kind `3313`) rides a *standard*
+     * NIP-59 wrap, so it unwraps fine — but it is a key handoff, not a message, and letting it
+     * through would have the chat layer build a room out of it. Returning true here keeps all
+     * Concord kind knowledge inside this package and leaves the chat code untouched.
+     */
+    fun onInboxRumor(rumor: UnsignedEvent): Boolean {
+        if (rumor.kind().asU16() != ConcordKind.DIRECT_INVITE.toUShort()) return false
+
+        val invite = runCatching { concordJson.decodeFromString<CommunityInvite>(rumor.content()) }.getOrNull()
+        if (invite == null) {
+            println("Concord: a direct invite arrived but its bundle could not be read")
+            return true
+        }
+        if (invite.problems().isNotEmpty()) {
+            println("Concord: refusing a direct invite that does not prove its community id")
+            return true
+        }
+
+        _directInvites.update { current ->
+            if (current.any { it.communityId.equals(invite.communityId, ignoreCase = true) }) current
+            else current + invite
+        }
+        return true
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------------------------
+
+    /** Local half of startup: load memberships, fold the cached Control plane, index the planes. */
+    suspend fun restore() {
+        val store = store ?: return
+        val memberships = store.loadMemberships()
+        _memberships.value = memberships
+
+        // Fold what is already on disk so Channels and metadata render immediately. Live editions
+        // arrive later through handlePlaneEvent and re-fold.
+        folds = memberships.associate { membership ->
+            membership.communityId to ConcordControl.fold(
+                editions = store.cachedRumors(membership.communityId)
+                    .mapNotNull { ConcordControl.editionOf(it) },
+                communityIdHex = membership.communityId,
+            )
+        }
+        refreshPlanes()
+    }
+
+    /** Network half of startup: connect every Community's relays and subscribe to its planes. */
+    suspend fun sync() {
+        for (membership in _memberships.value) {
+            try {
+                subscribeCommunity(membership)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                println("Concord: could not subscribe to ${membership.communityId}: ${e.message}")
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // Invites
+    // -----------------------------------------------------------------------------------------
+
+    /**
+     * Fetches and decrypts the bundle behind a public invite link, so the UI can show what joining
+     * would mean. Nothing is joined, nothing is subscribed and no presence is announced here
+     * (CORD-05 §1: a bundle is passive until the user accepts).
+     */
+    suspend fun previewInvite(link: String): InvitePreview {
+        val parsed = parseInviteLink(link) ?: throw IllegalArgumentException("That is not a Concord invite link")
+        val bundleKey = inviteBundleKey(parsed.fragment.tokenHex)
+            ?: throw IllegalArgumentException("The invite link's token is malformed")
+        val client = nostr.client ?: throw IllegalStateException("Nostr client is not ready")
+
+        // The fragment's bootstrap relays only have to *find* the bundle; the bundle then carries
+        // the Community's real relay set (CORD-05 §3).
+        val relays = (parsed.naddrRelays.map { it.toString() } + parsed.fragment.relays)
+            .mapNotNull { runCatching { RelayUrl.parse(it) }.getOrNull() }
+            .distinct()
+        if (relays.isEmpty()) throw IllegalStateException("The invite link names no relay to fetch from")
+
+        relays.forEach { relay ->
+            client.addRelay(relay)
+            client.connectRelay(relay)
+        }
+
+        val filter = Filter()
+            .kind(Kind(ConcordKind.INVITE_BUNDLE.toUShort()))
+            .author(PublicKey.fromBytes(parsed.signerHex.hexToBytes()))
+            .identifier(parsed.identifier)
+
+        val bundle = client
+            .fetchEvents(ReqTarget.manual(relays.associateWith { listOf(filter) }), timeout = 8.seconds)
+            .toVec()
+            .firstOrNull()
+            ?: throw IllegalStateException("No invite bundle was found at that link")
+
+        if (isInviteTombstone(bundle.tagValue(ConcordTag.VSK))) {
+            throw IllegalStateException("This invite link has been revoked")
+        }
+
+        val invite = decryptInviteBundle(bundle.content(), bundleKey)
+            ?: throw IllegalStateException("The invite bundle could not be opened")
+
+        return preview(invite, link, parsed.fragment.relays)
+    }
+
+    /** The same preview for a Direct Invite, which arrived with no link to fetch. */
+    fun previewDirectInvite(invite: CommunityInvite): InvitePreview = preview(invite, link = null, fallbackRelays = emptyList())
+
+    /** Accepts an invite: persist the keys, connect, subscribe, and announce the join. */
+    suspend fun join(preview: InvitePreview): CommunityState {
+        preview.problems.firstOrNull()?.let { throw IllegalArgumentException(it) }
+        if (preview.expired) throw IllegalArgumentException("That invite has expired")
+
+        val store = store ?: throw IllegalStateException("Concord storage is not ready")
+        val membership = preview.invite.toMembership(preview.relays)
+
+        val updated = _memberships.value.filterNot { it.communityId == membership.communityId } + membership
+        store.saveMemberships(updated)
+        _memberships.value = updated
+
+        refreshPlanes()
+        subscribeCommunity(membership)
+
+        // CORD-02 §5: a Join is each member's own word, published to the Guestbook. There is no
+        // Guestbook fold in v1 — the Control plane is what drives the UI.
+        if (!preview.alreadyJoined) publishJoin(membership, preview.invite)
+
+        _directInvites.update { invites ->
+            invites.filterNot { it.communityId.equals(membership.communityId, ignoreCase = true) }
+        }
+        return _communities.value.firstOrNull { it.membership.communityId == membership.communityId }
+            ?: CommunityState(membership, null, emptyList())
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // Reading
+    // -----------------------------------------------------------------------------------------
+
+    /**
+     * A Channel's messages, oldest first. Reads the local cache; the live subscription is what
+     * keeps it current.
+     */
+    suspend fun channelMessages(channelIdHex: String): List<ConcordMessage> =
+        store?.cachedRumors(channelIdHex).orEmpty()
+            .mapNotNull { it.toConcordMessage() }
+            .sortedBy { it.timestampMs }
+
+    /** A Channel's unread badge. See [ConcordChannel.unreadCount] for what it does and does not survive. */
+    fun unreadCount(channelIdHex: String): Int = unread[channelIdHex] ?: 0
+
+    /** Clears a Channel's badge — the Channel screen calls this once its messages are on display. */
+    fun markChannelRead(channelIdHex: String) {
+        if ((unread[channelIdHex] ?: 0) == 0) return
+        unread = unread - channelIdHex
+        publishUnread(channelIdHex, 0)
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // Writing
+    // -----------------------------------------------------------------------------------------
+
+    /**
+     * Sends a message to a Channel (CORD-03 §3).
+     *
+     * The send *is* [PlaneKey.rumor] plus [PlaneKey.wrap], with nothing in between: the rumor carries
+     * the `channel`/`epoch` binding stamped from the Channel's own key, and the wrap is signed by that
+     * key's stream half, so a message cannot be built for a coordinate it will not verify at.
+     *
+     * The message is cached locally *before* it is published, so it is visible even if every relay is
+     * unreachable and so the subscription's echo of the wrap lands on the same `d` slot instead of
+     * duplicating it.
+     *
+     * Returns the message as a reader will see it. Throws when the Channel is hidden behind a key we
+     * were never granted — a Private Channel is listable without being writable.
+     */
+    suspend fun sendChannelMessage(channelIdHex: String, content: String): ConcordMessage {
+        val client = nostr.client ?: throw IllegalStateException("Nostr client is not ready")
+        val plane = planes.values.firstOrNull {
+            it.role == PlaneRole.Channel && it.scopeIdHex.equals(channelIdHex, ignoreCase = true)
+        } ?: throw IllegalArgumentException("That Channel is not one we hold a key for")
+        val author = nostr.signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+        val rumor = plane.key.rumor(
+            author = author,
+            kind = ConcordKind.MESSAGE.toUShort(),
+            content = content,
+            createdAt = Clock.System.now(),
+        )
+        val wrap = plane.key.wrap(rumor, nostr.signer)
+
+        store?.cacheRumor(plane.scopeIdHex, wrap.id().toHex(), rumor)
+        _revision.update { it + 1 }
+
+        // Always the Community's own relays, never the app's defaults (see [subscribeCommunity]).
+        val relays = _memberships.value
+            .firstOrNull { it.communityId == plane.communityIdHex }
+            ?.relays
+            .orEmpty()
+            .mapNotNull { runCatching { RelayUrl.parse(it) }.getOrNull() }
+        if (relays.isEmpty()) throw IllegalStateException("That Community names no relay to publish to")
+
+        client.sendEvent(event = wrap, target = SendEventTarget.to(relays), ackPolicy = AckPolicy.none())
+            .failed.forEach { (relay, reason) -> println("Concord: $relay refused a message: $reason") }
+
+        return rumor.toConcordMessage()
+            ?: throw IllegalStateException("Concord: could not read back the message just sent")
+    }
+
+    /** Records a badge change and re-publishes [communities] so a badge drawn from it moves. */
+    private fun publishUnread(channelIdHex: String, count: Int) {
+        _communities.update { states ->
+            if (states.none { state -> state.channels.any { it.idHex == channelIdHex } }) return@update states
+            states.map { state ->
+                state.copy(
+                    channels = state.channels.map {
+                        if (it.idHex == channelIdHex) it.copy(unreadCount = count) else it
+                    }
+                )
+            }
+        }
+    }
+
+    /** Counts one incoming message against its Channel, ignoring our own and anything but a message. */
+    private fun countUnread(channelIdHex: String, rumor: UnsignedEvent) {
+        if (rumor.kind().asU16() != ConcordKind.MESSAGE.toUShort()) return
+        if (rumor.author() == nostr.signer.publicKeyFlow.value) return
+
+        val count = (unread[channelIdHex] ?: 0) + 1
+        unread = unread + (channelIdHex to count)
+        publishUnread(channelIdHex, count)
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // Planes
+    // -----------------------------------------------------------------------------------------
+
+    /**
+     * Rebuilds the plane index and the Community read model from the memberships and folds we hold.
+     *
+     * Returns the communities whose set of plane addresses changed, because those are exactly the
+     * ones whose subscription is now stale — a Control edition that adds a Channel adds an address.
+     */
+    private fun refreshPlanes(): Set<String> {
+        val previous = planes
+        val next = mutableMapOf<String, Plane>()
+        val states = mutableListOf<CommunityState>()
+
+        for (membership in _memberships.value) {
+            val communityId = membership.communityId.hex32()
+            val root = membership.communityRoot.hex32()
+            val fold = folds[membership.communityId]
+            val granted = membership.channels.associateBy { it.id }
+
+            if (communityId != null && root != null) {
+                // Control is write-restricted: we hold the read key plus the writers' pubkey, which
+                // is all reading takes (CORD-01, CORD-02 §5). A bundle with no `control_pk` is a
+                // legacy, pre-split Community, whose plane was addressed by the `concord/control`
+                // derivation itself; v1 does not read those, so such a Community shows no metadata.
+                // CORD-02 §5 requires that legacy reading and the first base rotation upgrades it.
+                membership.controlPk?.let { controlPkHex ->
+                    if (controlPkHex.hex32() != null) {
+                        val key = controlPlaneKey(root, communityId, membership.rootEpoch, controlPkHex)
+                        next[key.streamPublicKeyHex] = Plane(
+                            communityIdHex = membership.communityId,
+                            role = PlaneRole.Control,
+                            key = key,
+                            scopeIdHex = membership.communityId,
+                        )
+                    }
+                }
+
+                val guestbook = guestbookPlaneKey(root, communityId, membership.rootEpoch)
+                next[guestbook.streamPublicKeyHex] = Plane(
+                    communityIdHex = membership.communityId,
+                    role = PlaneRole.Guestbook,
+                    key = guestbook,
+                    scopeIdHex = membership.communityId,
+                )
+            }
+
+            val channelIds = (granted.keys + fold?.channels?.keys.orEmpty()).distinct()
+            val channels = channelIds.mapNotNull { channelIdHex ->
+                val meta = fold?.channels?.get(channelIdHex)
+                if (meta?.deleted == true) return@mapNotNull null
+
+                val stored = granted[channelIdHex]
+                val channelId = channelIdHex.hex32()
+                // A Public Channel's key *is* the community_root, so one we were never granted is
+                // still derivable; a Private one is not (CORD-03 §1).
+                val secret = stored?.key?.hex32()
+                    ?: if (meta?.isPrivate != true) root else null
+                val epoch = stored?.epoch ?: membership.rootEpoch
+
+                var plane: PlaneKey? = null
+                if (channelId != null && secret != null) {
+                    plane = channelPlaneKey(secret, channelId, epoch)
+                    next[plane.streamPublicKeyHex] = Plane(
+                        communityIdHex = membership.communityId,
+                        role = PlaneRole.Channel,
+                        key = plane,
+                        scopeIdHex = channelIdHex,
+                    )
+                }
+
+                ConcordChannel(
+                    idHex = channelIdHex,
+                    name = meta?.name ?: stored?.name ?: channelIdHex.take(8),
+                    private = meta?.isPrivate ?: stored?.private ?: false,
+                    epoch = epoch,
+                    hasKey = plane != null,
+                    // Carried across the re-index rather than recomputed: a Control edition must not
+                    // silently clear every badge, the same way ChatRepository preserves its counters.
+                    unreadCount = unread[channelIdHex] ?: 0,
+                )
+            }
+
+            states += CommunityState(
+                membership = membership,
+                meta = fold?.meta,
+                channels = channels.sortedBy { it.name.lowercase() },
+            )
+        }
+
+        planes = next
+        _communities.value = states
+
+        return _memberships.value
+            .filter { membership ->
+                previous.planeKeys(membership.communityId) != next.planeKeys(membership.communityId)
+            }
+            .map { it.communityId }
+            .toSet()
+    }
+
+    /** Re-folds one Community's Control plane from the cache, then re-indexes if planes shifted. */
+    private suspend fun refreshControl(communityIdHex: String) {
+        val store = store ?: return
+        val editions = store.cachedRumors(communityIdHex).mapNotNull { ConcordControl.editionOf(it) }
+        folds = folds + (communityIdHex to ConcordControl.fold(editions, communityIdHex))
+
+        if (communityIdHex in refreshPlanes()) {
+            _memberships.value.firstOrNull { it.communityId == communityIdHex }?.let { subscribeCommunity(it) }
+        }
+    }
+
+    /**
+     * Subscribes to one Community: connect its relays, then ask for every plane's address.
+     *
+     * `channel` and `epoch` are multi-letter tags, and Nostr filters only accept single-letter ones,
+     * so plane addresses are the finest granularity available. That is the right level anyway — one
+     * key per plane — and the `channel`/`epoch` binding is a strict check after decryption.
+     */
+    private suspend fun subscribeCommunity(membership: Membership) {
+        val client = nostr.client ?: return
+        val id = subscriptionId(membership.communityId)
+        client.unsubscribe(id)
+
+        val relays = membership.relays.mapNotNull { runCatching { RelayUrl.parse(it) }.getOrNull() }.distinct()
+        if (relays.isEmpty()) return
+
+        // Always the Community's own relays, never the app's defaults: Concord reverses NIP-59
+        // (fixed author, ephemeral `p`), so a relay enforcing the optional `p`-tag guard drops
+        // these wraps, and the bootstrap set is tuned for NIP-17.
+        relays.forEach { relay ->
+            client.addRelay(relay)
+            client.connectRelay(relay)
+        }
+
+        val filters = planes.values
+            .filter { it.communityIdHex == membership.communityId }
+            .mapNotNull { plane -> plane.key.streamPublicKeyHex.hex32() }
+            .distinct()
+            .map { Filter().kind(Kind(ConcordKind.WRAP.toUShort())).author(PublicKey.fromBytes(it)) }
+        if (filters.isEmpty()) return
+
+        client.subscribe(target = ReqTarget.manual(relays.associateWith { filters }), id = id)
+    }
+
+    /** Publishes a still-fetchable Guestbook Join (CORD-02 §5) — each member's own word. */
+    private suspend fun publishJoin(membership: Membership, invite: CommunityInvite?) {
+        val client = nostr.client ?: return
+        val communityId = membership.communityId.hex32() ?: return
+        val root = membership.communityRoot.hex32() ?: return
+        val author = nostr.signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+        val plane = guestbookPlaneKey(root, communityId, membership.rootEpoch)
+        // CORD-05 §1: an accepting joiner echoes the invite's creator and label, which is what
+        // makes per-link usage counters possible at all.
+        val extraTags = invite?.creatorNpub?.let { creator ->
+            listOf(Tag.custom(ConcordTag.INVITE, listOf(creator, invite.label.orEmpty())))
+        }.orEmpty()
+
+        val rumor = plane.rumor(
+            author = author,
+            kind = ConcordKind.JOIN_LEAVE.toUShort(),
+            content = "join",
+            createdAt = Clock.System.now(),
+            extraTags = extraTags,
+        )
+        val wrap = plane.wrap(rumor, nostr.signer)
+
+        val targets = membership.relays.mapNotNull { runCatching { RelayUrl.parse(it) }.getOrNull() }
+        client.sendEvent(event = wrap, target = SendEventTarget.to(targets), ackPolicy = AckPolicy.none())
+    }
+
+    private fun subscriptionId(communityIdHex: String): String = "$SUBSCRIPTION_PREFIX$communityIdHex"
+
+    private fun preview(
+        invite: CommunityInvite,
+        link: String?,
+        fallbackRelays: List<String>,
+    ): InvitePreview {
+        val relays = invite.relaySet(fallbackRelays)
+        val problems = invite.problems() + if (relays.isEmpty()) listOf("The invite names no relays") else emptyList()
+        return InvitePreview(
+            link = link,
+            invite = invite,
+            relays = relays,
+            problems = problems,
+            expired = invite.isExpired(Clock.System.now().toEpochMilliseconds()),
+            alreadyJoined = _memberships.value.any { it.communityId.equals(invite.communityId, ignoreCase = true) },
+        )
+    }
+
+    private companion object {
+        const val SUBSCRIPTION_PREFIX = "concord:"
+    }
+}
+
+/** What a plane is for — the Community-wide Control and Guestbook planes, or one Channel. */
+private enum class PlaneRole { Control, Guestbook, Channel }
+
+/**
+ * One plane address we hold: the key to decrypt it, the role that says how to fold it, and the
+ * [scopeIdHex] it caches under.
+ */
+private class Plane(
+    val communityIdHex: String,
+    val role: PlaneRole,
+    val key: PlaneKey,
+    val scopeIdHex: String,
+)
+
+private fun Map<String, Plane>.planeKeys(communityIdHex: String): Set<String> =
+    filterValues { it.communityIdHex == communityIdHex }.keys
+
+/** The first content value of a tag, or null. Used for tags read without their companion fields. */
+private fun Event.tagValue(kind: String): String? =
+    tags().toVec().firstOrNull { it.kind() == kind }?.content()

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordModels.kt

@@ -0,0 +1,259 @@
+package su.reya.coop.concord
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import rust.nostr.sdk.UnsignedEvent
+import kotlin.time.Instant
+
+/**
+ * Concord's data model: what we persist about a Community, what an invite carries, and what the
+ * Control fold projects.
+ *
+ * Types that travel on the wire ([CommunityInvite], [CommunityMeta], [ChannelMeta], [ConcordIcon])
+ * keep the spec's snake_case field names because those keys are normative. Types that are ours
+ * alone ([Membership], [StoredChannelKey]) keep Kotlin naming.
+ *
+ * Concord reserves every top-level field it does not define, and CORD-02 §6 requires editors to
+ * round-trip fields they do not understand. v1 only ever *reads* these documents, so the models
+ * below carry just the fields v1 uses and rely on `ignoreUnknownKeys`; anything aimed at writing
+ * them back must preserve what it did not parse.
+ */
+internal val concordJson = Json {
+    ignoreUnknownKeys = true
+    encodeDefaults = true
+}
+
+// ---------------------------------------------------------------------------------------------
+// Persisted
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * A Community this device has joined, as stored locally. Holding these keys *is* membership
+ * (CORD-02 §2), so the whole blob lives in [su.reya.coop.AppStorage]'s encrypted store.
+ *
+ * There is no owner recovery by design: [communityId] commits to [owner], so losing the owner key
+ * cannot be repaired by anyone, including us. Nothing in the UI should suggest otherwise.
+ */
+@Serializable
+data class Membership(
+    /** Hex `community_id`. Never appears on the wire; every coordinate derives from it one-way. */
+    val communityId: String,
+    /** Owner x-only pubkey hex, the other half of the `community_id` commitment. */
+    val owner: String,
+    /** 32-byte hex salt; not secret, travels in invites so anyone can recompute the commitment. */
+    val ownerSalt: String,
+    /** 32-byte hex `community_root`. The base access key — never leaves the encrypted store. */
+    val communityRoot: String,
+    /** Epoch the root was issued at (CORD-02 §3). */
+    val rootEpoch: ULong,
+    /** Control Plane signer pubkey (CORD-02 §5), used to *address* the plane. Trusted on trust. */
+    val controlPk: String? = null,
+    /** Staff-only write key. v1 never writes to the Control Plane, so this stays null. */
+    val controlRoot: String? = null,
+    /** The Community's relays — always from the invite, never the app's defaults (see PLAN.md 13.2). */
+    val relays: List<String> = emptyList(),
+    /** Last known name, cached so a community renders before its Control fold lands. */
+    val name: String? = null,
+    /** Channels this invite actually granted a key for. */
+    val channels: List<StoredChannelKey> = emptyList(),
+)
+
+/**
+ * A Channel key handed out by an invite. Public Channels derive from `community_root` and so carry
+ * it here, which is why [private] can only be a hint — the Control fold is the authority.
+ */
+@Serializable
+data class StoredChannelKey(
+    val id: String,
+    val key: String,
+    val epoch: ULong,
+    val name: String? = null,
+    val private: Boolean = false,
+)
+
+// ---------------------------------------------------------------------------------------------
+// Invite bundle (CORD-05 §1)
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The `CommunityInvite` bundle: the same document whether it arrives inside a public link's
+ * encrypted relay-side event or giftwrapped straight to an npub as a Direct Invite (CORD-05 §6).
+ *
+ * The `community_id` self-certifies the owner, so a bundle cannot smuggle a false owner onto a real
+ * Community. [controlPk] is the one field taken on trust: it derives from a secret the joiner will
+ * never hold, so nothing in the bundle can prove it. Build nothing security-relevant on it.
+ */
+@Serializable
+data class CommunityInvite(
+    @SerialName("community_id") val communityId: String = "",
+    val owner: String = "",
+    @SerialName("owner_salt") val ownerSalt: String = "",
+    @SerialName("community_root") val communityRoot: String = "",
+    @SerialName("root_epoch") val rootEpoch: ULong = 0u,
+    @SerialName("control_pk") val controlPk: String? = null,
+    val channels: List<InviteChannel> = emptyList(),
+    val relays: List<String> = emptyList(),
+    val name: String? = null,
+    val icon: ConcordIcon? = null,
+    /** Unix **milliseconds** — see [expiryToEpochSeconds]. Optional. */
+    @SerialName("expires_at") val expiresAt: Long? = null,
+    @SerialName("creator_npub") val creatorNpub: String? = null,
+    val label: String? = null,
+)
+
+/** One granted Channel inside a bundle. `key` is `community_root` for a Public one (CORD-03 §1). */
+@Serializable
+data class InviteChannel(
+    val id: String = "",
+    val key: String = "",
+    val epoch: ULong = 0u,
+    val name: String? = null,
+)
+
+/**
+ * A pointer to an encrypted blob — icon, banner (CORD-02 §6). The media server holds ciphertext
+ * only; a member fetches, decrypts and verifies [hash]. v1 never fetches these.
+ */
+@Serializable
+data class ConcordIcon(
+    val url: String? = null,
+    val key: String? = null,
+    val nonce: String? = null,
+    val hash: String? = null,
+)
+
+// ---------------------------------------------------------------------------------------------
+// Control fold
+// ---------------------------------------------------------------------------------------------
+
+/** Community metadata — the `vsk 0` entity's content (CORD-02 §6). */
+@Serializable
+data class CommunityMeta(
+    val name: String? = null,
+    val description: String? = null,
+    /** The Community's own relay set. This is the authority; the invite's copy is a snapshot. */
+    val relays: List<String> = emptyList(),
+    val icon: ConcordIcon? = null,
+    val banner: ConcordIcon? = null,
+    /** Disappearing-messages timer in seconds (CORD-08). Read only; v1 does not enforce it. */
+    @SerialName("message_expiration") val messageExpiration: Long? = null,
+)
+
+/** Channel metadata — the `vsk 2` entity's content (CORD-03 §2). */
+@Serializable
+data class ChannelMeta(
+    val name: String? = null,
+    @SerialName("private") val isPrivate: Boolean = false,
+    /** Terminal: the id is never reused and clients drop the Channel (CORD-03 §2). */
+    val deleted: Boolean = false,
+)
+
+/**
+ * One `kind 3308` Control edition, parsed from its rumor (CORD-04 §1, CORD-02 Appendix B).
+ *
+ * The tags are the edition machinery — `vsk` names the entity type, `eid` its stable coordinate,
+ * `ev` this version, `ep` the hash of the previous edition. [content] is the entity's new state as
+ * a JSON string, held verbatim because [editionHash] hashes those bytes and never a re-serialization.
+ */
+data class ControlEdition(
+    val vsk: Int,
+    val eidHex: String,
+    val version: ULong,
+    val prevHashHex: String?,
+    val content: String,
+    val actorHex: String,
+    val rumorIdHex: String,
+    val createdAt: Instant,
+)
+
+/** The projected Control state v1 uses: the Community's metadata and its Channel list. */
+data class ControlFold(
+    val meta: CommunityMeta?,
+    val channels: Map<String, ChannelMeta>,
+)
+
+// ---------------------------------------------------------------------------------------------
+// Read surface
+// ---------------------------------------------------------------------------------------------
+
+/** A Channel as the UI sees it: its identity, and whether we actually hold a key to read it. */
+data class ConcordChannel(
+    val idHex: String,
+    val name: String,
+    val private: Boolean,
+    val epoch: ULong,
+    /** False for a Private Channel we were never granted — listable, but not readable. */
+    val hasKey: Boolean,
+    /**
+     * Messages from others since this Channel was last opened. In memory only, exactly like
+     * `Room.unreadCount`: it survives a Control re-fold, but not a restart.
+     */
+    val unreadCount: Int = 0,
+)
+
+/** A Community with its Control fold applied. */
+data class CommunityState(
+    val membership: Membership,
+    /** Null until a `vsk 0` edition has been folded; the invite's name fills in before that. */
+    val meta: CommunityMeta?,
+    val channels: List<ConcordChannel>,
+)
+
+/** A Chat-plane message, already unwrapped and signature-checked. */
+data class ConcordMessage(
+    val idHex: String,
+    val author: String,
+    val content: String,
+    val createdAt: Instant,
+    /** CORD-02 §4: `created_at * 1000 + ms`. The only ordering basis the protocol uses. */
+    val timestampMs: Long,
+)
+
+/** A redeemed-in-part invite, ready for the UI to preview before anything joins (CORD-05 §1). */
+data class InvitePreview(
+    /** Null for a Direct Invite, which arrives with no link. */
+    val link: String?,
+    val invite: CommunityInvite,
+    /** Resolved relay set: the bundle's, falling back to the link's bootstrap relays. */
+    val relays: List<String>,
+    /** Non-empty means the bundle is refused — these are the reasons, in plain English. */
+    val problems: List<String>,
+    val expired: Boolean,
+    val alreadyJoined: Boolean,
+) {
+    val joinable: Boolean get() = problems.isEmpty() && !expired
+}
+
+// ---------------------------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * CORD-05 §1: the bundle's `expires_at` is unix **milliseconds**, the Invite List's is unix
+ * **seconds**, and a NIP-40 `expiration` tag is **seconds**. Three spellings of one instant, so
+ * every conversion lives here. Returns null when the bundle carries no expiry at all.
+ */
+fun CommunityInvite.expiryToEpochSeconds(): Long? = expiresAt?.let { it / 1000 }
+
+/** CORD-02 §4: true time is `created_at * 1000 + ms`; an absent or out-of-range `ms` reads as 0. */
+internal fun UnsignedEvent.concordTimestampMs(): Long {
+    val ms = tags().toVec()
+        .firstOrNull { it.kind() == ConcordTag.MS }
+        ?.content()
+        ?.toIntOrNull()
+        ?.takeIf { it in 0..999 }
+    return createdAt().asSecs().toLong() * 1000 + (ms ?: 0)
+}
+
+/** Projects a Chat-plane rumor into a [ConcordMessage], or null when it is not a message. */
+internal fun UnsignedEvent.toConcordMessage(): ConcordMessage? {
+    if (kind().asU16() != ConcordKind.MESSAGE.toUShort()) return null
+    return ConcordMessage(
+        idHex = id()?.toHex().orEmpty(),
+        author = author().toHex(),
+        content = content(),
+        createdAt = Instant.fromEpochSeconds(createdAt().asSecs().toLong()),
+        timestampMs = concordTimestampMs(),
+    )
+}

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordPlane.kt

@@ -0,0 +1,308 @@
+package su.reya.coop.concord
+
+import kotlinx.coroutines.CancellationException
+import rust.nostr.sdk.AsyncNostrSigner
+import rust.nostr.sdk.Event
+import rust.nostr.sdk.EventBuilder
+import rust.nostr.sdk.Keys
+import rust.nostr.sdk.Kind
+import rust.nostr.sdk.Nip44Version
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.Tag
+import rust.nostr.sdk.Timestamp
+import rust.nostr.sdk.UnsignedEvent
+import rust.nostr.sdk.nip44Decrypt
+import rust.nostr.sdk.nip44Encrypt
+import kotlin.time.Instant
+
+/**
+ * The CORD-01 wire stack: `wrap → seal → rumor`.
+ *
+ * A stream is a shared key and a stream of gift wraps signed with it. Everything a plane sends
+ * is three nested layers:
+ *
+ * ```
+ * wrap   kind 1059, signed by the stream key, one ephemeral `p` tag
+ *   └ nip44(conv_key) of
+ *     seal   kind 20013 (encrypted) or 20014 (plaintext), signed by the real author
+ *       └ nip44(conv_key) of | byte-verbatim
+ *         rumor   unsigned, its authority is the seal's signature around it
+ * ```
+ *
+ * Both encrypted layers use the *same* conversation key — that is double encryption under one
+ * key, not two, and it is what makes the wrap readable by anyone holding the plane key.
+ *
+ * Concord reverses NIP-59: the author is fixed (the stream key) and the `p` tag is ephemeral,
+ * which is why the app's normal NIP-59 path in `MessageManager.extractRumor` cannot read these
+ * and why routing happens by author before that code is reached.
+ */
+
+/**
+ * Which of CORD-01's two seal forms a plane uses; CORD-02 §5 makes this a fixed property of the
+ * plane, "never a per-message choice". Because the plane owns it, [wrap] cannot pick the wrong
+ * one and [unwrap] can reject a seal of the other form instead of quietly accommodating it.
+ */
+enum class SealForm(private val kindValue: Int) {
+    /**
+     * Chat, Guestbook, rekey. The rumor is NIP-44-encrypted inside the already-encrypted wrap,
+     * so no relay — honest or malicious — can retain and display the rumor as a public event.
+     */
+    Encrypted(ConcordKind.SEAL),
+
+    /**
+     * Control plane only. The seal's content is the rumor's serialized JSON **byte-verbatim**,
+     * because a signature over ciphertext is bound to the key that encrypted it and would break
+     * if re-wrapped under another key across an epoch change.
+     */
+    Plaintext(ConcordKind.PLAINTEXT_SEAL);
+
+    val kind: UShort get() = kindValue.toUShort()
+}
+
+/**
+ * CORD-03 §3: what a Chat-plane rumor must commit so a member cannot re-wrap another's message
+ * into a different Channel or replay it across an epoch.
+ *
+ * The tags live *inside* the author-signed rumor, so the author's signature covers them; the
+ * reader checks them strict-equal against the coordinate whose key opened the wrap.
+ */
+data class ChatBinding(val channelIdHex: String, val epoch: ULong)
+
+/**
+ * One plane's keys and, for a Chat plane, the coordinate its rumors are bound to.
+ *
+ * [read] decrypts: it is the conversation key for the wrap and for an encrypted seal. [stream]
+ * is the address that signs wraps. They are the same key on a normal stream, and differ only on
+ * a write-restricted one (CORD-01, used by the Control Plane in CORD-02 §5) — where a reader
+ * holds the read key plus the writers' *pubkey*, enough to verify a wrap but not to mint one.
+ *
+ * Deliberately not a `data class`: there is no value equality worth having, and the default
+ * `toString` keeps key material out of logs.
+ */
+class PlaneKey(
+    val read: GroupKey,
+    val stream: GroupKey?,
+    /** The x-only hex of the key every wrap on this plane must be signed by. */
+    val streamPublicKeyHex: String,
+    /** CORD-02 §5: the one seal form this plane may use, on both the write and the read side. */
+    val form: SealForm,
+    val chat: ChatBinding?,
+)
+
+/**
+ * A Channel's Chat plane (CORD-03 §1). Public channels pass `community_root` as the secret,
+ * Private ones their own independent `channel_key`; the `channel_id` in the derivation is what
+ * gives each Channel a distinct address either way.
+ */
+fun channelPlaneKey(channelSecret: ByteArray, channelId: ByteArray, epoch: ULong): PlaneKey {
+    val key = groupKey(ConcordLabel.CHANNEL, channelSecret, channelId, epoch)
+    return PlaneKey(
+        read = key,
+        stream = key,
+        streamPublicKeyHex = key.publicKey.toHex(),
+        form = SealForm.Encrypted,
+        chat = ChatBinding(channelId.toHex(), epoch),
+    )
+}
+
+/** The community-wide Guestbook plane (CORD-02 §5), where joins, leaves and kicks are recorded. */
+fun guestbookPlaneKey(communityRoot: ByteArray, communityId: ByteArray, epoch: ULong): PlaneKey {
+    val key = groupKey(ConcordLabel.GUESTBOOK, communityRoot, communityId, epoch)
+    return PlaneKey(
+        read = key,
+        stream = key,
+        streamPublicKeyHex = key.publicKey.toHex(),
+        form = SealForm.Encrypted,
+        chat = null,
+    )
+}
+
+/**
+ * The Control plane's **read** key (CORD-02 §5). Its wraps are signed by the staff-held
+ * `control-signer` key instead, so this plane is read-only and [streamPublicKeyHex] is
+ * whatever the invite claimed — nothing in an invite can prove it, so build nothing
+ * security-relevant on it beyond the subscription address.
+ */
+fun controlPlaneKey(
+    communityRoot: ByteArray,
+    communityId: ByteArray,
+    epoch: ULong,
+    streamPublicKeyHex: String,
+): PlaneKey {
+    val key = groupKey(ConcordLabel.CONTROL, communityRoot, communityId, epoch)
+    return PlaneKey(
+        read = key,
+        stream = null,
+        streamPublicKeyHex = streamPublicKeyHex,
+        form = SealForm.Plaintext,
+        chat = null,
+    )
+}
+
+/**
+ * Builds an unsigned rumor for this plane (CORD-01).
+ *
+ * The `channel`/`epoch` binding tags are stamped from the plane itself, and therefore from the
+ * very key that will encrypt the wrap, so a rumor can never be built whose coordinate does not
+ * match the key it travels under. `ms` rides every rumor (CORD-02 A.5) because `created_at` is
+ * never tweaked — true time is `created_at * 1000 + ms`.
+ *
+ * A rumor is never signed and never a standalone artifact: its authority is the seal's
+ * signature around it.
+ */
+fun PlaneKey.rumor(
+    author: PublicKey,
+    kind: UShort,
+    content: String,
+    createdAt: Instant,
+    extraTags: List<Tag> = emptyList(),
+): UnsignedEvent {
+    val tags = buildList {
+        chat?.let {
+            add(Tag.custom(ConcordTag.CHANNEL, listOf(it.channelIdHex)))
+            add(Tag.custom(ConcordTag.EPOCH, listOf(it.epoch.toString())))
+        }
+        add(Tag.custom(ConcordTag.MS, listOf(msOf(createdAt).toString())))
+        addAll(extraTags)
+    }
+    return EventBuilder(Kind(kind), content)
+        .tags(tags)
+        .customCreatedAt(Timestamp.fromSecs(createdAt.epochSeconds.toULong()))
+        .finalizeUnsigned(author)
+        .ensureId()
+}
+
+/**
+ * Wraps [rumor] into a publishable stream event.
+ *
+ * [signer] signs the *seal*, so it must be the real author's signer — the user's own key, which
+ * also means a NIP-46 bunker works here. The wrap is signed by the plane's stream key instead,
+ * and the seal form comes from the plane itself (CORD-02 §5).
+ *
+ * Both the seal and the wrap take the rumor's `created_at`, never a fresh one, so the three
+ * layers agree and pagination by wrap timestamp lines up with message ordering.
+ */
+suspend fun PlaneKey.wrap(rumor: UnsignedEvent, signer: AsyncNostrSigner): Event {
+    val stream = stream ?: error("Concord: this plane is read-only and cannot wrap")
+    val createdAt = rumor.createdAt()
+
+    val rumorJson = rumor.asJson()
+    val seal = try {
+        EventBuilder(
+            Kind(form.kind),
+            // CORD-01: byte-verbatim for a plaintext seal, so a re-wrap can carry the exact
+            // signed bytes forward instead of re-serializing them.
+            if (form == SealForm.Encrypted) nip44Seal(read, rumorJson) else rumorJson,
+        )
+            .customCreatedAt(createdAt)
+            .finalizeAsync(signer)
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Exception) {
+        throw IllegalStateException("Concord: failed to seal rumor: ${e.message}", e)
+    }
+
+    // The receiver drops a rumor whose author differs from its seal's, so publishing a mismatch
+    // would produce a message nobody can read. Fail here instead, where the cause is visible.
+    check(seal.author() == rumor.author()) {
+        "Concord: seal author ${seal.author().toHex()} does not match rumor author ${rumor.author().toHex()}"
+    }
+
+    return try {
+        // The ephemeral `p` is discarded: it only breaks linkage between a plane's wraps. Only
+        // its pubkey is kept, and `Tag.publicKey` has already serialized it, so destroying the
+        // keypair right away is safe. v1 has no giftwrap deletion, which is the one thing
+        // CORD-01 §Deletions would want the secret for.
+        val ephemeral = Keys.generate().use { Tag.publicKey(it.publicKey()) }
+        Keys(stream.secretKey).use { keys ->
+            EventBuilder(Kind(concordKind(ConcordKind.WRAP)), nip44Seal(read, seal.asJson()))
+                .tags(listOf(ephemeral))
+                .customCreatedAt(createdAt)
+                .finalize(keys)
+        }
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Exception) {
+        throw IllegalStateException("Concord: failed to wrap seal: ${e.message}", e)
+    }
+}
+
+/**
+ * Unwraps a stream event and enforces every check a reader must make, returning null when any
+ * of them fails.
+ *
+ * Null means **drop**, never retry: a wrong key, a forged or unverifiable signature, an
+ * impersonation attempt, a decompression/serialization failure, or a `channel`/`epoch`
+ * mismatch (CORD-03 §3). The checks are all here so a caller cannot skip one, and nothing is
+ * rendered before they pass.
+ */
+fun PlaneKey.unwrap(event: Event): UnsignedEvent? {
+    if (event.kind().asU16() != ConcordKind.WRAP.toUShort()) return null
+    // The wrap is signed by the stream key. Verifying this is what makes CORD-01's
+    // write-restricted split real: a read-key holder can verify a wrap but cannot mint one.
+    if (event.author().toHex() != streamPublicKeyHex) return null
+    if (!event.verify()) return null
+
+    val seal = runCatching {
+        Event.fromJson(nip44Decrypt(read.secretKey, read.publicKey, event.content()))
+    }.getOrNull() ?: return null
+    if (!seal.verify()) return null
+
+    // CORD-02 §5 makes the seal form a fixed property of the plane, so a seal of the other form
+    // is a discipline violation, not a variant to accommodate: only the matching pair is accepted.
+    val sealKind = seal.kind().asU16()
+    val rumorJson = when {
+        sealKind == SealForm.Encrypted.kind && form == SealForm.Encrypted -> runCatching {
+            nip44Decrypt(read.secretKey, read.publicKey, seal.content())
+        }.getOrNull() ?: return null
+        // Plaintext seal: the rumor's bytes are already the content, never re-parsed as an event.
+        sealKind == SealForm.Plaintext.kind && form == SealForm.Plaintext -> seal.content()
+        else -> return null
+    }
+
+    val rumor = runCatching { UnsignedEvent.fromJson(rumorJson).ensureId() }.getOrNull() ?: return null
+    // NIP-59's impersonation check: the seal proves who wrote the rumor inside it.
+    if (rumor.author() != seal.author()) return null
+    if (!bindsToThisPlane(rumor)) return null
+    return rumor
+}
+
+/**
+ * CORD-03 §3, strict-equal and fail-closed: on a Chat plane both tags must be present and match
+ * this plane's coordinate, so neither a re-wrap into another Channel nor a cross-epoch replay
+ * survives. The community-wide Guestbook and Control planes split no sub-context, so the spec
+ * binds nothing there and this is a no-op.
+ */
+private fun PlaneKey.bindsToThisPlane(rumor: UnsignedEvent): Boolean {
+    val expected = chat ?: return true
+    val tags = rumor.tags().toVec()
+    val channel = tags.firstOrNull { it.kind() == ConcordTag.CHANNEL }?.content()
+    val epoch = tags.firstOrNull { it.kind() == ConcordTag.EPOCH }?.content()
+    return channel == expected.channelIdHex && epoch == expected.epoch.toString()
+}
+
+/**
+ * CORD-02 A.5: true time is `created_at * 1000 + ms`, and a reader drops a rumor whose `ms`
+ * falls outside `0..999`. `mod` rather than `%` so a pre-epoch timestamp cannot produce a
+ * negative value.
+ */
+private fun msOf(createdAt: Instant): Int = createdAt.toEpochMilliseconds().mod(1000L).toInt()
+
+/**
+ * NIP-44's plaintext cap, enforced by the publisher (CORD-01 §Encoding).
+ *
+ * Libraries are lenient and a lenient publisher mints events a strict reader cannot decrypt, so
+ * this fails loudly at build time instead of producing an undecryptable message.
+ */
+private const val MAX_PLAINTEXT_BYTES = 65_535
+
+private fun nip44Seal(key: GroupKey, plaintext: String): String {
+    val size = plaintext.encodeToByteArray().size
+    require(size <= MAX_PLAINTEXT_BYTES) {
+        "Concord: NIP-44 plaintext is $size bytes, over the $MAX_PLAINTEXT_BYTES cap"
+    }
+    return nip44Encrypt(key.secretKey, key.publicKey, plaintext, Nip44Version.V2)
+}
+
+/** `Kind` for a frozen [ConcordKind] number; the SDK's constructor wants a `UShort`. */
+private fun concordKind(kind: Int): UShort = kind.toUShort()

shared/src/commonMain/kotlin/su/reya/coop/concord/ConcordStore.kt

@@ -0,0 +1,113 @@
+package su.reya.coop.concord
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import rust.nostr.sdk.EventBuilder
+import rust.nostr.sdk.Filter
+import rust.nostr.sdk.Keys
+import rust.nostr.sdk.Kind
+import rust.nostr.sdk.KindStandard
+import rust.nostr.sdk.Tag
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.AppStorage
+import su.reya.coop.nostr.Nostr
+
+/**
+ * Concord's local persistence, in the two places the rest of the app already keeps things.
+ *
+ * **Secrets → [AppStorage]'s encrypted store.** A Community's keys *are* membership (CORD-02 §2),
+ * so they go through `setSecret`, which is backed by Android Keystore AES-GCM. They must never go
+ * through plaintext storage, and they never touch LMDB.
+ *
+ * **Community state → LMDB, as index events.** Decrypted plane rumors are cached the same way
+ * [su.reya.coop.nostr.MessageManager] caches DM rumors, so history survives a restart and the
+ * Control fold has something to fold before the network answers.
+ */
+class ConcordStore(private val storage: AppStorage, private val nostr: Nostr) {
+
+    suspend fun loadMemberships(): List<Membership> {
+        val raw = try {
+            storage.getSecret(MEMBERSHIPS_KEY)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            println("Concord: could not read memberships: ${e.message}")
+            return emptyList()
+        } ?: return emptyList()
+
+        return try {
+            concordJson.decodeFromString<List<Membership>>(raw)
+        } catch (e: Exception) {
+            println("Concord: stored memberships are unreadable: ${e.message}")
+            emptyList()
+        }
+    }
+
+    suspend fun saveMemberships(memberships: List<Membership>) {
+        try {
+            storage.setSecret(MEMBERSHIPS_KEY, concordJson.encodeToString(memberships))
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            throw IllegalStateException("Concord: could not store memberships: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Caches one decrypted plane rumor under its logical scope — a Channel id for Chat, the
+     * community id for Control and Guestbook.
+     *
+     * The `d` tag is not optional. [KindStandard.APPLICATION_SPECIFIC_DATA] is an *addressable*
+     * kind, so LMDB keeps one event per `(kind, pubkey, d)` coordinate: without a unique `d` every
+     * message would replace the one before it and history would vanish silently. The wrap id is
+     * that unique value, exactly as [su.reya.coop.nostr.MessageManager.setCachedRumor] uses it —
+     * and it doubles as the dedupe key when a wrap arrives from several relays.
+     */
+    suspend fun cacheRumor(scopeIdHex: String, wrapIdHex: String, rumor: UnsignedEvent) {
+        try {
+            val event = EventBuilder(Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA), rumor.asJson())
+                .tags(
+                    listOf(
+                        Tag.identifier(wrapIdHex),
+                        Tag.custom(INDEX_SCOPE_TAG, listOf(scopeIdHex)),
+                        Tag.custom(INDEX_KIND_TAG, listOf(rumor.kind().asU16().toString())),
+                    )
+                )
+                .finalizeAsync(Keys.generate())
+
+            nostr.client?.database()?.saveEvent(event)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            println("Concord: failed to cache rumor: ${e.message}")
+        }
+    }
+
+    /** Every cached rumor for one scope, oldest first. */
+    suspend fun cachedRumors(scopeIdHex: String): List<UnsignedEvent> {
+        val events = try {
+            val filter = Filter()
+                .kind(Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA))
+                .reference(scopeIdHex)
+            nostr.client?.database()?.query(filter)?.toVec() ?: return emptyList()
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            println("Concord: failed to read cached rumors: ${e.message}")
+            return emptyList()
+        }
+
+        return events
+            .mapNotNull { runCatching { UnsignedEvent.fromJson(it.content()).ensureId() }.getOrNull() }
+            .sortedBy { it.createdAt().asSecs() }
+    }
+
+    private companion object {
+        const val MEMBERSHIPS_KEY = "concord_memberships"
+
+        /** Single-letter index tags; `r` is what `Filter.reference` queries. */
+        const val INDEX_SCOPE_TAG = "r"
+        const val INDEX_KIND_TAG = "k"
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/nostr/Messaging.kt

@@ -1,5 +1,6 @@
 package su.reya.coop.nostr
 
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
@@ -38,12 +39,11 @@ class MessageManager(private val nostr: Nostr) {
     private val client: Client? get() = nostr.client
     private val signer: UniversalSigner get() = nostr.signer
 
-    val sentEvents: MutableMap<EventId, List<RelayUrl>> = mutableMapOf()
-    val rumorMap: MutableMap<EventId, EventId> = mutableMapOf()
-
     private val _messageSyncState = MutableStateFlow(MessageSyncState())
     val messageSyncState = _messageSyncState.asStateFlow()
 
+    val rumorMap: MutableMap<EventId, EventId> = mutableMapOf()
+
     fun updateSyncState(update: (MessageSyncState) -> MessageSyncState) {
         _messageSyncState.update(update)
     }
@@ -72,6 +72,8 @@ class MessageManager(private val nostr: Nostr) {
                 target = ReqTarget.manual(target),
                 id = "gift-wraps"
             )
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to fetch user messages: ${e.message}", e)
         }
@@ -119,7 +121,9 @@ class MessageManager(private val nostr: Nostr) {
             setCachedRumor(event.id(), unsignedEvent)
 
             return unsignedEvent
-        } catch (e: Throwable) {
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
             println("Failed to unwrap gift ${event.id().toHex()}: ${e.message}")
             return null
         }
@@ -131,19 +135,24 @@ class MessageManager(private val nostr: Nostr) {
             val event = client?.database()?.query(filter)?.first()
 
             return event?.content()?.let { UnsignedEvent.fromJson(it).ensureId() }
-        } catch (e: Throwable) {
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
             throw IllegalStateException("Failed to get cached rumor: ${e.message}", e)
         }
     }
 
     private suspend fun setCachedRumor(giftId: EventId, rumor: UnsignedEvent) {
         try {
+            val isReaction = rumor.kind().asStd() == KindStandard.REACTION
+            val kValue = if (isReaction) "reaction" else "dm"
+
             // Construct reference tags
             val tags = listOf(
                 Tag.identifier(giftId.toHex()),
                 Tag.publicKey(rumor.author()),
                 Tag.custom("r", listOf(rumor.roomId().toString())),
-                Tag.custom("k", listOf("14"))
+                Tag.custom("k", listOf("14", kValue))
             )
 
             // Set event kind
@@ -155,7 +164,9 @@ class MessageManager(private val nostr: Nostr) {
                 .finalizeAsync(Keys.generate())
 
             client?.database()?.saveEvent(event)
-        } catch (e: Throwable) {
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
             println("Failed to set cached rumor: ${e.message}")
         }
     }
@@ -168,38 +179,61 @@ class MessageManager(private val nostr: Nostr) {
             val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA)
             val kTag = SingleLetterTag.lowercase(Alphabet.K)
 
-            // Get all DM events
-            val filter = Filter().kind(kind).customTags(kTag, listOf("14", "dm"))
-            val events = client?.database()?.query(filter)
+            // Get all rumors (DMs and Reactions)
+            val filter = Filter().kind(kind).customTags(kTag, listOf("14", "dm", "reaction"))
+            val events = client?.database()?.query(filter)?.toVec() ?: return null
 
             // Collect rooms
             val roomsMap: MutableMap<Long, Room> = mutableMapOf()
+            val lastDmTimestampMap: MutableMap<Long, ULong> = mutableMapOf()
 
             events
-                ?.toVec()
-                ?.map { UnsignedEvent.fromJson(it.content()) }
-                ?.filter { it.tags().publicKeys().isNotEmpty() }
-                ?.forEach { event ->
-                    val newRoom = Room.new(rumor = event, userPubkey = userPubkey)
-                    val existingRoom = roomsMap[newRoom.id]
+                .map { UnsignedEvent.fromJson(it.content()) }
+                .filter { it.tags().publicKeys().isNotEmpty() }
+                .forEach { rumor ->
+                    val id = rumor.roomId()
+                    val isFromMe = rumor.author() == userPubkey
+                    val isReaction = rumor.kind().asStd() == KindStandard.REACTION
+                    val existing = roomsMap[id]
+                    val createdAt = rumor.createdAt()
 
-                    // Check if the room already exists
-                    if (existingRoom == null || newRoom.createdAt.asSecs() > existingRoom.createdAt.asSecs()) {
-                        val rTag = SingleLetterTag.lowercase(Alphabet.R)
-                        val filter = Filter().kind(kind).pubkey(userPubkey)
-                            .customTag(rTag, newRoom.id.toString())
+                    if (existing == null) {
+                        val room = Room.new(rumor = rumor, userPubkey = userPubkey, id = id)
+                        // If the first event we see is a reaction, don't use it as lastMessage
+                        roomsMap[id] = if (isReaction) {
+                            room.copy(lastMessage = null)
+                        } else {
+                            lastDmTimestampMap[id] = createdAt.asSecs()
+                            room
+                        }
+                        if (isFromMe) {
+                            roomsMap[id] = roomsMap[id]!!.copy(kind = RoomKind.Ongoing)
+                        }
+                    } else {
+                        // Update the overall room timestamp (for sorting) if this event is newer
+                        if (createdAt.asSecs() > existing.createdAt.asSecs()) {
+                            roomsMap[id] = roomsMap[id]!!.copy(createdAt = createdAt)
+                        }
 
-                        // Determine if it's an ongoing room
-                        val isOngoing =
-                            client?.database()?.query(filter)?.toVec()?.isNotEmpty() ?: false
+                        // Update the last message content if this is a DM and it's newer than the last DM we've seen
+                        if (!isReaction) {
+                            val lastDmTs = lastDmTimestampMap[id] ?: 0uL
+                            if (createdAt.asSecs() >= lastDmTs) {
+                                lastDmTimestampMap[id] = createdAt.asSecs()
+                                roomsMap[id] = roomsMap[id]!!.copy(lastMessage = rumor.content())
+                            }
+                        }
 
-                        // Append room to map
-                        roomsMap[newRoom.id] =
-                            if (isOngoing) newRoom.copy(kind = RoomKind.Ongoing) else newRoom
+                        // If any event is from the user, mark the room as Ongoing
+                        if (isFromMe && roomsMap[id]?.kind != RoomKind.Ongoing) {
+                            roomsMap[id] = roomsMap[id]!!.copy(kind = RoomKind.Ongoing)
+                        }
                     }
                 }
 
             return roomsMap.values.sortedByDescending { it.createdAt.asSecs() }.toSet()
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             println("Failed to get chat rooms: ${e.message}")
             return null
@@ -219,6 +253,8 @@ class MessageManager(private val nostr: Nostr) {
                 // Filter out events without public keys (receivers)
                 ?.filter { it.tags().publicKeys().isNotEmpty() }
                 ?.sortedByDescending { it.createdAt().asSecs() } ?: emptyList()
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to get chat room messages: ${e.message}", e)
         }
@@ -242,6 +278,8 @@ class MessageManager(private val nostr: Nostr) {
                     connectMsgRelays(event)
                 }
             }
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to fetch relays: ${e.message}", e)
         }
@@ -321,9 +359,6 @@ class MessageManager(private val nostr: Nostr) {
                 )
 
                 if (output != null) {
-                    // Keep track of sent events
-                    sentEvents[output.id] = emptyList()
-
                     // Keep track of rumor IDs
                     val id = rumor.id() ?: throw IllegalStateException("Rumor ID is null")
                     rumorMap[id] = output.id
@@ -334,8 +369,70 @@ class MessageManager(private val nostr: Nostr) {
                     }
                 }
             }
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to send message: ${e.message}", e)
         }
     }
+
+    suspend fun sendReaction(
+        to: Set<PublicKey>,
+        targetEventId: EventId,
+        reaction: String,
+        onRumorCreated: ((UnsignedEvent) -> Unit)? = null,
+    ) {
+        try {
+            val currentUser =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            val tags = mutableListOf<Tag>()
+            tags.add(Tag.event(targetEventId))
+            // Add public key tags for each recipient (including me) to ensure roomId consistency
+            to.forEach { pubkey ->
+                tags.add(Tag.publicKey(pubkey))
+            }
+
+            for (receiver in setOf(currentUser) + to) {
+                // Construct the rumor event
+                val rumor = EventBuilder(Kind.fromStd(KindStandard.REACTION), reaction)
+                    .tags(tags)
+                    .finalizeUnsigned(currentUser)
+                    .ensureId()
+
+                // Emit the rumor to the chat screen
+                if (receiver == currentUser) {
+                    onRumorCreated?.invoke(rumor)
+                }
+
+                // Construct the gift wrap event
+                val gift = nip59MakeGiftWrapAsync(
+                    signer = signer,
+                    receiverPubkey = receiver,
+                    rumor = rumor,
+                    extraTags = listOf(
+                        Tag.custom("k", listOf("14"))
+                    )
+                )
+
+                // Send the event to receiver's NIP-17 relays
+                val output = client?.sendEvent(
+                    event = gift,
+                    target = SendEventTarget.toNip17(),
+                    ackPolicy = AckPolicy.none(),
+                    authenticationTimeout = Duration.parse("2s")
+                )
+
+                if (output != null) {
+                    // Keep track of rumor IDs
+                    val id = rumor.id() ?: throw IllegalStateException("Rumor ID is null")
+                    rumorMap[id] = output.id
+                }
+            }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to send reaction: ${e.message}", e)
+        }
+    }
 }

shared/src/commonMain/kotlin/su/reya/coop/nostr/Nostr.kt

@@ -1,7 +1,9 @@
 package su.reya.coop.nostr
 
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -9,6 +11,7 @@ import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.supervisorScope
+import kotlinx.coroutines.withTimeoutOrNull
 import rust.nostr.sdk.AsyncNostrSigner
 import rust.nostr.sdk.Client
 import rust.nostr.sdk.ClientBuilder
@@ -29,25 +32,18 @@ import rust.nostr.sdk.SleepWhenIdle
 import rust.nostr.sdk.Timestamp
 import rust.nostr.sdk.UnsignedEvent
 import rust.nostr.sdk.initLogger
+import su.reya.coop.AppStorage
+import su.reya.coop.concord.ConcordManager
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
 
 object NostrManager {
     val instance = Nostr()
-
-    val BOOTSTRAP_RELAYS = listOf(
-        "wss://relay.primal.net",
-        "wss://relay.ditto.pub",
-        "wss://user.kindpag.es",
-    )
-
-    val INDEXER_RELAY = listOf(
-        "wss://indexer.coracle.social",
-    )
-
-    val ALL_RELAYS = BOOTSTRAP_RELAYS + INDEXER_RELAY
 }
 
-class Nostr {
+class Nostr(
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) {
     var client: Client? = null
         private set
     var signer: UniversalSigner = UniversalSigner(Keys.generate())
@@ -56,23 +52,33 @@ class Nostr {
     val messages = MessageManager(this)
     val profiles = ProfileManager(this)
     val relays = RelayManager(this)
+    val concord = ConcordManager(this)
 
     private val isInitialized = MutableStateFlow(false)
 
-    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
+    private val _newEvents = MutableSharedFlow<UnsignedEvent>(
+        replay = 0,
+        extraBufferCapacity = 100,
+        onBufferOverflow = BufferOverflow.SUSPEND
+    )
     val newEvents = _newEvents.asSharedFlow()
 
-    suspend fun emitNewEvent(event: UnsignedEvent) {
-        _newEvents.emit(event)
+    fun emitNewEvent(event: UnsignedEvent) {
+        _newEvents.tryEmit(event)
     }
 
     suspend fun init(
         dbPath: String,
-        logLevel: LogLevel = LogLevel.WARN
+        storage: AppStorage,
+        logLevel: LogLevel = LogLevel.WARN,
     ) {
         try {
             if (isInitialized.value) return
 
+            // Concord's keys live in the encrypted store, which only the Android layer can build.
+            // Handing it over here keeps it out of the Context-free singleton's constructor.
+            concord.attach(storage)
+
             // Initialize the logger for nostr client
             initLogger(logLevel)
 
@@ -105,21 +111,14 @@ class Nostr {
     }
 
     suspend fun waitUntilInitialized() {
-        isInitialized.first { it }
+        withTimeoutOrNull(30.seconds) { isInitialized.first { it } }
+            ?: throw IllegalStateException("Nostr initialization timed out")
     }
 
     suspend fun connectBootstrapRelays() {
         relays.connectBootstrapRelays()
     }
 
-    suspend fun reconnect() {
-        relays.reconnect()
-    }
-
-    suspend fun disconnect() {
-        relays.disconnect()
-    }
-
     suspend fun prune() {
         try {
             client?.database()?.wipe()
@@ -156,17 +155,39 @@ class Nostr {
         val notifications = client?.notifications() ?: return@supervisorScope
 
         val giftWrapQueue = Channel<Event>(1024)
+        val concordQueue = Channel<Event>(1024)
+
         var processedCount = 0
         var eoseReceived = false
 
-        launch(Dispatchers.Default) {
+        try {
+            concord.restore()
+        } catch (e: Exception) {
+            println("Failed to restore Concord state: ${e.message}")
+        }
+
+        launch(defaultDispatcher) { concord.sync() }
+
+        launch(defaultDispatcher) {
+            for (event in concordQueue) {
+                try {
+                    concord.handlePlaneEvent(event)
+                } catch (e: Exception) {
+                    println("Failed to handle Concord plane event: ${e.message}")
+                }
+            }
+        }
+
+        launch(defaultDispatcher) {
             for (event in giftWrapQueue) {
                 val rumor = messages.extractRumor(event)
                 processedCount++
 
-                // Trigger new message notification
-                if (rumor != null) {
-                    if (rumor.createdAt().asSecs() >= now.asSecs()) {
+                if (rumor != null && !concord.onInboxRumor(rumor)) {
+                    val isSelfMessage = rumor.author() == signer.publicKeyFlow.value
+                    val isNew = rumor.createdAt().asSecs() >= now.asSecs()
+
+                    if (isNew && !isSelfMessage) {
                         onNewMessage(rumor)
                     }
                 }
@@ -186,8 +207,6 @@ class Nostr {
 
             when (notification) {
                 is ClientNotification.Message -> {
-                    val relayUrl = notification.relayUrl
-
                     when (val message = notification.message.asEnum()) {
                         is RelayMessageEnum.EventMsg -> {
                             val event = message.event
@@ -225,7 +244,11 @@ class Nostr {
                                 }
 
                                 KindStandard.GIFT_WRAP -> {
-                                    giftWrapQueue.send(event)
+                                    if (concord.isPlaneAddress(event.author().toHex())) {
+                                        concordQueue.send(event)
+                                    } else {
+                                        giftWrapQueue.send(event)
+                                    }
                                 }
 
                                 else -> {}
@@ -241,14 +264,6 @@ class Nostr {
                             }
                         }
 
-                        is RelayMessageEnum.Ok -> {
-                            if (messages.sentEvents.containsKey(message.eventId)) {
-                                val currentRelays =
-                                    messages.sentEvents[message.eventId] ?: emptyList()
-                                messages.sentEvents[message.eventId] = currentRelays + relayUrl
-                            }
-                        }
-
                         else -> {
                             /* Ignore other message types */
                         }

shared/src/commonMain/kotlin/su/reya/coop/nostr/ProfileManager.kt

@@ -4,6 +4,7 @@ import io.ktor.client.HttpClient
 import io.ktor.client.call.body
 import io.ktor.client.request.get
 import io.ktor.client.statement.HttpResponse
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import rust.nostr.sdk.AckPolicy
@@ -26,17 +27,28 @@ import rust.nostr.sdk.ReqTarget
 import rust.nostr.sdk.SendEventTarget
 import rust.nostr.sdk.SubscribeAutoCloseOptions
 import rust.nostr.sdk.Timestamp
+import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Duration
 
 class ProfileManager(private val nostr: Nostr) {
     private val client: Client? get() = nostr.client
     private val signer: UniversalSigner get() = nostr.signer
+    private val httpClient by lazy { HttpClient() }
 
     private val _metadataUpdates =
-        MutableSharedFlow<Pair<PublicKey, Metadata>>(extraBufferCapacity = 100)
+        MutableSharedFlow<Pair<PublicKey, Metadata>>(
+            replay = 0,
+            extraBufferCapacity = 100,
+            onBufferOverflow = BufferOverflow.SUSPEND
+        )
     val metadataUpdates = _metadataUpdates.asSharedFlow()
 
-    private val _contactListUpdates = MutableSharedFlow<List<PublicKey>>(extraBufferCapacity = 100)
+    private val _contactListUpdates =
+        MutableSharedFlow<List<PublicKey>>(
+            replay = 0,
+            extraBufferCapacity = 100,
+            onBufferOverflow = BufferOverflow.SUSPEND
+        )
     val contactListUpdates = _contactListUpdates.asSharedFlow()
 
     suspend fun emitMetadataUpdate(pubkey: PublicKey, metadata: Metadata) {
@@ -69,6 +81,8 @@ class ProfileManager(private val nostr: Nostr) {
             val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
 
             client?.subscribe(target = target, id = "user-metadata", closeOn = opts)
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to fetch user metadata: ${e.message}", e)
         }
@@ -78,9 +92,11 @@ class ProfileManager(private val nostr: Nostr) {
         try {
             val kind = Kind.fromStd(KindStandard.CONTACT_LIST)
             val filter = Filter().kind(kind).authors(pubkeys).limit(pubkeys.size.toULong())
-            val relays = NostrManager.BOOTSTRAP_RELAYS.map { RelayUrl.parse(it) }
+            val relays = RelayManager.BOOTSTRAP_RELAYS.map { RelayUrl.parse(it) }
 
             client?.sync(filter, relays)
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             println("Failed to sync mutual contacts: ${e.message}")
         }
@@ -138,19 +154,24 @@ class ProfileManager(private val nostr: Nostr) {
         bio: String? = null,
         picture: String? = null
     ): Metadata {
-        val currentUser =
-            signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
-
         try {
-            val record = getLatestMetadata(currentUser)?.asRecord() ?: MetadataRecord()
-            val newRecord = record.copy(
-                displayName = name ?: record.displayName,
-                about = bio ?: record.about,
-                picture = picture ?: record.picture
-            )
-            val newMetadata = Metadata.fromRecord(newRecord)
-            val event = EventBuilder.metadata(newMetadata).finalizeAsync(signer)
+            val currentUser =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
 
+            // Get the latest metadata event
+            val record = getLatestMetadata(currentUser)?.asRecord() ?: MetadataRecord()
+
+            // Build a new metadata based on old records
+            val newMetadata = Metadata.fromRecord(
+                record.copy(
+                    displayName = name ?: record.displayName,
+                    about = bio ?: record.about,
+                    picture = picture ?: record.picture
+                )
+            )
+
+            // Send the new metadata event
+            val event = EventBuilder.metadata(newMetadata).finalizeAsync(signer)
             client?.sendEvent(
                 event = event,
                 target = SendEventTarget.broadcast(),
@@ -158,6 +179,8 @@ class ProfileManager(private val nostr: Nostr) {
             )
 
             return newMetadata
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to update identity: ${e.message}", e)
         }
@@ -170,6 +193,8 @@ class ProfileManager(private val nostr: Nostr) {
             val event = client?.database()?.query(filter)?.first() ?: return null
 
             Metadata.fromJson(event.content())
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             println("Failed to get latest metadata: ${e.message}")
             null
@@ -192,6 +217,8 @@ class ProfileManager(private val nostr: Nostr) {
             }
 
             return results
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             println("Failed to get all cache metadata: ${e.message}")
             return emptyMap()
@@ -211,11 +238,13 @@ class ProfileManager(private val nostr: Nostr) {
 
             // Construct request target
             val target = mutableMapOf<RelayUrl, List<Filter>>()
-            NostrManager.BOOTSTRAP_RELAYS.forEach { relay ->
+            RelayManager.BOOTSTRAP_RELAYS.forEach { relay ->
                 target[RelayUrl.parse(relay)] = listOf(filter)
             }
 
             client?.subscribe(target = ReqTarget.manual(target), closeOn = opts)
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to fetch metadata batch: ${e.message}", e)
         }
@@ -231,6 +260,8 @@ class ProfileManager(private val nostr: Nostr) {
                 target = SendEventTarget.broadcast(),
                 ackPolicy = AckPolicy.none(),
             )
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to set contact list: ${e.message}", e)
         }
@@ -242,6 +273,8 @@ class ProfileManager(private val nostr: Nostr) {
             val bodyString: String = response.body()
 
             return Nip05Profile.fromJson(address, bodyString)
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to fetch profile from address: ${e.message}", e)
         }
@@ -250,9 +283,11 @@ class ProfileManager(private val nostr: Nostr) {
     suspend fun searchByAddress(query: String): PublicKey {
         try {
             val address = Nip05Address.parse(query)
-            val profile = profileFromAddress(HttpClient(), address)
+            val profile = profileFromAddress(httpClient, address)
 
             return profile.publicKey()
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to search address: ${e.message}", e)
         }
@@ -288,6 +323,8 @@ class ProfileManager(private val nostr: Nostr) {
             }
 
             return results
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to search nostr: ${e.message}", e)
         }
@@ -297,7 +334,7 @@ class ProfileManager(private val nostr: Nostr) {
         try {
             val filter = Filter().author(pubkey).limit(3u)
             val target = mutableMapOf<RelayUrl, List<Filter>>()
-            NostrManager.BOOTSTRAP_RELAYS.forEach { relay ->
+            RelayManager.BOOTSTRAP_RELAYS.forEach { relay ->
                 target[RelayUrl.parse(relay)] = listOf(filter)
             }
 
@@ -307,6 +344,8 @@ class ProfileManager(private val nostr: Nostr) {
             )
 
             return events?.first()?.createdAt()
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to get latest activity: ${e.message}", e)
         }
@@ -324,6 +363,8 @@ class ProfileManager(private val nostr: Nostr) {
             val pubkeys = events?.first()?.tags()?.publicKeys() ?: listOf()
 
             return pubkeys.contains(pubkey)
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to get mutual contacts: ${e.message}", e)
         }
@@ -345,6 +386,8 @@ class ProfileManager(private val nostr: Nostr) {
             }
 
             return contacts.toSet()
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             throw IllegalStateException("Failed to get mutual contacts: ${e.message}", e)
         }

shared/src/commonMain/kotlin/su/reya/coop/nostr/RelayManager.kt

@@ -20,14 +20,30 @@ import rust.nostr.sdk.nip17ExtractRelayList
 import kotlin.time.Duration
 
 class RelayManager(private val nostr: Nostr) {
+    companion object {
+        val BOOTSTRAP_RELAYS = listOf(
+            "wss://relay.ditto.pub",
+            "wss://relay.primal.net",
+            "wss://relay.nostr.net",
+            "wss://profiles.nostr1.com",
+        )
+
+        val INDEXER_RELAY = listOf(
+            "wss://indexer.coracle.social",
+            "wss://user.kindpag.es",
+        )
+
+        val ALL_RELAYS = BOOTSTRAP_RELAYS + INDEXER_RELAY
+    }
+
     private val client: Client? get() = nostr.client
     private val signer: UniversalSigner get() = nostr.signer
 
     suspend fun connectBootstrapRelays() {
-        NostrManager.BOOTSTRAP_RELAYS.forEach { url ->
+        BOOTSTRAP_RELAYS.forEach { url ->
             client?.addRelay(RelayUrl.parse(url))
         }
-        NostrManager.INDEXER_RELAY.forEach { url ->
+        INDEXER_RELAY.forEach { url ->
             client?.addRelay(
                 url = RelayUrl.parse(url),
                 capabilities = RelayCapabilities.gossip()
@@ -38,7 +54,7 @@ class RelayManager(private val nostr: Nostr) {
     }
 
     suspend fun reconnect() {
-        NostrManager.ALL_RELAYS.forEach { url ->
+        ALL_RELAYS.forEach { url ->
             try {
                 client?.relay(RelayUrl.parse(url)).let { relay ->
                     if (relay != null) {
@@ -54,7 +70,7 @@ class RelayManager(private val nostr: Nostr) {
     }
 
     suspend fun disconnect() {
-        NostrManager.ALL_RELAYS.forEach { url ->
+        ALL_RELAYS.forEach { url ->
             try {
                 client?.disconnectRelay(RelayUrl.parse(url))
             } catch (e: Exception) {
@@ -104,6 +120,32 @@ class RelayManager(private val nostr: Nostr) {
         return msgRelayList
     }
 
+    suspend fun getRelayList(publicKey: PublicKey): Map<RelayUrl, RelayMetadata?> {
+        try {
+            val kind = Kind.fromStd(KindStandard.RELAY_LIST)
+            val filter = Filter().kind(kind).author(publicKey).limit(1u)
+            val events = client?.database()?.query(filter)
+
+            return extractRelayList(events?.toVec()?.firstOrNull() ?: return emptyMap())
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get relay list: ${e.message}", e)
+        }
+    }
+
+    suspend fun setRelayList(relays: Map<RelayUrl, RelayMetadata?>) {
+        try {
+            val event = EventBuilder.relayList(relays).finalizeAsync(signer)
+
+            client?.sendEvent(
+                event = event,
+                target = SendEventTarget.broadcast(),
+                ackPolicy = AckPolicy.none(),
+            )
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to set msg relays: ${e.message}", e)
+        }
+    }
+
     suspend fun setMsgRelays(urls: List<RelayUrl>) {
         try {
             val event = EventBuilder.nip17RelayList(urls).finalizeAsync(signer)
@@ -154,30 +196,4 @@ class RelayManager(private val nostr: Nostr) {
             throw IllegalStateException("Failed to fetch msg relays: ${e.message}", e)
         }
     }
-
-    suspend fun getRelayList(publicKey: PublicKey): Map<RelayUrl, RelayMetadata?> {
-        try {
-            val kind = Kind.fromStd(KindStandard.RELAY_LIST)
-            val filter = Filter().kind(kind).author(publicKey).limit(1u)
-            val events = client?.database()?.query(filter)
-
-            return extractRelayList(events?.toVec()?.firstOrNull() ?: return emptyMap())
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to get relay list: ${e.message}", e)
-        }
-    }
-
-    suspend fun setRelaylist(relays: Map<RelayUrl, RelayMetadata?>) {
-        try {
-            val event = EventBuilder.relayList(relays).finalizeAsync(signer)
-
-            client?.sendEvent(
-                event = event,
-                target = SendEventTarget.broadcast(),
-                ackPolicy = AckPolicy.none(),
-            )
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to set msg relays: ${e.message}", e)
-        }
-    }
 }

shared/src/commonMain/kotlin/su/reya/coop/nostr/Signer.kt

@@ -29,16 +29,14 @@ class UniversalSigner(initialSigner: AsyncNostrSigner) : AsyncNostrSigner {
     /**
      * Switch to a new signer.
      */
-    suspend fun switch(newSigner: AsyncNostrSigner) = mutex.withLock {
-        val pubkey = try {
-            withTimeoutOrNull(20.seconds) {
-                newSigner.getPublicKeyAsync()
-            }
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to get public key from signer", e)
+    suspend fun switch(newSigner: AsyncNostrSigner) {
+        val pubkey = withTimeoutOrNull(20.seconds) { newSigner.getPublicKeyAsync() }
+            ?: throw IllegalStateException("Failed to get public key from signer")
+
+        mutex.withLock {
+            signer = newSigner
+            _publicKeyFlow.value = pubkey
         }
-        signer = newSigner
-        _publicKeyFlow.value = pubkey
     }
 
     override suspend fun getPublicKeyAsync(): PublicKey? {

shared/src/commonMain/kotlin/su/reya/coop/repository/AccountRepository.kt

@@ -0,0 +1,588 @@
+package su.reya.coop.repository
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import rust.nostr.sdk.AsyncNostrSigner
+import rust.nostr.sdk.EncryptedSecretKey
+import rust.nostr.sdk.Keys
+import rust.nostr.sdk.NostrConnect
+import rust.nostr.sdk.NostrConnectUri
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayMetadata
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.Timestamp
+import su.reya.coop.AppStorage
+import su.reya.coop.Profile
+import su.reya.coop.nostr.ExternalSignerHandler
+import su.reya.coop.nostr.ExternalSignerProxy
+import su.reya.coop.nostr.Nostr
+import su.reya.coop.nostr.SignerPermissions
+import su.reya.coop.viewmodel.ErrorHost
+import su.reya.coop.viewmodel.createErrorHost
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
+
+data class AccountState(
+    val signerRequired: Boolean? = null,
+    val isNotificationBannerDismissed: Boolean = false,
+    val isImporting: Boolean = false,
+    val isRelayListEmpty: Boolean = false,
+    val contactList: Set<PublicKey> = emptySet(),
+    val userRelayList: Map<RelayUrl, RelayMetadata?> = emptyMap(),
+    val userMsgRelayList: List<RelayUrl> = emptyList(),
+)
+
+class AccountRepository(
+    private val nostr: Nostr,
+    private val storage: AppStorage,
+    private val mediaRepository: MediaRepository,
+    private val settingsRepository: SettingsRepository,
+    private val scope: CoroutineScope,
+    private val externalSignerHandler: ExternalSignerHandler? = null,
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : ErrorHost by createErrorHost() {
+    companion object {
+        private const val KEY_USER_SIGNER = "user_signer"
+        private const val KEY_APP_KEYS = "app_keys"
+        private const val KEY_BANNER_DISMISSED = "notification_banner_dismissed"
+    }
+
+    private val _state = MutableStateFlow(AccountState())
+    val state: StateFlow<AccountState> = _state.asStateFlow()
+
+    private val _isUpdatingProfile = MutableStateFlow(false)
+    val isUpdatingProfile: StateFlow<Boolean> = _isUpdatingProfile.asStateFlow()
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val currentUserProfile: StateFlow<Profile?> = nostr.signer.publicKeyFlow
+        .flatMapLatest { if (it != null) currentUserProfileFlow(it) else flowOf(null) }
+        .stateIn(scope, SharingStarted.WhileSubscribed(5000), null)
+
+    init {
+        checkNotificationBannerDismissedStatus()
+        login()
+        observeSignerState()
+        observeContactList()
+    }
+
+    private fun observeSignerState() {
+        scope.launch {
+            nostr.signer.publicKeyFlow
+                .filterNotNull()
+                .distinctUntilChanged()
+                .collectLatest { pubkey ->
+                    // Refresh metadata
+                    nostr.profiles.getUserMetadata()
+
+                    // Verify messaging relays exist (wait up to 10s for initial fetch)
+                    val relays = withTimeoutOrNull(10.seconds) {
+                        var list = nostr.relays.getMsgRelays(pubkey)
+                        while (list.isEmpty()) {
+                            delay(500.milliseconds)
+                            list = nostr.relays.getMsgRelays(pubkey)
+                        }
+                        list
+                    } ?: emptyList()
+
+                    // Automatically update the warning state
+                    _state.update { it.copy(isRelayListEmpty = relays.isEmpty()) }
+                }
+        }
+    }
+
+    private fun checkNotificationBannerDismissedStatus() {
+        scope.launch {
+            val dismissed = storage.get(KEY_BANNER_DISMISSED) == "true"
+            _state.update { it.copy(isNotificationBannerDismissed = dismissed) }
+        }
+    }
+
+    private fun login() {
+        scope.launch {
+            try {
+                val secret = withTimeoutOrNull(5.seconds) {
+                    storage.getSecret(KEY_USER_SIGNER)
+                }
+
+                if (secret == null) {
+                    _state.update { it.copy(signerRequired = true) }
+                    return@launch
+                }
+
+                runCatching {
+                    val (signer, _) = createSigner(secret)
+                    nostr.setSigner(signer)
+                }.onSuccess {
+                    _state.update { it.copy(signerRequired = false) }
+                }.onFailure { e ->
+                    showError("Login failed: ${e.message}")
+                    _state.update { it.copy(signerRequired = true) }
+                }
+            } catch (e: Exception) {
+                showError("Login failed: ${e.message}")
+                _state.update { it.copy(signerRequired = true) }
+            }
+        }
+    }
+
+    fun logout(onLogout: () -> Unit = {}) {
+        scope.launch {
+            try {
+                nostr.signer.switch(Keys.generate())
+                nostr.prune()
+            } catch (e: Exception) {
+                showError("Logout encountered an error: ${e.message}")
+            } finally {
+                storage.clear(KEY_USER_SIGNER)
+                storage.clear(KEY_BANNER_DISMISSED)
+                onLogout()
+                _state.update { it.copy(signerRequired = true) }
+            }
+        }
+    }
+
+    fun dismissNotificationBanner() {
+        scope.launch {
+            storage.set(KEY_BANNER_DISMISSED, "true")
+            _state.update { it.copy(isNotificationBannerDismissed = true) }
+        }
+    }
+
+    private suspend fun getOrInitAppKeys(): Keys = withContext(defaultDispatcher) {
+        val secret = storage.getSecret(KEY_APP_KEYS)
+        if (secret != null) return@withContext Keys.parse(secret)
+        val keys = Keys.generate()
+        storage.setSecret(KEY_APP_KEYS, keys.secretKey().toBech32())
+        keys
+    }
+
+    private suspend fun createSigner(
+        secret: String,
+        password: String? = null
+    ): Pair<AsyncNostrSigner, String?> = withContext(defaultDispatcher) {
+        when {
+            secret.startsWith("nsec1") -> Keys.parse(secret) to null
+
+            secret.startsWith("ncryptsec1") -> {
+                if (password == null) throw IllegalArgumentException("Password is required")
+                val enc = EncryptedSecretKey.fromBech32(secret)
+                val decrypted = enc.decrypt(password)
+                val keys = Keys(decrypted)
+                keys to keys.secretKey().toBech32()
+            }
+
+            secret.startsWith("bunker://") -> {
+                val appKeys = getOrInitAppKeys()
+                val bunker = NostrConnectUri.parse(secret)
+                val timeout = 50.seconds
+                NostrConnect(uri = bunker, appKeys, timeout, null) to null
+            }
+
+            secret.startsWith("nip55://") -> {
+                val handler = externalSignerHandler ?: throw IllegalStateException("Not available")
+                val parts = secret.removePrefix("nip55://").split("/", limit = 2)
+                val packageName = parts[0]
+                val pubkey = PublicKey.parse(parts[1])
+
+                handler.setPackageName(packageName)
+                ExternalSignerProxy(handler, pubkey) to null
+            }
+
+            else -> throw IllegalArgumentException("Invalid secret format")
+        }
+    }
+
+    fun isExternalSignerAvailable(): Boolean {
+        return externalSignerHandler?.isAvailable() == true
+    }
+
+    fun importIdentity(secret: String, password: String? = null) {
+        scope.launch {
+            _state.update { it.copy(isImporting = true) }
+            try {
+                val (signer, decryptedSecret) = createSigner(secret, password)
+
+                nostr.setSigner(signer)
+
+                storage.setSecret(KEY_USER_SIGNER, decryptedSecret ?: secret)
+                _state.update { it.copy(signerRequired = false, isImporting = false) }
+            } catch (e: Exception) {
+                showError("Import failed: ${e.message}")
+                _state.update { it.copy(isImporting = false) }
+            }
+        }
+    }
+
+    fun connectExternalSigner() {
+        scope.launch {
+            _state.update { it.copy(isImporting = true) }
+            try {
+                val handler =
+                    externalSignerHandler ?: throw IllegalStateException("Signer not available")
+
+                val permissions = SignerPermissions.toJson(
+                    listOf(
+                        SignerPermissions.signEvent(0),
+                        SignerPermissions.signEvent(3),
+                        SignerPermissions.signEvent(10000),
+                        SignerPermissions.signEvent(10050),
+                        SignerPermissions.signEvent(10063),
+                        SignerPermissions.signEvent(22242),
+                        SignerPermissions.signEvent(30030),
+                        SignerPermissions.signEvent(30315),
+                        SignerPermissions.nip44Encrypt(),
+                        SignerPermissions.nip44Decrypt(),
+                    )
+                )
+
+                val result = handler.getPublicKey(permissions) ?: throw Exception("Rejected")
+                val signer = ExternalSignerProxy(handler, result.pubkey)
+                val uri = "nip55://${result.packageName}/${result.pubkey.toHex()}"
+
+                nostr.setSigner(signer)
+
+                storage.setSecret(KEY_USER_SIGNER, uri)
+                _state.update { it.copy(signerRequired = false, isImporting = false) }
+            } catch (e: Exception) {
+                showError("External signer connection failed: ${e.message}")
+                _state.update { it.copy(isImporting = false) }
+            }
+        }
+    }
+
+    fun createIdentity(
+        name: String,
+        bio: String?,
+        picture: ByteArray?,
+        contentType: String? = null
+    ) {
+        scope.launch {
+            _state.update { it.copy(isImporting = true) }
+            try {
+                val keys = Keys.generate()
+                val secret = keys.secretKey().toBech32()
+                val avatarUrl = picture?.let {
+                    mediaRepository.blossomUpload(keys, it, contentType ?: "image/jpeg")
+                }
+
+                nostr.profiles.createIdentity(
+                    keys = keys,
+                    name = name,
+                    bio = bio,
+                    picture = avatarUrl
+                )
+
+                storage.setSecret(KEY_USER_SIGNER, secret)
+                _state.update { it.copy(signerRequired = false, isImporting = false) }
+            } catch (e: Exception) {
+                showError("Identity creation failed: ${e.message}")
+                _state.update { it.copy(isImporting = false) }
+            }
+        }
+    }
+
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private fun currentUserProfileFlow(pubkey: PublicKey) = merge(
+        flow {
+            nostr.waitUntilInitialized()
+            val cached = nostr.profiles.getAllCacheMetadata()[pubkey]
+            if (cached != null) emit(Profile(pubkey, cached))
+            nostr.profiles.fetchMetadataBatch(listOf(pubkey))
+        },
+        nostr.profiles.metadataUpdates
+            .filter { (p, _) -> p == pubkey }
+            .map { (p, m) -> Profile(p, m) }
+    )
+
+    fun updateProfile(
+        name: String? = null,
+        bio: String? = null,
+        picture: ByteArray? = null,
+        contentType: String? = null
+    ) {
+        scope.launch {
+            _isUpdatingProfile.value = true
+            try {
+                val avatarUrl = picture?.let {
+                    mediaRepository.blossomUpload(
+                        nostr.signer.get(),
+                        it,
+                        contentType ?: "image/jpeg"
+                    )
+                }
+                nostr.profiles.updateProfile(name, bio, avatarUrl)
+                _isUpdatingProfile.value = false
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+                _isUpdatingProfile.value = false
+            }
+        }
+    }
+
+    private fun observeContactList() {
+        scope.launch {
+            nostr.waitUntilInitialized()
+            nostr.profiles.contactListUpdates.collect { contacts ->
+                _state.update { it.copy(contactList = contacts.toSet()) }
+            }
+        }
+    }
+
+    fun resetInternalState() {
+        _state.update { it.copy(contactList = emptySet(), isRelayListEmpty = false) }
+    }
+
+    fun addContact(address: String) {
+        scope.launch {
+            val pubkey = try {
+                if (address.contains("@")) {
+                    nostr.profiles.searchByAddress(address)
+                } else {
+                    PublicKey.parse(address)
+                }
+            } catch (e: Exception) {
+                showError("Invalid contact address: ${e.message}")
+                return@launch
+            }
+
+            if (pubkey in _state.value.contactList) return@launch
+
+            try {
+                val updated = _state.value.contactList + pubkey
+                nostr.profiles.setContactList(updated.toList())
+                _state.update { it.copy(contactList = it.contactList + pubkey) }
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun removeContact(publicKey: PublicKey) {
+        scope.launch {
+            if (publicKey !in _state.value.contactList) return@launch
+
+            try {
+                val updated = _state.value.contactList - publicKey
+                nostr.profiles.setContactList(updated.toList())
+                _state.update { it.copy(contactList = it.contactList - publicKey) }
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun searchByAddress(query: String, onResult: (PublicKey?) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.searchByAddress(query))
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+                onResult(null)
+            }
+        }
+    }
+
+    fun searchByNostr(query: String, onResult: (List<PublicKey>) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.searchByNostr(query))
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+                onResult(emptyList())
+            }
+        }
+    }
+
+    fun verifyActivity(pubkey: PublicKey, onResult: (Timestamp?) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.verifyActivity(pubkey))
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+                onResult(null)
+            }
+        }
+    }
+
+    fun verifyContact(pubkey: PublicKey, onResult: (Boolean) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.verifyContact(pubkey))
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+                onResult(false)
+            }
+        }
+    }
+
+    fun mutualContacts(pubkey: PublicKey, onResult: (Set<PublicKey>) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.mutualContacts(pubkey))
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+                onResult(emptySet())
+            }
+        }
+    }
+
+    fun dismissRelayWarning() {
+        _state.update { it.copy(isRelayListEmpty = false) }
+    }
+
+    fun refetchMsgRelays() {
+        scope.launch {
+            val currentUser = nostr.signer.getPublicKeyAsync() ?: return@launch
+            val relays = nostr.relays.fetchMsgRelays(currentUser)
+
+            if (relays.isNotEmpty()) dismissRelayWarning()
+        }
+    }
+
+    fun useDefaultMsgRelayList() {
+        scope.launch {
+            try {
+                val defaultRelays = nostr.relays.getDefaultMsgRelayList()
+                nostr.relays.setMsgRelays(defaultRelays)
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun loadCurrentUserRelayList() {
+        scope.launch {
+            try {
+                val user = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
+                val relayList = nostr.relays.getRelayList(user)
+                _state.update { it.copy(userRelayList = relayList) }
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun currentUserRelayListInternal(): Map<RelayUrl, RelayMetadata?> {
+        try {
+            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
+            return nostr.relays.getRelayList(currentUser)
+        } catch (e: Exception) {
+            showError("Error: ${e.message}")
+            return emptyMap()
+        }
+    }
+
+    fun addInboxRelay(relay: String) {
+        scope.launch {
+            try {
+                val relayUrl = RelayUrl.parse(relay)
+                val relays = currentUserRelayListInternal().toMutableMap()
+                relays[relayUrl] = RelayMetadata.WRITE
+
+                nostr.relays.setRelayList(relays)
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun addOutboxRelay(relay: String) {
+        scope.launch {
+            try {
+                val relayUrl = RelayUrl.parse(relay)
+                val relays = currentUserRelayListInternal().toMutableMap()
+                relays[relayUrl] = RelayMetadata.READ
+
+                nostr.relays.setRelayList(relays)
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun removeRelay(relay: String) {
+        scope.launch {
+            try {
+                val relayUrl = RelayUrl.parse(relay)
+                val relays = currentUserRelayListInternal().toMutableMap()
+                relays.remove(relayUrl)
+
+                nostr.relays.setRelayList(relays)
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun loadCurrentUserMsgRelayList() {
+        scope.launch {
+            try {
+                val user = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
+                val msgRelays = nostr.relays.getMsgRelays(user)
+                _state.update { it.copy(userMsgRelayList = msgRelays) }
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun userLatestMsgRelayList(): List<RelayUrl> {
+        try {
+            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
+            return nostr.relays.getMsgRelays(currentUser)
+        } catch (e: Exception) {
+            showError("Error: ${e.message}")
+            return emptyList()
+        }
+    }
+
+    fun addMsgRelay(relay: String) {
+        scope.launch {
+            try {
+                val relayUrl = RelayUrl.parse(relay)
+                val relays = userLatestMsgRelayList().toMutableSet()
+                relays.add(relayUrl)
+
+                nostr.relays.setMsgRelays(relays.toList())
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun removeMsgRelay(relay: String) {
+        scope.launch {
+            try {
+                val relayUrl = RelayUrl.parse(relay)
+                val relays = userLatestMsgRelayList().toMutableSet()
+                relays.remove(relayUrl)
+
+                nostr.relays.setMsgRelays(relays.toList())
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/repository/ChatRepository.kt

@@ -0,0 +1,315 @@
+package su.reya.coop.repository
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import rust.nostr.sdk.EventBuilder
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.Kind
+import rust.nostr.sdk.KindStandard
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.Tag
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.Room
+import su.reya.coop.RoomKind
+import su.reya.coop.nostr.Nostr
+import su.reya.coop.roomId
+import su.reya.coop.viewmodel.ErrorHost
+import su.reya.coop.viewmodel.createErrorHost
+
+data class ChatState(
+    val rooms: Map<Long, Room> = emptyMap(),
+    val isPartialProcessedGiftWrap: Boolean = false,
+)
+
+class ChatRepository(
+    private val nostr: Nostr,
+    private val mediaRepository: MediaRepository,
+    private val settingsRepository: SettingsRepository,
+    private val scope: CoroutineScope,
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : ErrorHost by createErrorHost() {
+    private val _state = MutableStateFlow(ChatState())
+    val state = _state.asStateFlow()
+
+    private val _newEvents = MutableSharedFlow<UnsignedEvent>(
+        replay = 0,
+        extraBufferCapacity = 100,
+        onBufferOverflow = BufferOverflow.SUSPEND
+    )
+    val newEvents = _newEvents.asSharedFlow()
+
+    val chatRooms = state
+        .map { it.rooms.values.sortedByDescending { it.createdAt.asSecs() } }
+        .stateIn(scope, SharingStarted.WhileSubscribed(5000), emptyList())
+
+    val isSyncing = nostr.messages.messageSyncState
+        .map { it.isSyncing }
+        .stateIn(scope, SharingStarted.WhileSubscribed(5000), false)
+
+    val isPartialProcessedGiftWrap = state
+        .map { it.isPartialProcessedGiftWrap }
+        .stateIn(scope, SharingStarted.WhileSubscribed(5000), false)
+
+    init {
+        scope.launch(defaultDispatcher) {
+            nostr.waitUntilInitialized()
+
+            // Observe message sync progress
+            launch {
+                nostr.messages.messageSyncState.collect { syncState ->
+                    // When at least some messages are processed, allow UI to show the list
+                    if (syncState.processedCount > 0 || !syncState.isSyncing) {
+                        _state.update { it.copy(isPartialProcessedGiftWrap = true) }
+                    }
+
+                    // Refresh UI every 100 messages OR when sync is fully done
+                    if (syncState.processedCount % 100 == 0 || !syncState.isSyncing) {
+                        refreshChatRooms()
+                    }
+                }
+            }
+
+            // Observe new messages
+            launch {
+                nostr.newEvents.collect { event ->
+                    updateRoomState(event)
+                }
+            }
+        }
+    }
+
+    fun createChatRoom(to: List<PublicKey>): Long {
+        try {
+            if (to.isEmpty()) {
+                throw IllegalArgumentException("At least one recipient is required")
+            }
+
+            // Get current user
+            val currentUser = nostr.signer.publicKeyFlow.value
+                ?: throw IllegalStateException("User not signed in")
+
+            // Construct the rumor event
+            val rumor = EventBuilder(Kind.fromStd(KindStandard.PRIVATE_DIRECT_MESSAGE), "")
+                .tags(to.map { Tag.publicKey(it) })
+                .finalizeUnsigned(currentUser)
+
+            // Check if the room already exists
+            val id = rumor.roomId()
+            val existingRoom = _state.value.rooms[id]
+
+            // If the room already exists, return its ID
+            if (existingRoom != null) {
+                return existingRoom.id
+            }
+
+            // Create a room from the rumor event
+            val room = Room.new(rumor, currentUser)
+
+            // Update the chat rooms state
+            _state.update { it.copy(rooms = it.rooms + (room.id to room)) }
+
+            return room.id
+        } catch (e: Exception) {
+            throw IllegalArgumentException("Failed to create room: ${e.message}")
+        }
+    }
+
+    fun getChatRoom(id: Long): Room? {
+        return _state.value.rooms[id]
+    }
+
+    fun markAsRead(roomId: Long) {
+        _state.update { currentState ->
+            val rooms = currentState.rooms.toMutableMap()
+            val room = rooms[roomId]
+            if (room != null && room.unreadCount > 0) {
+                rooms[roomId] = room.copy(unreadCount = 0)
+                currentState.copy(rooms = rooms)
+            } else {
+                currentState
+            }
+        }
+    }
+
+    fun refreshChatRooms() {
+        scope.launch(defaultDispatcher) {
+            try {
+                val dbRooms = nostr.messages.getChatRooms() ?: emptySet()
+                _state.update { currentState ->
+                    val newMap = currentState.rooms.toMutableMap()
+                    dbRooms.forEach { dbRoom ->
+                        val existing = newMap[dbRoom.id]
+                        // Only update if the database version is newer or equal
+                        if (existing == null || dbRoom.createdAt.asSecs() >= existing.createdAt.asSecs()) {
+                            // Preserve Ongoing kind and unreadCount status if already marked as such in memory
+                            val mergedKind =
+                                if (existing?.kind == RoomKind.Ongoing) RoomKind.Ongoing else dbRoom.kind
+                            val mergedUnreadCount = existing?.unreadCount ?: 0
+                            newMap[dbRoom.id] = dbRoom.copy(
+                                kind = mergedKind,
+                                unreadCount = mergedUnreadCount
+                            )
+                        }
+                    }
+                    currentState.copy(rooms = newMap)
+                }
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun loadChatRoomMessages(roomId: Long, onResult: (List<UnsignedEvent>) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.messages.getChatRoomMessages(roomId))
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun chatRoomConnect(roomId: Long) {
+        scope.launch(defaultDispatcher) {
+            try {
+                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
+                val members = room.members
+
+                nostr.messages.chatRoomConnect(members.toList())
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun sendMessage(roomId: Long, message: String, replies: List<EventId> = emptyList()) {
+        if (message.isEmpty()) {
+            showError("Message cannot be empty")
+            return
+        }
+        scope.launch(defaultDispatcher) {
+            try {
+                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
+                nostr.messages.sendMessage(
+                    to = room.members,
+                    content = message,
+                    subject = room.subject,
+                    replies = replies,
+                    onRumorCreated = {
+                        scope.launch(defaultDispatcher) {
+                            updateRoomState(it, roomId)
+                        }
+                    },
+                )
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun sendFileMessage(
+        roomId: Long,
+        file: ByteArray?,
+        contentType: String? = "image/jpeg",
+        replies: List<EventId> = emptyList()
+    ) {
+        if (file == null) return
+
+        scope.launch {
+            try {
+                val uri = mediaRepository.blossomUpload(nostr.signer.get(), file, contentType)
+                if (uri != null) sendMessage(roomId, uri, replies)
+            } catch (e: Exception) {
+                showError("File upload failed: ${e.message}")
+            }
+        }
+    }
+
+    fun sendReaction(roomId: Long, targetEventId: EventId, reaction: String) {
+        scope.launch(defaultDispatcher) {
+            try {
+                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
+                nostr.messages.sendReaction(
+                    to = room.members,
+                    targetEventId = targetEventId,
+                    reaction = reaction,
+                    onRumorCreated = {
+                        scope.launch(defaultDispatcher) {
+                            updateRoomState(it, roomId)
+                        }
+                    },
+                )
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun updateRoomState(event: UnsignedEvent, roomId: Long = event.roomId()) {
+        val currentUser = nostr.signer.getPublicKeyAsync() ?: return
+        val isReaction = event.kind().asStd() == KindStandard.REACTION
+
+        _state.update { currentState ->
+            val rooms = currentState.rooms.toMutableMap()
+            val existingRoom = rooms[roomId]
+
+            val isFromMe = event.author() == currentUser
+            val newKind =
+                if (isFromMe) RoomKind.Ongoing else (existingRoom?.kind ?: RoomKind.Request)
+
+            if (existingRoom == null) {
+                // New room discovery
+                val newRoom = Room.new(event, currentUser, roomId).copy(
+                    kind = newKind,
+                    unreadCount = if (isFromMe || isReaction) 0 else 1,
+                    lastMessage = if (isReaction) null else event.content()
+                )
+                rooms[newRoom.id] = newRoom
+            } else if (event.createdAt().asSecs() >= existingRoom.createdAt.asSecs()) {
+                // Update timestamp for any newer event (DM or Reaction)
+                // But only update preview if it's a DM
+                rooms[roomId] = existingRoom.copy(
+                    lastMessage = if (isReaction) existingRoom.lastMessage else event.content(),
+                    createdAt = event.createdAt(),
+                    kind = newKind,
+                    unreadCount = if (isFromMe || isReaction) existingRoom.unreadCount else existingRoom.unreadCount + 1
+                )
+            } else if (isFromMe && existingRoom.kind != RoomKind.Ongoing) {
+                // Even if it's an older message or reaction, if it's from me, the room is ongoing
+                rooms[roomId] = existingRoom.copy(kind = RoomKind.Ongoing)
+            } else {
+                // Don't update the room list state for older messages or reactions that don't change preview
+                return@update currentState
+            }
+            currentState.copy(rooms = rooms)
+        }
+
+        // Notify subscribers about the new event (for the active chat screen)
+        _newEvents.tryEmit(event)
+    }
+
+    fun resetInternalState() {
+        _state.update {
+            it.copy(
+                rooms = emptyMap(),
+                isPartialProcessedGiftWrap = false,
+            )
+        }
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/repository/ErrorRepository.kt

@@ -1,13 +0,0 @@
-package su.reya.coop.repository
-
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.receiveAsFlow
-
-object ErrorRepository {
-    private val _errors = Channel<String>(Channel.BUFFERED)
-    val errors = _errors.receiveAsFlow()
-
-    fun showError(message: String) {
-        _errors.trySend(message)
-    }
-}

shared/src/commonMain/kotlin/su/reya/coop/repository/MediaRepository.kt

@@ -3,11 +3,14 @@ package su.reya.coop.repository
 import io.ktor.client.HttpClient
 import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
 import io.ktor.serialization.kotlinx.json.json
+import kotlinx.coroutines.CancellationException
 import kotlinx.serialization.json.Json
 import rust.nostr.sdk.AsyncNostrSigner
 import su.reya.coop.blossom.BlossomClient
 
-class MediaRepository {
+class MediaRepository(
+    private val settingsRepository: SettingsRepository
+) {
     private val httpClient = HttpClient {
         install(ContentNegotiation) {
             json(Json {
@@ -24,13 +27,12 @@ class MediaRepository {
         contentType: String? = "image/jpeg"
     ): String? {
         return try {
-            val blossom = BlossomClient(url = "https://blossom.band", client = httpClient)
-            val descriptor = blossom.upload(
-                file = file,
-                contentType = contentType,
-                signer = signer,
-            )
+            val url = settingsRepository.settings.value.blossomServer ?: "https://blossom.band"
+            val blossom = BlossomClient(url, httpClient)
+            val descriptor = blossom.upload(file = file, contentType = contentType, signer = signer)
             descriptor?.url
+        } catch (e: CancellationException) {
+            throw e
         } catch (e: Exception) {
             println("Upload failed: ${e.message}")
             null

shared/src/commonMain/kotlin/su/reya/coop/repository/SettingsRepository.kt

@@ -0,0 +1,61 @@
+package su.reya.coop.repository
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import su.reya.coop.AppStorage
+import su.reya.coop.Settings
+
+class SettingsRepository(
+    private val storage: AppStorage,
+    private val scope: CoroutineScope
+) {
+    companion object {
+        private const val KEY_SETTINGS = "app_settings"
+    }
+
+    private val json = Json {
+        ignoreUnknownKeys = true
+        encodeDefaults = true
+    }
+
+    private val _settings = MutableStateFlow(Settings())
+    val settings: StateFlow<Settings> = _settings.asStateFlow()
+
+    init {
+        scope.launch {
+            _settings.value = load()
+        }
+    }
+
+    fun update(transform: (Settings) -> Settings) {
+        scope.launch {
+            val newSettings = transform(_settings.value)
+            _settings.value = newSettings
+            save(newSettings)
+        }
+    }
+
+    private suspend fun save(settings: Settings) {
+        val jsonString = json.encodeToString(settings)
+        storage.set(KEY_SETTINGS, jsonString)
+    }
+
+    private suspend fun load(): Settings {
+        val jsonString = storage.get(KEY_SETTINGS)
+        return if (jsonString != null) {
+            try {
+                json.decodeFromString<Settings>(jsonString)
+            } catch (_: Exception) {
+                Settings()
+            }
+        } else {
+            Settings()
+        }
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/storage/SecretStorage.kt

@@ -1,8 +0,0 @@
-package su.reya.coop.storage
-
-interface SecretStorage {
-    suspend fun get(key: String): String?
-    suspend fun set(key: String, value: String)
-    suspend fun clear(key: String)
-    suspend fun has(key: String): Boolean
-}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/AccountViewModel.kt

@@ -0,0 +1,66 @@
+package su.reya.coop.viewmodel
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.Timestamp
+import su.reya.coop.Profile
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.AccountState
+
+class AccountViewModel(
+    private val repository: AccountRepository,
+) : ViewModel(), ErrorHost by repository {
+    val state: StateFlow<AccountState> = repository.state
+    val isUpdatingProfile: StateFlow<Boolean> = repository.isUpdatingProfile
+    val currentUserProfile: StateFlow<Profile?> = repository.currentUserProfile
+
+    fun logout(onLogout: () -> Unit = {}) = repository.logout(onLogout)
+    fun dismissNotificationBanner() = repository.dismissNotificationBanner()
+    fun isExternalSignerAvailable() = repository.isExternalSignerAvailable()
+    fun importIdentity(secret: String, password: String? = null) =
+        repository.importIdentity(secret, password)
+
+    fun connectExternalSigner() = repository.connectExternalSigner()
+    fun createIdentity(
+        name: String,
+        bio: String?,
+        picture: ByteArray?,
+        contentType: String? = null
+    ) = repository.createIdentity(name, bio, picture, contentType)
+
+    fun updateProfile(
+        name: String? = null,
+        bio: String? = null,
+        picture: ByteArray? = null,
+        contentType: String? = null
+    ) = repository.updateProfile(name, bio, picture, contentType)
+
+    fun resetInternalState() = repository.resetInternalState()
+    fun addContact(address: String) = repository.addContact(address)
+    fun removeContact(publicKey: PublicKey) = repository.removeContact(publicKey)
+    fun searchByAddress(query: String, onResult: (PublicKey?) -> Unit) =
+        repository.searchByAddress(query, onResult)
+
+    fun searchByNostr(query: String, onResult: (List<PublicKey>) -> Unit) =
+        repository.searchByNostr(query, onResult)
+
+    fun verifyActivity(pubkey: PublicKey, onResult: (Timestamp?) -> Unit) =
+        repository.verifyActivity(pubkey, onResult)
+
+    fun verifyContact(pubkey: PublicKey, onResult: (Boolean) -> Unit) =
+        repository.verifyContact(pubkey, onResult)
+
+    fun mutualContacts(pubkey: PublicKey, onResult: (Set<PublicKey>) -> Unit) =
+        repository.mutualContacts(pubkey, onResult)
+
+    fun dismissRelayWarning() = repository.dismissRelayWarning()
+    fun refetchMsgRelays() = repository.refetchMsgRelays()
+    fun useDefaultMsgRelayList() = repository.useDefaultMsgRelayList()
+    fun loadCurrentUserRelayList() = repository.loadCurrentUserRelayList()
+    fun addInboxRelay(relay: String) = repository.addInboxRelay(relay)
+    fun addOutboxRelay(relay: String) = repository.addOutboxRelay(relay)
+    fun loadCurrentUserMsgRelayList() = repository.loadCurrentUserMsgRelayList()
+    fun addMsgRelay(relay: String) = repository.addMsgRelay(relay)
+    fun removeMsgRelay(relay: String) = repository.removeMsgRelay(relay)
+}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/AuthViewModel.kt

@@ -1,225 +0,0 @@
-package su.reya.coop.viewmodel
-
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withTimeoutOrNull
-import rust.nostr.sdk.AsyncNostrSigner
-import rust.nostr.sdk.EncryptedSecretKey
-import rust.nostr.sdk.Keys
-import rust.nostr.sdk.NostrConnect
-import rust.nostr.sdk.NostrConnectUri
-import rust.nostr.sdk.PublicKey
-import su.reya.coop.nostr.ExternalSignerHandler
-import su.reya.coop.nostr.ExternalSignerProxy
-import su.reya.coop.nostr.Nostr
-import su.reya.coop.nostr.SignerPermissions
-import su.reya.coop.repository.MediaRepository
-import su.reya.coop.storage.SecretStorage
-import kotlin.time.Duration.Companion.seconds
-
-data class AuthState(
-    val signerRequired: Boolean? = null,
-    val isNotificationBannerDismissed: Boolean = false,
-)
-
-class AuthViewModel(
-    private val nostr: Nostr,
-    private val secretStore: SecretStorage,
-    private val externalSignerHandler: ExternalSignerHandler? = null,
-) : BaseViewModel() {
-    private val mediaRepository = MediaRepository()
-
-    companion object {
-        private const val KEY_USER_SIGNER = "user_signer"
-        private const val KEY_APP_KEYS = "app_keys"
-        private const val KEY_BANNER_DISMISSED = "notification_banner_dismissed"
-    }
-
-    private val _state = MutableStateFlow(AuthState())
-    val state = _state.asStateFlow()
-
-    init {
-        // Check if the notification banner has been dismissed
-        checkNotificationBannerDismissedStatus()
-
-        // Check local stored secret (secret key or bunker)
-        login()
-    }
-
-    private fun checkNotificationBannerDismissedStatus() {
-        viewModelScope.launch {
-            val dismissed = secretStore.get(KEY_BANNER_DISMISSED) == "true"
-            _state.update { it.copy(isNotificationBannerDismissed = dismissed) }
-        }
-    }
-
-    private fun login() {
-        viewModelScope.launch {
-            try {
-                val secret = withTimeoutOrNull(5.seconds) {
-                    secretStore.get(KEY_USER_SIGNER)
-                }
-
-                if (secret == null) {
-                    _state.update { it.copy(signerRequired = true) }
-                    return@launch
-                }
-
-                runCatching {
-                    val (signer, _) = createSigner(secret)
-                    nostr.setSigner(signer)
-                }.onSuccess {
-                    _state.update { it.copy(signerRequired = false) }
-                }.onFailure { e ->
-                    showError("Login failed: ${e.message}")
-                    _state.update { it.copy(signerRequired = true) }
-                }
-            } catch (e: Exception) {
-                showError("Login failed: ${e.message}")
-                _state.update { it.copy(signerRequired = true) }
-            }
-        }
-    }
-
-    fun logout(onLogout: () -> Unit = {}) {
-        viewModelScope.launch {
-            try {
-                // Reset the nostr signer and prune the database
-                nostr.signer.switch(Keys.generate())
-                nostr.prune()
-            } catch (e: Exception) {
-                showError("Logout encountered an error: ${e.message}")
-            } finally {
-                // Clear credentials from persistent storage
-                secretStore.clear(KEY_USER_SIGNER)
-                secretStore.clear(KEY_BANNER_DISMISSED)
-                // Call cleanup callback (e.g. to reset other ViewModels)
-                onLogout()
-                // Reset local states
-                _state.update { it.copy(signerRequired = true) }
-            }
-        }
-    }
-
-    fun dismissNotificationBanner() {
-        viewModelScope.launch {
-            secretStore.set(KEY_BANNER_DISMISSED, "true")
-            _state.update { it.copy(isNotificationBannerDismissed = true) }
-        }
-    }
-
-    private suspend fun getOrInitAppKeys(): Keys {
-        val secret = secretStore.get(KEY_APP_KEYS)
-        // If app keys are already stored, use them
-        if (secret != null) return Keys.parse(secret)
-        // Generate new app keys and save to the secret storage
-        val keys = Keys.generate()
-        secretStore.set(KEY_APP_KEYS, keys.secretKey().toBech32())
-        return keys
-    }
-
-    private suspend fun createSigner(
-        secret: String,
-        password: String? = null
-    ): Pair<AsyncNostrSigner, String?> {
-        return when {
-            secret.startsWith("nsec1") -> Keys.parse(secret) to null
-
-            secret.startsWith("ncryptsec1") -> {
-                if (password == null) throw IllegalArgumentException("Password is required")
-                val enc = EncryptedSecretKey.fromBech32(secret)
-                val secret = enc.decrypt(password)
-                val keys = Keys(secret)
-
-                keys to keys.secretKey().toBech32()
-            }
-
-            secret.startsWith("bunker://") -> {
-                val appKeys = getOrInitAppKeys()
-                val bunker = NostrConnectUri.parse(secret)
-                val timeout = 50.seconds
-                NostrConnect(uri = bunker, appKeys, timeout, null) to null
-            }
-
-            secret.startsWith("nip55://") -> {
-                val handler = externalSignerHandler
-                    ?: throw IllegalStateException("External signer not available on this platform")
-
-                // Format: nip55://packageName/hexPubkey
-                val parts = secret.removePrefix("nip55://").split("/", limit = 2)
-                val packageName = parts[0]
-                val pubkey = PublicKey.parse(parts[1])
-
-                handler.setPackageName(packageName)
-                ExternalSignerProxy(handler, pubkey) to null
-            }
-
-            else -> throw IllegalArgumentException("Invalid secret format")
-        }
-    }
-
-    suspend fun importIdentity(secret: String, password: String? = null) {
-        val (signer, decryptedSecret) = createSigner(secret, password)
-        // Update signer
-        nostr.setSigner(signer)
-        // Persist the secret in the secret storage
-        secretStore.set(KEY_USER_SIGNER, decryptedSecret ?: secret)
-        // Update local states
-        _state.update { it.copy(signerRequired = false) }
-    }
-
-    suspend fun connectExternalSigner() {
-        val handler = externalSignerHandler ?: throw IllegalStateException("Signer not available")
-
-        val permissions = SignerPermissions.toJson(
-            listOf(
-                SignerPermissions.signEvent(0),
-                SignerPermissions.signEvent(3),
-                SignerPermissions.signEvent(10000),
-                SignerPermissions.signEvent(10050),
-                SignerPermissions.signEvent(10063),
-                SignerPermissions.signEvent(22242),
-                SignerPermissions.signEvent(30030),
-                SignerPermissions.signEvent(30315),
-                SignerPermissions.nip44Encrypt(),
-                SignerPermissions.nip44Decrypt(),
-            )
-        )
-
-        val result = handler.getPublicKey(permissions) ?: throw Exception("Rejected")
-        val signer = ExternalSignerProxy(handler, result.pubkey)
-
-        // Update signer
-        nostr.setSigner(signer)
-        // Store the signer in the secret storage
-        secretStore.set(KEY_USER_SIGNER, "nip55://${result.packageName}/${result.pubkey.toHex()}")
-        // Update local states
-        _state.update { it.copy(signerRequired = false) }
-    }
-
-    fun isExternalSignerAvailable(): Boolean {
-        return externalSignerHandler?.isAvailable() == true
-    }
-
-    suspend fun createIdentity(
-        name: String,
-        bio: String?,
-        picture: ByteArray?,
-        contentType: String? = null
-    ) {
-        val keys = Keys.generate()
-        val secret = keys.secretKey().toBech32()
-        val avatarUrl = picture?.let {
-            mediaRepository.blossomUpload(keys, it, contentType ?: "image/jpeg")
-        }
-        // Create identity
-        nostr.profiles.createIdentity(keys = keys, name = name, bio = bio, picture = avatarUrl)
-        // Persist the secret in the secret storage
-        secretStore.set(KEY_USER_SIGNER, secret)
-        // Update local states
-        _state.update { it.copy(signerRequired = false) }
-    }
-}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/BaseViewModel.kt

@@ -1,10 +0,0 @@
-package su.reya.coop.viewmodel
-
-import androidx.lifecycle.ViewModel
-import su.reya.coop.repository.ErrorRepository
-
-abstract class BaseViewModel : ViewModel() {
-    protected fun showError(message: String) {
-        ErrorRepository.showError(message)
-    }
-}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatScreenViewModel.kt

@@ -0,0 +1,81 @@
+package su.reya.coop.viewmodel
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.Profile
+import su.reya.coop.Room
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.roomId
+
+class ChatScreenViewModel(
+    val id: Long,
+    screening: Boolean,
+    accountRepository: AccountRepository,
+    private val chatRepository: ChatRepository,
+) : ViewModel(), ErrorHost by chatRepository {
+    val currentUser: StateFlow<Profile?> = accountRepository.currentUserProfile
+    val chatRooms: StateFlow<List<Room>> = chatRepository.chatRooms
+
+    var loading by mutableStateOf(true)
+    var newOtherMessages by mutableIntStateOf(0)
+    var requireScreening by mutableStateOf(screening)
+    val messages = mutableStateListOf<UnsignedEvent>()
+
+    init {
+        loadMessages()
+        connect()
+        observeNewEvents()
+    }
+
+    private fun loadMessages() {
+        chatRepository.loadChatRoomMessages(id) { initialMessages ->
+            messages.clear()
+            messages.addAll(initialMessages.distinctBy { it.id() })
+            loading = false
+            // Mark the room as read once messages are loaded
+            chatRepository.markAsRead(id)
+        }
+    }
+
+    private fun connect() {
+        chatRepository.chatRoomConnect(id)
+    }
+
+    private fun observeNewEvents() {
+        viewModelScope.launch {
+            chatRepository.newEvents.collect { event ->
+                if (event.roomId() == id) {
+                    if (messages.none { it.id() == event.id() }) {
+                        messages.add(0, event)
+                        chatRepository.markAsRead(id)
+                    }
+                } else {
+                    newOtherMessages++
+                }
+            }
+        }
+    }
+
+    fun sendMessage(text: String, replyTo: EventId? = null) {
+        val replyToList = if (replyTo != null) listOf(replyTo) else emptyList()
+        chatRepository.sendMessage(id, text, replyToList)
+    }
+
+    fun sendFileMessage(file: ByteArray?, type: String?) {
+        chatRepository.sendFileMessage(id, file, type)
+    }
+
+    fun sendReaction(targetEventId: EventId, reaction: String) {
+        chatRepository.sendReaction(id, targetEventId, reaction)
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatViewModel.kt

@@ -1,260 +1,21 @@
 package su.reya.coop.viewmodel
 
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import rust.nostr.sdk.EventBuilder
-import rust.nostr.sdk.EventId
-import rust.nostr.sdk.Kind
-import rust.nostr.sdk.KindStandard
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
 import rust.nostr.sdk.PublicKey
-import rust.nostr.sdk.RelayUrl
-import rust.nostr.sdk.Tag
-import rust.nostr.sdk.UnsignedEvent
 import su.reya.coop.Room
-import su.reya.coop.nostr.Nostr
-import su.reya.coop.repository.MediaRepository
-import su.reya.coop.roomId
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.ChatState
 
-data class ChatState(
-    val rooms: Set<Room> = emptySet(),
-    val isSyncing: Boolean = false,
-    val isPartialProcessedGiftWrap: Boolean = false,
-)
+class ChatViewModel(
+    private val repository: ChatRepository,
+) : ViewModel(), ErrorHost by repository {
+    val state: StateFlow<ChatState> = repository.state
+    val chatRooms: StateFlow<List<Room>> = repository.chatRooms
+    val isSyncing: StateFlow<Boolean> = repository.isSyncing
+    val isPartialProcessedGiftWrap: StateFlow<Boolean> = repository.isPartialProcessedGiftWrap
 
-class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
-    private val mediaRepository = MediaRepository()
-
-    private val _state = MutableStateFlow(ChatState())
-    val state = combine(
-        _state,
-        nostr.messages.messageSyncState
-    ) { local, state -> local.copy(isSyncing = state.isSyncing) }.stateIn(
-        viewModelScope,
-        SharingStarted.WhileSubscribed(5000),
-        ChatState()
-    )
-
-    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
-    val newEvents = _newEvents.asSharedFlow()
-
-    private val _sentReports = MutableSharedFlow<Map<EventId, List<RelayUrl>>>()
-    val sentReport = _sentReports.asSharedFlow()
-
-    val chatRooms = state.map { it.rooms }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptySet())
-
-    val isSyncing = state.map { it.isSyncing }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
-
-    val isPartialProcessedGiftWrap = state.map { it.isPartialProcessedGiftWrap }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
-
-    init {
-        viewModelScope.launch {
-            nostr.waitUntilInitialized()
-
-            // Observe message sync progress
-            launch {
-                nostr.messages.messageSyncState.collect { syncState ->
-                    // When at least some messages are processed, allow UI to show the list
-                    if (syncState.processedCount > 0 || !syncState.isSyncing) {
-                        _state.update { it.copy(isPartialProcessedGiftWrap = true) }
-                    }
-
-                    // Refresh UI every 10 messages OR when sync is fully done
-                    if (syncState.processedCount % 10 == 0 || !syncState.isSyncing) {
-                        refreshChatRooms()
-                    }
-                }
-            }
-
-            // Observe new messages
-            launch {
-                nostr.newEvents.collect { event ->
-                    val roomId = event.roomId()
-                    val existingRoom = _state.value.rooms.firstOrNull { it.id == roomId }
-
-                    if (existingRoom == null) {
-                        val currentUser = nostr.signer.getPublicKeyAsync() ?: return@collect
-                        val newRoom = Room.new(event, currentUser)
-                        _state.update {
-                            it.copy(
-                                rooms = (it.rooms + newRoom).sortedDescending().toSet()
-                            )
-                        }
-                    } else {
-                        updateRoomList(roomId, event)
-                    }
-
-                    _newEvents.emit(event)
-                }
-            }
-
-            // Initial load of rooms
-            refreshChatRooms()
-        }
-    }
-
-    fun createChatRoom(to: List<PublicKey>): Long {
-        try {
-            if (to.isEmpty()) {
-                throw IllegalArgumentException("At least one recipient is required")
-            }
-
-            // Get current user
-            val currentUser = nostr.signer.publicKeyFlow.value
-                ?: throw IllegalStateException("User not signed in")
-
-            // Construct the rumor event
-            val rumor = EventBuilder(Kind.fromStd(KindStandard.PRIVATE_DIRECT_MESSAGE), "")
-                .tags(to.map { Tag.publicKey(it) })
-                .finalizeUnsigned(currentUser)
-
-            // Check if the room already exists
-            val id = rumor.roomId()
-            val existingRoom = _state.value.rooms.firstOrNull { it.id == id }
-
-            // If the room already exists, return its ID
-            if (existingRoom != null) {
-                return existingRoom.id
-            }
-
-            // Create a room from the rumor event
-            val room = Room.new(rumor, currentUser)
-
-            // Update the chat rooms state
-            _state.update { it.copy(rooms = (it.rooms + room).sortedDescending().toSet()) }
-
-            return room.id
-        } catch (e: Exception) {
-            throw IllegalArgumentException("Failed to create room: ${e.message}")
-        }
-    }
-
-    fun getChatRoom(id: Long): Room? {
-        return _state.value.rooms.firstOrNull { it.id == id }
-    }
-
-    suspend fun refreshChatRooms() {
-        try {
-            val rooms = nostr.messages.getChatRooms() ?: emptySet()
-            _state.update { currentState ->
-                val merged = currentState.rooms.associateBy { it.id }.toMutableMap()
-                // Add or update rooms from the database
-                rooms.forEach { room ->
-                    merged[room.id] = room
-                }
-                // Return as a sorted set to maintain UI consistency
-                currentState.copy(rooms = merged.values.sortedDescending().toSet())
-            }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun getChatRoomMessages(roomId: Long): List<UnsignedEvent> {
-        try {
-            return nostr.messages.getChatRoomMessages(roomId)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-
-        return emptyList()
-    }
-
-    fun chatRoomConnect(roomId: Long) {
-        viewModelScope.launch {
-            try {
-                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
-                val members = room.members
-
-                nostr.messages.chatRoomConnect(members.toList())
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    fun sendMessage(roomId: Long, message: String, replies: List<EventId> = emptyList()) {
-        if (message.isEmpty()) {
-            showError("Message cannot be empty")
-        }
-        viewModelScope.launch {
-            try {
-                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
-                nostr.messages.sendMessage(
-                    to = room.members,
-                    content = message,
-                    subject = room.subject,
-                    replies = replies,
-                    onRumorCreated = { event ->
-                        updateRoomList(roomId, event)
-                        viewModelScope.launch { _newEvents.emit(event) }
-                    },
-                )
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun sendFileMessage(
-        roomId: Long,
-        file: ByteArray?,
-        contentType: String? = "image/jpeg",
-        replies: List<EventId> = emptyList()
-    ) {
-        if (file == null) return
-
-        try {
-            val uri = mediaRepository.blossomUpload(nostr.signer.get(), file, contentType)
-            if (uri != null) sendMessage(roomId, uri, replies)
-        } catch (e: Exception) {
-            throw IllegalArgumentException("Error: ${e.message}")
-        }
-    }
-
-    fun isMessageSent(id: EventId): Boolean {
-        val giftWrapId = nostr.messages.rumorMap[id]
-
-        if (giftWrapId != null) {
-            val isSent = nostr.messages.sentEvents[giftWrapId]?.isNotEmpty() ?: false
-            return isSent
-        } else {
-            return false
-        }
-    }
-
-    private fun updateRoomList(roomId: Long, newMessage: UnsignedEvent) {
-        _state.update { currentState ->
-            val updatedRooms = currentState.rooms.map { room ->
-                if (room.id == roomId) {
-                    room.copy(
-                        lastMessage = newMessage.content(),
-                        createdAt = newMessage.createdAt()
-                    )
-                } else {
-                    room
-                }
-            }.sortedDescending().toSet()
-            currentState.copy(rooms = updatedRooms)
-        }
-    }
-
-    fun resetInternalState() {
-        _state.update {
-            it.copy(
-                rooms = emptySet(),
-                isPartialProcessedGiftWrap = false,
-            )
-        }
-    }
+    fun createChatRoom(to: List<PublicKey>): Long = repository.createChatRoom(to)
+    fun refreshChatRooms() = repository.refreshChatRooms()
+    fun resetInternalState() = repository.resetInternalState()
 }

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ErrorHost.kt

@@ -0,0 +1,28 @@
+package su.reya.coop.viewmodel
+
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+
+interface ErrorHost {
+    val errorEvents: SharedFlow<String>
+
+    fun showError(message: String)
+}
+
+fun createErrorHost(): ErrorHost = ErrorHostImpl()
+
+private class ErrorHostImpl : ErrorHost {
+    private val _errorEvents = MutableSharedFlow<String>(
+        replay = 0,
+        extraBufferCapacity = 10,
+        onBufferOverflow = BufferOverflow.SUSPEND
+    )
+
+    override val errorEvents: SharedFlow<String> = _errorEvents.asSharedFlow()
+
+    override fun showError(message: String) {
+        _errorEvents.tryEmit(message)
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/NostrViewModel.kt

@@ -1,444 +0,0 @@
-package su.reya.coop.viewmodel
-
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.awaitCancellation
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withTimeoutOrNull
-import rust.nostr.sdk.PublicKey
-import rust.nostr.sdk.RelayMetadata
-import rust.nostr.sdk.RelayUrl
-import rust.nostr.sdk.Timestamp
-import su.reya.coop.Profile
-import su.reya.coop.nostr.Nostr
-import su.reya.coop.repository.MediaRepository
-import kotlin.time.Clock
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
-
-data class NostrAppState(
-    val isBusy: Boolean = false,
-    val isRelayListEmpty: Boolean = false,
-)
-
-class NostrViewModel(private val nostr: Nostr) : BaseViewModel() {
-    private val mediaRepository = MediaRepository()
-
-    private val alwaysRunTasks = flow {
-        coroutineScope {
-            val observerJob = launch { runObserver() }
-            val batchingJob = launch { runMetadataBatching() }
-            try {
-                emit(Unit)
-                awaitCancellation()
-            } finally {
-                observerJob.cancel()
-                batchingJob.cancel()
-            }
-        }
-    }
-
-    private val _appState = MutableStateFlow(NostrAppState())
-    val appState: StateFlow<NostrAppState> =
-        combine(_appState, alwaysRunTasks) { state, _ -> state }.stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5000),
-            initialValue = NostrAppState()
-        )
-
-    private val _contactList = MutableStateFlow<Set<PublicKey>>(emptySet())
-    val contactList = _contactList.asStateFlow()
-
-    private val profilesMutex = Mutex()
-    private val profiles = mutableMapOf<PublicKey, MutableStateFlow<Profile?>>()
-    private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
-    private val seenPublicKeys = mutableSetOf<PublicKey>()
-    
-    val isRelayListEmpty = appState.map { it.isRelayListEmpty }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    val currentUserProfile = nostr.signer.publicKeyFlow
-        .flatMapLatest { pubkey ->
-            if (pubkey != null) getMetadata(pubkey) else flowOf(null)
-        }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
-
-    init {
-        // Automatically reconnect bootstrap relays
-        reconnect()
-
-        // Observe the signer state and verify the relay list
-        observeSignerAndCheckRelays()
-
-        // Get all local stored metadata
-        getCacheMetadata()
-    }
-
-    private fun reconnect() {
-        viewModelScope.launch {
-            nostr.waitUntilInitialized()
-            nostr.reconnect()
-        }
-    }
-
-    private suspend fun runObserver() = coroutineScope {
-        // Observe contact list updates
-        launch {
-            nostr.profiles.contactListUpdates.collect { contacts ->
-                _contactList.value = contacts.toSet()
-            }
-        }
-
-        // Observe metadata updates
-        launch {
-            nostr.profiles.metadataUpdates.collect { (pubkey, metadata) ->
-                updateMetadata(pubkey, Profile(pubkey, metadata))
-            }
-        }
-    }
-
-    private suspend fun runMetadataBatching() = coroutineScope {
-        // Wait until the client is ready
-        nostr.waitUntilInitialized()
-
-        val batch = mutableSetOf<PublicKey>()
-        val timeout = 500L // 500ms timeout for batching
-
-        while (true) {
-            // Get the first pubkey
-            val firstKey = metadataRequestChannel.receive()
-            batch.add(firstKey)
-
-            // Get current time
-            val lastFlushTime = Clock.System.now().toEpochMilliseconds()
-
-            while (batch.isNotEmpty()) {
-                // Get the next pubkey
-                val nextKey = withTimeoutOrNull(timeout.milliseconds) {
-                    metadataRequestChannel.receive()
-                }
-
-                // Only add the pubkey if it's not null
-                if (nextKey != null) batch.add(nextKey)
-
-                // Get current time
-                val now = Clock.System.now().toEpochMilliseconds()
-
-                // Check if the batch is full or timeout has passed
-                if (batch.size >= 10 || (now - lastFlushTime) >= timeout || nextKey == null) {
-                    val keysToRequest = batch.toList()
-                    batch.clear()
-
-                    nostr.profiles.fetchMetadataBatch(keysToRequest)
-                }
-            }
-        }
-    }
-
-    private fun getCacheMetadata() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            nostr.profiles.getAllCacheMetadata().forEach { (pubkey, metadata) ->
-                // Update the metadata state
-                updateMetadata(pubkey, Profile(pubkey, metadata))
-                // Update seenPublicKeys to avoid duplicate requests
-                seenPublicKeys.add(pubkey)
-            }
-        }
-    }
-
-    private fun observeSignerAndCheckRelays() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            // Wait until a signer is explicitly set (which updates publicKeyFlow)
-            val currentUser = nostr.signer.publicKeyFlow.filterNotNull().first()
-
-            // Get all metadata for the current user
-            nostr.profiles.getUserMetadata()
-
-            // Small delay to ensure all relays are connected
-            delay(2.seconds)
-
-            // Check if the relay list is empty
-            val relays = nostr.relays.getMsgRelays(currentUser)
-            if (relays.isEmpty()) _appState.update { it.copy(isRelayListEmpty = true) }
-        }
-    }
-
-    private fun requestMetadata(pubkey: PublicKey) {
-        if (seenPublicKeys.add(pubkey)) {
-            viewModelScope.launch {
-                metadataRequestChannel.send(pubkey)
-            }
-        }
-    }
-
-    private fun updateMetadata(pubkey: PublicKey, profile: Profile) {
-        viewModelScope.launch {
-            profilesMutex.withLock {
-                profiles.getOrPut(pubkey) { MutableStateFlow(null) }.value = profile
-            }
-        }
-    }
-
-    fun getMetadata(pubkey: PublicKey): StateFlow<Profile?> {
-        val flow = profiles.getOrPut(pubkey) { MutableStateFlow(null) }
-        if (flow.value == null) requestMetadata(pubkey)
-
-        return flow.asStateFlow()
-    }
-
-    fun resetInternalState() {
-        _contactList.value = emptySet()
-        _appState.update {
-            it.copy(
-                isRelayListEmpty = false,
-            )
-        }
-    }
-
-    fun dismissRelayWarning() {
-        _appState.update { it.copy(isRelayListEmpty = false) }
-    }
-
-    suspend fun updateProfile(
-        name: String? = null,
-        bio: String? = null,
-        picture: ByteArray? = null,
-        contentType: String? = null
-    ) {
-        _appState.update { it.copy(isBusy = true) }
-        try {
-            val avatarUrl =
-                picture?.let {
-                    mediaRepository.blossomUpload(
-                        nostr.signer.get(),
-                        it,
-                        contentType ?: "image/jpeg"
-                    )
-                }
-            val newMetadata = nostr.profiles.updateProfile(name, bio, avatarUrl)
-            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-
-            // Update the metadata state after successfully published
-            updateMetadata(currentUser, Profile(currentUser, newMetadata))
-
-            // Update local state
-            _appState.update { it.copy(isBusy = false) }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun refetchMsgRelays() {
-        val currentUser = nostr.signer.getPublicKeyAsync() ?: return
-        val relays = nostr.relays.fetchMsgRelays(currentUser)
-
-        if (relays.isNotEmpty()) dismissRelayWarning()
-    }
-
-    suspend fun useDefaultMsgRelayList() {
-        try {
-            val defaultRelays = nostr.relays.getDefaultMsgRelayList()
-            nostr.relays.setMsgRelays(defaultRelays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun currentUserRelayList(): Map<RelayUrl, RelayMetadata?> {
-        try {
-            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-            return nostr.relays.getRelayList(currentUser)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyMap()
-        }
-    }
-
-    suspend fun addInboxRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserRelayList().toMutableMap()
-            relays[relayUrl] = RelayMetadata.WRITE
-
-            nostr.relays.setRelaylist(relays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun addOutboxRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserRelayList().toMutableMap()
-            relays[relayUrl] = RelayMetadata.READ
-
-            nostr.relays.setRelaylist(relays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun removeRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserRelayList().toMutableMap()
-            relays.remove(relayUrl)
-
-            nostr.relays.setRelaylist(relays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun currentUserMsgRelayList(): List<RelayUrl> {
-        try {
-            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-            return nostr.relays.getMsgRelays(currentUser)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyList()
-        }
-    }
-
-    suspend fun addMsgRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserMsgRelayList().toMutableSet()
-            relays.add(relayUrl)
-
-            nostr.relays.setMsgRelays(relays.toList())
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun removeMsgRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserMsgRelayList().toMutableSet()
-            relays.remove(relayUrl)
-
-            nostr.relays.setMsgRelays(relays.toList())
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    private suspend fun newContact(publicKey: PublicKey) {
-        if (publicKey in contactList.value) return
-
-        try {
-            val updated = contactList.value + publicKey
-            // Publish new event
-            nostr.profiles.setContactList(updated.toList())
-            // Optimistic local update
-            _contactList.update { it + publicKey }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun addContact(address: String): Boolean {
-        val pubkey = try {
-            if (address.contains("@")) {
-                nostr.profiles.searchByAddress(address)
-            } else {
-                PublicKey.parse(address)
-            }
-        } catch (e: Exception) {
-            showError("Invalid contact address: ${e.message}")
-            return false
-        }
-
-        return run {
-            newContact(pubkey)
-            true
-        }
-    }
-
-    fun removeContact(publicKey: PublicKey) {
-        viewModelScope.launch {
-            if (publicKey !in contactList.value) return@launch
-
-            try {
-                val updated = contactList.value - publicKey
-                // Publish new event
-                nostr.profiles.setContactList(updated.toList())
-                // Optimistic local update
-                _contactList.update { it - publicKey }
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun searchByAddress(query: String): PublicKey? {
-        try {
-            return nostr.profiles.searchByAddress(query)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-        return null
-    }
-
-    suspend fun searchByNostr(query: String): List<PublicKey> {
-        try {
-            return nostr.profiles.searchByNostr(query)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-        return emptyList()
-    }
-
-    suspend fun verifyActivity(pubkey: PublicKey): Timestamp? {
-        return try {
-            nostr.profiles.verifyActivity(pubkey)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            null
-        }
-    }
-
-    suspend fun verifyContact(pubkey: PublicKey): Boolean {
-        return try {
-            nostr.profiles.verifyContact(pubkey)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            false
-        }
-    }
-
-    suspend fun mutualContacts(pubkey: PublicKey): Set<PublicKey> {
-        return try {
-            nostr.profiles.mutualContacts(pubkey)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            setOf()
-        }
-    }
-}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ProfileCache.kt

@@ -0,0 +1,138 @@
+package su.reya.coop.viewmodel
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import rust.nostr.sdk.PublicKey
+import su.reya.coop.Profile
+import su.reya.coop.nostr.Nostr
+import kotlin.time.Duration.Companion.milliseconds
+
+class ProfileCache(
+    private val nostr: Nostr,
+    defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : ErrorHost by createErrorHost() {
+    private val scope = CoroutineScope(SupervisorJob() + defaultDispatcher)
+    private val profiles = MutableStateFlow<Map<PublicKey, MutableStateFlow<Profile?>>>(emptyMap())
+    private val seenPublicKeys = MutableStateFlow<Set<PublicKey>>(emptySet())
+    private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
+
+    init {
+        scope.launch {
+            try {
+                runObserver()
+            } catch (e: Exception) {
+                showError("Metadata observer failed: ${e.message}")
+            }
+        }
+        scope.launch {
+            try {
+                runMetadataBatching()
+            } catch (e: Exception) {
+                showError("Metadata batching failed: ${e.message}")
+            }
+        }
+        scope.launch {
+            try {
+                nostr.waitUntilInitialized()
+                getCachedMetadata()
+            } catch (e: Exception) {
+                showError("Failed to load initial cache: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun runObserver() {
+        nostr.profiles.metadataUpdates.collect { (pubkey, metadata) ->
+            updateMetadata(pubkey, Profile(pubkey, metadata))
+        }
+    }
+
+    private suspend fun runMetadataBatching() {
+        nostr.waitUntilInitialized()
+
+        while (true) {
+            val firstKey = metadataRequestChannel.receive()
+            val batch = mutableSetOf(firstKey)
+
+            while (batch.size < 10) {
+                val nextKey =
+                    withTimeoutOrNull(500.milliseconds) { metadataRequestChannel.receive() }
+                        ?: break
+                batch.add(nextKey)
+            }
+
+            try {
+                nostr.profiles.fetchMetadataBatch(batch.toList())
+            } catch (e: Exception) {
+                // Allow these keys to be requested again since the fetch failed
+                seenPublicKeys.update { it - batch }
+                println("Failed to fetch metadata batch: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun getCachedMetadata() {
+        val cache = nostr.profiles.getAllCacheMetadata()
+        cache.forEach { (pubkey, metadata) ->
+            updateMetadata(pubkey, Profile(pubkey, metadata))
+        }
+    }
+
+    private fun requestMetadata(pubkey: PublicKey) {
+        var added = false
+        seenPublicKeys.update { current ->
+            if (current.contains(pubkey)) {
+                added = false
+                current
+            } else {
+                added = true
+                current + pubkey
+            }
+        }
+        if (added) metadataRequestChannel.trySend(pubkey)
+    }
+
+    private fun updateMetadata(pubkey: PublicKey, profile: Profile) {
+        profiles.update { current ->
+            val flow = current[pubkey] ?: MutableStateFlow<Profile?>(null)
+            flow.value = profile
+            if (current.containsKey(pubkey)) current else current + (pubkey to flow)
+        }
+        seenPublicKeys.update { it + pubkey }
+    }
+
+    fun getMetadata(pubkey: PublicKey): StateFlow<Profile?> {
+        val currentMap = profiles.value
+        val existingFlow = currentMap[pubkey]
+
+        if (existingFlow != null) {
+            if (existingFlow.value == null) requestMetadata(pubkey)
+            return existingFlow.asStateFlow()
+        }
+
+        val newFlow = MutableStateFlow<Profile?>(null)
+        var resultFlow = newFlow
+
+        profiles.update { prev ->
+            if (prev.containsKey(pubkey)) {
+                resultFlow = prev[pubkey]!!
+                prev
+            } else {
+                prev + (pubkey to newFlow)
+            }
+        }
+
+        if (resultFlow.value == null) requestMetadata(pubkey)
+
+        return resultFlow.asStateFlow()
+    }
+}

shared/src/commonMain/kotlin/su/reya/coop/viewmodel/SettingsViewModel.kt

@@ -0,0 +1,16 @@
+package su.reya.coop.viewmodel
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
+import su.reya.coop.Settings
+import su.reya.coop.repository.SettingsRepository
+
+class SettingsViewModel(
+    private val repository: SettingsRepository
+) : ViewModel() {
+    val settings: StateFlow<Settings> = repository.settings
+
+    fun update(transform: (Settings) -> Settings) {
+        repository.update(transform)
+    }
+}