improve the profile cache

Reviewed-on: #44

CHANGELOG.md

@@ -0,0 +1,93 @@
+### [2026-06-20] v0.2.0 (Stable)
+
+**What's Changed:**
+
+* Fixed the issue that cause app crashing
+* Added screener for new message requests
+* Added request messages screen
+* Added contact list screen
+
+---
+
+### [2026-06-12] v0.1.9 (Pre-Release)
+
+**What's Changed:**
+
+* Fixed the issue that cause app crashing
+* Added relay management
+
+---
+
+### [2026-06-09] v0.1.8 (Pre-Release)
+
+**What's Changed:**
+
+* Added support for NIP-55 (use external signer like Amber)
+
+---
+
+### [2026-06-07] v0.1.7 (Pre-Release)
+
+**What's Changed:**
+
+* Added a screen for update profile
+* Fixed occasional splash screen hang
+* Improved the battery usage in background
+
+---
+
+### [2026-06-04] v0.1.6 (Pre-Release)
+
+**What's Changed:**
+
+* Added self chat
+* Fixed empty chat rooms on refreshes
+* Fixed crash on startup
+
+---
+
+### [2026-06-03] v0.1.5 (Pre-Release)
+
+**What's Changed:**
+
+* Added crash report screen
+* Added notification permission banner
+* Fixed navigation issues after create or import identity
+
+---
+
+### [2026-06-01] v0.1.4 (Pre-Release)
+
+**What's Changed:**
+
+* Added the deep link to allow user open chat screen directly via notification
+* Fixed the issue cause app crash if room has no member
+* Improve stability and performance
+
+---
+
+### [2026-05-29] v0.1.3 (Pre-Release)
+
+**What's Changed:**
+
+* Added basic notification when the app in background
+* Redesign the splash screen
+* Redesign the onboarding screen
+* Improved UX for the new identity creation and import screen
+* Fixed some issues cause app crashes
+
+---
+
+### [2026-05-24] v0.1.2 (Pre-Release)
+
+**What's Changed:**
+
+* Fixed the issue that cause app crash when open new chat room via QR
+
+---
+
+### [2026-05-23] v0.1.1 (Pre-Release)
+
+**What's Changed:**
+
+* Fixed the issue that cause app crash on startup

composeApp/build.gradle.kts

@@ -24,9 +24,9 @@ kotlin {
             implementation(libs.jetbrains.navigation3.ui)
             implementation(libs.jetbrains.lifecycle.viewmodelNavigation3)
             implementation(libs.androidx.core.splashscreen)
-            implementation("su.reya:nostr-sdk-kmp:0.2.6")
-            implementation("io.coil-kt.coil3:coil-compose:3.4.0")
-            implementation("io.coil-kt.coil3:coil-network-okhttp:3.4.0")
+            implementation("su.reya:nostr-sdk-kmp:0.3.2")
+            implementation("io.coil-kt.coil3:coil-compose:3.5.0")
+            implementation("io.coil-kt.coil3:coil-network-okhttp:3.5.0")
             implementation("io.github.kalinjul.easyqrscan:scanner:0.7.0")
             implementation("io.github.alexzhirkevich:qrose:1.1.2")
         }
@@ -69,7 +69,7 @@ android {
         minSdk = libs.versions.android.minSdk.get().toInt()
         targetSdk = libs.versions.android.targetSdk.get().toInt()
         versionCode = 1
-        versionName = "0.1.8"
+        versionName = "0.2.4"
     }
     packaging {
         resources {

composeApp/src/androidMain/AndroidManifest.xml

@@ -8,7 +8,7 @@
 
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <queries>
@@ -36,7 +36,8 @@
         <activity
             android:name=".MainActivity"
             android:exported="true"
-            android:theme="@style/Theme.App.Starting">
+            android:theme="@style/Theme.App.Starting"
+            android:windowSoftInputMode="adjustResize">
 
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
@@ -59,7 +60,7 @@
             android:name=".NostrForegroundService"
             android:enabled="true"
             android:exported="false"
-            android:foregroundServiceType="dataSync" />
+            android:foregroundServiceType="remoteMessaging" />
     </application>
 
 </manifest>

composeApp/src/androidMain/composeResources/drawable/ic_add_circle.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,520L680,520L680,440L520,440L520,280L440,280L440,440L280,440L280,520L440,520L440,680ZM480,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_audio.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="M280,720L280,240L360,240L360,720L280,720ZM440,880L440,80L520,80L520,880L440,880ZM120,560L120,400L200,400L200,560L120,560ZM600,720L600,240L680,240L680,720L600,720ZM760,560L760,400L840,400L840,560L760,560Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_block.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="M324,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,880Q397,880 324,848.5ZM480,800Q534,800 584,782.5Q634,765 676,732L228,284Q195,326 177.5,376Q160,426 160,480Q160,614 253,707Q346,800 480,800ZM732,676Q765,634 782.5,584Q800,534 800,480Q800,346 707,253Q614,160 480,160Q426,160 376,177.5Q326,195 284,228L732,676ZM480,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_cancel.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="M336,680L480,536L624,680L680,624L536,480L680,336L624,280L480,424L336,280L280,336L424,480L280,624L336,680ZM480,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_check.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="M382,720L154,492L211,435L382,606L749,239L806,296L382,720Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_check_circle.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="M424,664L706,382L650,326L424,552L310,438L254,494L424,664ZM480,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_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_login.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="M480,840L480,760L760,760Q760,760 760,760Q760,760 760,760L760,200Q760,200 760,200Q760,200 760,200L480,200L480,120L760,120Q793,120 816.5,143.5Q840,167 840,200L840,760Q840,793 816.5,816.5Q793,840 760,840L480,840ZM400,680L345,622L447,520L120,520L120,440L447,440L345,338L400,280L600,480L400,680Z" />
+</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/composeResources/drawable/ic_report.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="M480,680Q497,680 508.5,668.5Q520,657 520,640Q520,623 508.5,611.5Q497,600 480,600Q463,600 451.5,611.5Q440,623 440,640Q440,657 451.5,668.5Q463,680 480,680ZM440,520L520,520L520,280L440,280L440,520ZM330,840L120,630L120,330L330,120L630,120L840,330L840,630L630,840L330,840ZM364,760L596,760L760,596L760,364L596,200L364,200L200,364L200,596L364,760ZM480,480L480,480L480,480L480,480L480,480L480,480L480,480L480,480Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_request.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="M720,560L720,440L600,440L600,360L720,360L720,240L800,240L800,360L920,360L920,440L800,440L800,560L720,560ZM247,433Q200,386 200,320Q200,254 247,207Q294,160 360,160Q426,160 473,207Q520,254 520,320Q520,386 473,433Q426,480 360,480Q294,480 247,433ZM40,800L40,688Q40,654 57.5,625.5Q75,597 104,582Q166,551 230,535.5Q294,520 360,520Q426,520 490,535.5Q554,551 616,582Q645,597 662.5,625.5Q680,654 680,688L680,800L40,800ZM120,720L600,720L600,688Q600,677 594.5,668Q589,659 580,654Q526,627 471,613.5Q416,600 360,600Q304,600 249,613.5Q194,627 140,654Q131,659 125.5,668Q120,677 120,688L120,720ZM416.5,376.5Q440,353 440,320Q440,287 416.5,263.5Q393,240 360,240Q327,240 303.5,263.5Q280,287 280,320Q280,353 303.5,376.5Q327,400 360,400Q393,400 416.5,376.5ZM360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320Q360,320 360,320ZM360,720L360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720Q360,720 360,720L360,720Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_warning.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="M330,840L120,630L120,330L330,120L630,120L840,330L840,630L630,840L330,840ZM366,650L480,536L594,650L650,594L536,480L650,366L594,310L480,424L366,310L310,366L424,480L310,594L366,650ZM364,760L596,760L760,596L760,364L596,200L364,200L200,364L200,596L364,760ZM480,480L480,480L480,480L480,480L480,480L480,480L480,480L480,480Z" />
+</vector>

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

@@ -6,6 +6,8 @@ import android.content.Intent
 import androidx.core.net.toUri
 import rust.nostr.sdk.PublicKey
 import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.nostr.ExternalSignerHandler
+import su.reya.coop.nostr.ExternalSignerResult
 
 class AndroidExternalSigner(
     private val context: Context,
@@ -61,7 +63,7 @@ class AndroidExternalSigner(
     ): String? {
         // Try Content Resolver first
         queryContentResolver(type, payload, pubkey, currentUser)?.let {
-            return it.result
+            return if (resultKey == "event") it.event else it.result
         }
 
         // Fall back to Intent

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

@@ -6,20 +6,11 @@ import android.os.Build
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialExpressiveTheme
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.MotionScheme
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
@@ -28,25 +19,22 @@ import androidx.compose.material3.darkColorScheme
 import androidx.compose.material3.dynamicDarkColorScheme
 import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.material3.expressiveLightColorScheme
-import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 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.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
 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
@@ -55,7 +43,9 @@ import androidx.navigation3.runtime.rememberNavBackStack
 import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
 import androidx.navigation3.ui.NavDisplay
 import kotlinx.coroutines.launch
-import su.reya.coop.screens.ChatScreen
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.screens.ContactListScreen
 import su.reya.coop.screens.HomeScreen
 import su.reya.coop.screens.ImportScreen
 import su.reya.coop.screens.MyQrScreen
@@ -64,11 +54,17 @@ import su.reya.coop.screens.NewIdentityScreen
 import su.reya.coop.screens.OnboardingScreen
 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.UpdateProfileScreen
+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.ProfileCache
 
-val LocalNostrViewModel = staticCompositionLocalOf<NostrViewModel> {
-    error("No NostrViewModel provided")
+val LocalProfileCache = staticCompositionLocalOf<ProfileCache> {
+    error("No ProfileCache provided")
 }
 
 val LocalSnackbarHostState = staticCompositionLocalOf<SnackbarHostState> {
@@ -85,17 +81,43 @@ val LocalScanResult = staticCompositionLocalOf<QrScanResult> {
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
 @Composable
-fun App(viewModel: NostrViewModel) {
+fun App(
+    profileCache: ProfileCache,
+    accountRepository: AccountRepository,
+    chatRepository: ChatRepository,
+) {
+    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
+                    )
+
+                    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 context = LocalContext.current
     val activity = context as? ComponentActivity
-    val scope = rememberCoroutineScope()
-    val sheetState = rememberModalBottomSheetState()
     val backStack = rememberNavBackStack(Screen.Home)
     val navigator = remember(backStack) { Navigator(backStack) }
     val qrScanResult = remember { QrScanResult() }
 
-    val signerRequired by viewModel.signerRequired.collectAsStateWithLifecycle()
-    val isRelayListEmpty by viewModel.isRelayListEmpty.collectAsStateWithLifecycle()
+    // Get the signer required state
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val signerRequired = accountState.signerRequired
 
     // Snackbar
     val snackbarHostState = remember { SnackbarHostState() }
@@ -122,8 +144,20 @@ fun App(viewModel: NostrViewModel) {
     }
 
     LaunchedEffect(Unit) {
-        viewModel.errorEvents.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)
+            }
         }
     }
 
@@ -132,7 +166,7 @@ fun App(viewModel: NostrViewModel) {
             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)
                 }
             }
@@ -165,11 +199,12 @@ fun App(viewModel: NostrViewModel) {
         motionScheme = MotionScheme.expressive(),
     ) {
         CompositionLocalProvider(
-            LocalNostrViewModel provides viewModel,
+            LocalProfileCache provides profileCache,
             LocalSnackbarHostState provides snackbarHostState,
             LocalNavigator provides navigator,
             LocalScanResult provides qrScanResult,
         ) {
+
             NavDisplay(
                 backStack = backStack,
                 onBack = {
@@ -185,95 +220,73 @@ fun App(viewModel: NostrViewModel) {
                 ),
                 entryProvider = entryProvider {
                     entry<Screen.Home> {
-                        HomeScreen()
+                        HomeScreen(accountViewModel, chatViewModel)
+                    }
+                    entry<Screen.RequestList> {
+                        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)
+                        val initialRoom = remember(key.id) { chatRepository.getChatRoom(key.id) }
+                        
+                        if (initialRoom != null) {
+                            val factory = remember(initialRoom) {
+                                object : ViewModelProvider.Factory {
+                                    override fun <T : ViewModel> create(modelClass: Class<T>): T {
+                                        return ChatScreenViewModel(
+                                            initialRoom,
+                                            key.screening,
+                                            accountRepository,
+                                            chatRepository
+                                        ) as T
+                                    }
+                                }
+                            }
+                            ChatScreen(
+                                viewModel<ChatScreenViewModel>(
+                                    key = key.id.toString(),
+                                    factory = factory
+                                ),
+                                accountViewModel
+                            )
+                        } else {
+                            // Handle the rare case where the room isn't in DB (e.g., invalid deep link)
+                            Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                                Text("Room not found")
+                            }
+                        }
                     }
                     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(accountViewModel, chatViewModel)
                     }
                     entry<Screen.Relay> {
-                        RelayScreen()
+                        RelayScreen(accountViewModel)
                     }
                 }
             )
-
-            // Show the relay setup dialog if the msg relay list is empty
-            if (isRelayListEmpty) {
-                ModalBottomSheet(
-                    onDismissRequest = { viewModel.dismissRelayWarning() },
-                    sheetState = sheetState,
-                    containerColor = MaterialTheme.colorScheme.surfaceContainer,
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .fillMaxHeight(0.5f)
-                            .padding(24.dp),
-                        horizontalAlignment = Alignment.CenterHorizontally,
-                    ) {
-                        Text(
-                            text = "Messaging Relays are required",
-                            style = MaterialTheme.typography.headlineSmallEmphasized.copy(
-                                fontWeight = FontWeight.SemiBold,
-                            ),
-                            textAlign = TextAlign.Center,
-                            color = MaterialTheme.colorScheme.primary,
-                        )
-                        Spacer(modifier = Modifier.size(8.dp))
-                        Text(
-                            text = "Coop cannot found your messaging relays. To send and receive messages on Coop, you need to set up at least one messaging relay.",
-                            style = MaterialTheme.typography.bodyLarge
-                        )
-                        Spacer(modifier = Modifier.size(8.dp))
-                        Text(
-                            text = "Please click the button below to continue with the default set of relays. You can always change them later in the settings.",
-                            style = MaterialTheme.typography.bodyLarge.copy(
-                                fontStyle = FontStyle.Italic,
-                            ),
-                        )
-                        Spacer(modifier = Modifier.weight(1f))
-                        Button(
-                            onClick = {
-                                scope.launch {
-                                    viewModel.useDefaultMsgRelayList()
-                                    sheetState.hide()
-                                }
-                            },
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .height(ButtonDefaults.MediumContainerHeight),
-                        ) {
-                            Text(
-                                text = "Continue",
-                                style = MaterialTheme.typography.titleMediumEmphasized,
-                            )
-                        }
-                    }
-                }
-            }
         }
     }
 }

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,23 +4,33 @@ 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()
 
     fun register(launcher: ActivityResultLauncher<Intent>) {
         this.launcher = launcher
     }
 
-    suspend fun launch(intent: Intent): ActivityResult {
-        val deferred = CompletableDeferred<ActivityResult>()
-        pendingResult = deferred
-        launcher?.launch(intent)
-            ?: throw IllegalStateException("ExternalSignerLauncher not registered")
-        return deferred.await()
+    suspend fun launch(intent: Intent): ActivityResult = mutex.withLock {
+        withContext(mainDispatcher) {
+            val deferred = CompletableDeferred<ActivityResult>()
+            pendingResult = deferred
+            launcher?.launch(intent) ?: throw IllegalStateException("Signer not registered")
+            deferred.await()
+        }
     }
 
+
     fun onResult(result: ActivityResult) {
         pendingResult?.complete(result)
         pendingResult = null

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

@@ -8,12 +8,13 @@ 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.ProcessLifecycleOwner
-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.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.MediaRepository
+import su.reya.coop.viewmodel.ProfileCache
 import kotlin.system.exitProcess
 
 class MainActivity : ComponentActivity() {
@@ -21,14 +22,19 @@ class MainActivity : ComponentActivity() {
         val externalSignerLauncher = ExternalSignerLauncher()
     }
 
-    private val viewModel: NostrViewModel by viewModels {
-        object : ViewModelProvider.Factory {
-            override fun <T : ViewModel> create(modelClass: Class<T>): T {
-                val secretStore = SecretStore(this@MainActivity)
-                val androidSigner = AndroidExternalSigner(this@MainActivity, externalSignerLauncher)
-                return NostrViewModel(NostrManager.instance, secretStore, androidSigner) as T
-            }
-        }
+    private val profileCache by lazy { ProfileCache(NostrManager.instance) }
+    private val scope = MainScope()
+
+    private val accountRepository by lazy {
+        val storage = AppStore(this@MainActivity)
+        val mediaRepository = MediaRepository()
+        val androidSigner = AndroidExternalSigner(this@MainActivity, externalSignerLauncher)
+        AccountRepository(NostrManager.instance, storage, mediaRepository, scope, androidSigner)
+    }
+
+    private val chatRepository by lazy {
+        val mediaRepository = MediaRepository()
+        ChatRepository(NostrManager.instance, mediaRepository, scope)
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -68,17 +74,19 @@ class MainActivity : ComponentActivity() {
 
         // Keep the splash screen visible until the signer check is complete
         splashScreen.setKeepOnScreenCondition {
-            viewModel.signerRequired.value == null
+            accountRepository.state.value.signerRequired == null
         }
 
-        // Bind the lifecycle of the ViewModel to the Activity's lifecycle'
-        viewModel.bindLifecycle(ProcessLifecycleOwner.get().lifecycle)
-
         setContent {
-            App(viewModel = viewModel)
+            App(
+                profileCache = profileCache,
+                accountRepository = accountRepository,
+                chatRepository = chatRepository,
+            )
         }
     }
 
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         setIntent(intent)

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

@@ -12,7 +12,7 @@ sealed interface Screen : NavKey {
 
             return when (data.host) {
                 // Matches coop://chat/{id}
-                "chat" -> data.pathSegments.firstOrNull()?.toLongOrNull()?.let { Chat(it) }
+                "chat" -> data.pathSegments.firstOrNull()?.toLongOrNull()?.let { Chat(it, false) }
                 // Matches coop://profile/{pubkey}
                 "profile" -> data.pathSegments.firstOrNull()?.let { Profile(it) }
                 else -> null
@@ -24,11 +24,17 @@ sealed interface Screen : NavKey {
     data object Home : Screen
 
     @Serializable
-    data class Chat(val id: Long) : Screen
+    data object RequestList : Screen
+
+    @Serializable
+    data class Chat(val id: Long, val screening: Boolean = false) : Screen
 
     @Serializable
     data class Profile(val pubkey: String) : Screen
 
+    @Serializable
+    data object ContactList : Screen
+
     @Serializable
     data object UpdateProfile : Screen
 

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

@@ -14,41 +14,47 @@ import androidx.core.app.NotificationCompat
 import androidx.core.net.toUri
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.ProcessLifecycleOwner
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
+import su.reya.coop.nostr.NostrManager
 import java.io.File
 
+private const val GROUP_KEY_MESSAGES = "su.reya.coop.MESSAGES"
+
 class NostrForegroundService : Service() {
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+    var ioDispatcher: CoroutineDispatcher = Dispatchers.IO
     private val nostr by lazy { NostrManager.instance }
     private var notificationJob: Job? = null
 
     override fun onBind(intent: Intent?): IBinder? = null
 
-    private fun isUserInApp(): Boolean {
-        return ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
-    }
-
     override fun onCreate() {
         super.onCreate()
-
         createNotificationChannel()
-        val notification = createNotification()
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            startForeground(1, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
-        } else {
-            startForeground(1, notification)
-        }
+        startAsForeground()
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        if (intent?.action == "STOP_SERVICE") {
+            stopForeground(STOP_FOREGROUND_REMOVE)
+            stopSelf()
+            return START_NOT_STICKY
+        }
+
+        // Start the nostr service in the foreground
+        startAsForeground()
+
+        // Check if the service is already running
         if (notificationJob?.isActive == true) return START_STICKY
 
+        // Start the Nostr client
         notificationJob = serviceScope.launch {
             try {
                 Log.d("Coop", "Starting Nostr in background")
@@ -63,18 +69,17 @@ class NostrForegroundService : Service() {
                 } catch (e: Exception) {
                     throw IllegalStateException("Failed to initialize Nostr Client", e)
                 }
+
                 // Connect to bootstrap relays
                 nostr.connectBootstrapRelays()
+
                 // Handle notifications
                 nostr.handleNotifications(
                     onMetadataUpdate = { pubkey, metadata ->
-                        serviceScope.launch { nostr.emitMetadataUpdate(pubkey, metadata) }
+                        serviceScope.launch { nostr.profiles.emitMetadataUpdate(pubkey, metadata) }
                     },
                     onContactListUpdate = { contacts ->
-                        serviceScope.launch { nostr.emitContactListUpdate(contacts) }
-                    },
-                    onSubscriptionClose = {
-                        serviceScope.launch { nostr.emitSubscriptionClosed() }
+                        serviceScope.launch { nostr.profiles.emitContactListUpdate(contacts) }
                     },
                     onNewMessage = { event ->
                         serviceScope.launch {
@@ -93,6 +98,26 @@ class NostrForegroundService : Service() {
         return START_STICKY
     }
 
+    private fun isUserInApp(): Boolean {
+        return ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
+    }
+
+    private fun startAsForeground() {
+        val notification = createNotification()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            startForeground(1, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_REMOTE_MESSAGING)
+        } else {
+            startForeground(1, notification)
+        }
+    }
+
+    private fun getStopServicePendingIntent(): PendingIntent {
+        val intent = Intent(this, NostrForegroundService::class.java).apply {
+            action = "STOP_SERVICE"
+        }
+        return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_IMMUTABLE)
+    }
+
     private fun createNotificationChannel() {
         val manager = getSystemService(NotificationManager::class.java)
 
@@ -115,10 +140,12 @@ class NostrForegroundService : Service() {
 
     private fun createNotification(content: String? = null): Notification {
         val builder = NotificationCompat.Builder(this, "nostr_service")
+            .setGroup(GROUP_KEY_MESSAGES)
             .setSmallIcon(R.drawable.ic_notification)
             .setOngoing(true)
             .setPriority(NotificationCompat.PRIORITY_MIN)
             .setCategory(Notification.CATEGORY_SERVICE)
+            .addAction(R.drawable.ic_notification, "Stop", getStopServicePendingIntent())
 
         if (content != null) {
             builder.setContentTitle("Coop")

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

@@ -1,398 +0,0 @@
-package su.reya.coop.screens
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-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.shape.RoundedCornerShape
-import androidx.compose.material3.Badge
-import androidx.compose.material3.BadgedBox
-import androidx.compose.material3.FilledTonalIconButton
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.IconButtonDefaults
-import androidx.compose.material3.LoadingIndicator
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
-import androidx.compose.material3.TextFieldDefaults
-import androidx.compose.material3.TopAppBar
-import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
-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.graphics.Color
-import androidx.compose.ui.text.font.FontWeight
-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_send
-import kotlinx.coroutines.flow.first
-import org.jetbrains.compose.resources.painterResource
-import rust.nostr.sdk.UnsignedEvent
-import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
-import su.reya.coop.LocalSnackbarHostState
-import su.reya.coop.Screen
-import su.reya.coop.formatAsGroupHeader
-import su.reya.coop.roomId
-import su.reya.coop.shared.Avatar
-import su.reya.coop.shared.displayNameFlow
-import su.reya.coop.shared.pictureFlow
-import su.reya.coop.short
-
-@Composable
-fun ChatScreen(id: Long) {
-    val snackbarHostState = LocalSnackbarHostState.current
-    val navigator = LocalNavigator.current
-    val viewModel = LocalNostrViewModel.current
-
-    // Get chat room by ID
-    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()
-    val room by remember(id) {
-        derivedStateOf { chatRooms.firstOrNull { it.id == id } }
-    }
-
-    // Show empty screen
-    if (room == null) {
-        Box(
-            modifier = Modifier.fillMaxSize(),
-            contentAlignment = Alignment.Center
-        ) {
-            Text(
-                text = "Chat room not found",
-                style = MaterialTheme.typography.titleMediumEmphasized,
-                color = MaterialTheme.colorScheme.onSurface
-            )
-        }
-        return
-    }
-
-    val displayName by remember(room) { room!!.displayNameFlow(viewModel) }.collectAsState("Loading...")
-    val picture by remember(room) { room!!.pictureFlow(viewModel) }.collectAsState(null)
-
-    var text by remember { mutableStateOf("") }
-    var loading by remember { mutableStateOf(true) }
-    var newOtherMessages by remember { mutableIntStateOf(0) }
-
-    val listState = rememberLazyListState()
-    val messages = remember { mutableStateListOf<UnsignedEvent>() }
-
-    val groupedMessages = remember(messages.toList()) {
-        messages.groupBy { it.createdAt().formatAsGroupHeader() }
-    }
-
-    LaunchedEffect(id) {
-        // Start loading spinner
-        loading = true
-
-        // Get messages
-        val initialMessages = viewModel.getChatRoomMessages(id)
-        messages.clear()
-        messages.addAll(initialMessages)
-
-        // Get msg relays for each member
-        val results = viewModel.chatRoomConnect(id)
-        results.forEach { (member, relays) ->
-            if (relays.isNotEmpty()) {
-                val metadata = viewModel.getMetadata(member).first { it != null }
-                val profile = metadata?.asRecord()
-                val name = profile?.displayName ?: profile?.name ?: member.short()
-
-                snackbarHostState.showSnackbar("Connected to messaging relays for $name")
-            }
-        }
-
-        // Stop loading spinner
-        loading = false
-
-        // Handle new messages
-        viewModel.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()) {
-            listState.animateScrollToItem(0)
-        }
-    }
-
-    Scaffold(
-        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 = picture,
-                                description = displayName,
-                                size = 32.dp,
-                            )
-                        }
-                        Spacer(modifier = Modifier.size(8.dp))
-                        Text(
-                            text = displayName,
-                            style = MaterialTheme.typography.titleMediumEmphasized,
-                        )
-                    }
-                },
-                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(
-                    modifier = Modifier
-                        .fillMaxSize()
-                        .padding(bottom = innerPadding.calculateBottomPadding())
-                ) {
-                    if (messages.isNotEmpty()) {
-                        LazyColumn(
-                            modifier = Modifier
-                                .weight(1f)
-                                .fillMaxWidth(),
-                            contentPadding = PaddingValues(16.dp),
-                            reverseLayout = true,
-                            state = listState,
-                        ) {
-                            groupedMessages.forEach { (dateHeader, messagesInGroup) ->
-                                items(
-                                    messagesInGroup,
-                                    key = { it.id()?.toBech32()!! }) { event ->
-                                    ChatMessage(event)
-                                }
-                                item {
-                                    DateSeparator(dateHeader)
-                                }
-                            }
-                        }
-                    } else {
-                        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
-                                )
-                            }
-                        }
-                    }
-                    ChatInput(
-                        value = text,
-                        onValueChange = { text = it },
-                        onSend = {
-                            viewModel.sendMessage(id, text)
-                            text = ""
-                        }
-                    )
-                }
-            }
-        }
-    )
-}
-
-@Composable
-fun DateSeparator(date: String) {
-    Box(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 16.dp),
-        contentAlignment = Alignment.Center
-    ) {
-        Text(
-            text = date,
-            style = MaterialTheme.typography.labelMedium,
-            color = MaterialTheme.colorScheme.outline
-        )
-    }
-}
-
-@Composable
-fun ChatMessage(
-    rumor: UnsignedEvent
-) {
-    val viewModel = LocalNostrViewModel.current
-    val currentUser = viewModel.currentUser()
-    val isMine = rumor.author() == currentUser
-
-    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)
-    }
-
-    val containerColor =
-        if (isMine) MaterialTheme.colorScheme.primaryContainer else MaterialTheme.colorScheme.tertiaryContainer
-
-    val contentColor =
-        if (isMine) MaterialTheme.colorScheme.onPrimaryContainer else MaterialTheme.colorScheme.onTertiaryContainer
-
-    Box(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 4.dp),
-        contentAlignment = if (isMine) Alignment.CenterEnd else Alignment.CenterStart
-    ) {
-        Column(
-            horizontalAlignment = if (isMine) Alignment.End else Alignment.Start
-        ) {
-            Surface(
-                color = containerColor,
-                contentColor = contentColor,
-                shape = bubbleShape,
-                modifier = Modifier
-                    .widthIn(max = 280.dp)
-                    .clickable(
-                        onClick = {
-                            val id = rumor.id()
-                            if (id != null) {
-                                val sent = viewModel.isMessageSent(id)
-                                println("Sent: $sent")
-                            }
-                        }
-                    )
-            ) {
-                Text(
-                    text = rumor.content(),
-                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
-                    style = MaterialTheme.typography.bodyMedium
-                )
-            }
-        }
-    }
-}
-
-@Composable
-fun ChatInput(
-    value: String,
-    onValueChange: (String) -> Unit,
-    onSend: () -> Unit
-) {
-
-    Surface(modifier = Modifier.fillMaxWidth()) {
-        Row(
-            modifier = Modifier
-                .padding(horizontal = 16.dp, vertical = 8.dp)
-                .height(IntrinsicSize.Min),
-            verticalAlignment = Alignment.Bottom
-        ) {
-            TextField(
-                value = value,
-                onValueChange = onValueChange,
-                placeholder = { Text("Message") },
-                shape = RoundedCornerShape(28.dp),
-                colors = TextFieldDefaults.colors(
-                    focusedIndicatorColor = Color.Transparent,
-                    unfocusedIndicatorColor = Color.Transparent
-                ),
-                modifier = Modifier.weight(1f)
-            )
-            Spacer(modifier = Modifier.size(8.dp))
-            FilledTonalIconButton(
-                onClick = onSend,
-                modifier = Modifier
-                    .fillMaxHeight()
-                    .aspectRatio(1f),
-                colors = IconButtonDefaults.filledTonalIconButtonColors(
-                    containerColor = MaterialTheme.colorScheme.surfaceVariant,
-                    contentColor = MaterialTheme.colorScheme.onSurfaceVariant
-                )
-            ) {
-                Icon(
-                    painter = painterResource(Res.drawable.ic_send),
-                    contentDescription = "Send"
-                )
-            }
-        }
-    }
-}

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

@@ -0,0 +1,365 @@
+package su.reya.coop.screens
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.ExtendedFloatingActionButton
+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.PlainTooltip
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SegmentedListItem
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TooltipAnchorPosition
+import androidx.compose.material3.TooltipBox
+import androidx.compose.material3.TooltipDefaults
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberTooltipState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+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.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.text.font.FontWeight
+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
+import coop.composeapp.generated.resources.ic_close
+import coop.composeapp.generated.resources.ic_plus
+import coop.composeapp.generated.resources.ic_scanner
+import org.jetbrains.compose.resources.painterResource
+import rust.nostr.sdk.Nip05Address
+import rust.nostr.sdk.PublicKey
+import su.reya.coop.LocalNavigator
+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(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
+    val navigator = LocalNavigator.current
+    val snackbarHostState = LocalSnackbarHostState.current
+    val contactList by accountViewModel.contactList.collectAsStateWithLifecycle()
+    var openAddContactDialog by remember { mutableStateOf(false) }
+    var contactToDelete by remember { mutableStateOf<PublicKey?>(null) }
+
+    Scaffold(
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        text = "My Contacts",
+                        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"
+                        )
+                    }
+                },
+                actions = {
+                    IconButton(onClick = { navigator.navigate(Screen.Scan) }) {
+                        Icon(
+                            painter = painterResource(Res.drawable.ic_scanner),
+                            contentDescription = "Scanner"
+                        )
+                    }
+                }
+            )
+        },
+        floatingActionButton = {
+            TooltipBox(
+                positionProvider = TooltipDefaults.rememberTooltipPositionProvider(
+                    TooltipAnchorPosition.Above,
+                    spacingBetweenTooltipAndAnchor = 8.dp,
+                ),
+                tooltip = {
+                    PlainTooltip { Text("New Contact") }
+                },
+                state = rememberTooltipState(),
+            ) {
+                ExtendedFloatingActionButton(
+                    onClick = { openAddContactDialog = true },
+                    expanded = false,
+                    icon = {
+                        Icon(
+                            painter = painterResource(Res.drawable.ic_plus),
+                            contentDescription = "New Contact"
+                        )
+                    },
+                    text = { Text("New Contact") },
+                )
+            }
+        },
+        content = { innerPadding ->
+            if (contactList.isNotEmpty()) {
+                val contacts = remember(contactList) { contactList.toList() }
+
+                LazyColumn(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(top = innerPadding.calculateTopPadding()),
+                    contentPadding = PaddingValues(16.dp),
+                    verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+                ) {
+                    itemsIndexed(contacts) { index, pubkey ->
+                        ContactListItem(
+                            pubkey = pubkey,
+                            index = index,
+                            total = contacts.size,
+                            onClick = {
+                                val room = chatViewModel.createChatRoom(listOf(pubkey))
+                                navigator.navigate(Screen.Chat(room))
+                            },
+                            onLongClick = {
+                                contactToDelete = pubkey
+                            }
+                        )
+                    }
+                }
+            } else {
+                Box(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(innerPadding),
+                    contentAlignment = Alignment.Center
+                ) {
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        Text(
+                            text = "No contacts yet",
+                            style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                                fontWeight = FontWeight.SemiBold
+                            ),
+                            color = MaterialTheme.colorScheme.onSurface
+                        )
+                        Text(
+                            text = "Your contacts will appear here",
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.outline
+                        )
+                    }
+                }
+            }
+        }
+    )
+
+    if (openAddContactDialog) {
+        AddContactDialog(
+            accountViewModel = accountViewModel,
+            onDismissRequest = { openAddContactDialog = false }
+        )
+    }
+
+    if (contactToDelete != null) {
+        AlertDialog(
+            onDismissRequest = { contactToDelete = null },
+            title = { Text("Delete Contact") },
+            text = { Text("Are you sure you want to remove this contact?") },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        contactToDelete?.let { accountViewModel.removeContact(it) }
+                        contactToDelete = null
+                    }
+                ) {
+                    Text("Delete")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { contactToDelete = null }) {
+                    Text("Cancel")
+                }
+            }
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun AddContactDialog(
+    accountViewModel: AccountViewModel,
+    onDismissRequest: () -> Unit,
+) {
+    val snackbarHostState = LocalSnackbarHostState.current
+    val focusRequester = remember { FocusRequester() }
+    var contact by remember { mutableStateOf("") }
+    var isError by remember { mutableStateOf(false) }
+
+    LaunchedEffect(Unit) {
+        focusRequester.requestFocus()
+    }
+
+    Dialog(
+        onDismissRequest = { onDismissRequest() },
+        properties = DialogProperties(
+            usePlatformDefaultWidth = false,
+            dismissOnBackPress = true,
+            decorFitsSystemWindows = false,
+        ),
+    ) {
+        Scaffold(
+            modifier = Modifier.fillMaxSize(),
+            snackbarHost = { SnackbarHost(snackbarHostState) },
+            containerColor = MaterialTheme.colorScheme.surface,
+            topBar = {
+                TopAppBar(
+                    colors = TopAppBarDefaults.topAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                    ),
+                    title = {
+                        Text(
+                            text = "New Contact",
+                            style = MaterialTheme.typography.titleMediumEmphasized
+                        )
+                    },
+                    navigationIcon = {
+                        IconButton(onClick = { onDismissRequest() }) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_close),
+                                contentDescription = "Close"
+                            )
+                        }
+                    },
+                    actions = {
+                        IconButton(onClick = {
+                            accountViewModel.addContact(contact)
+                            onDismissRequest()
+                        }) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_check),
+                                contentDescription = "Add"
+                            )
+                        }
+                    },
+                )
+            },
+            content = { innerPadding ->
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(innerPadding)
+                        .padding(16.dp),
+                    verticalArrangement = Arrangement.spacedBy(16.dp),
+                ) {
+                    OutlinedTextField(
+                        value = contact,
+                        onValueChange = { contact = it },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .focusRequester(focusRequester),
+                        isError = isError,
+                        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+                        keyboardActions = KeyboardActions(
+                            onDone = {
+                                isError = contact.isNotEmpty() && !verifyContact(contact)
+                            }
+                        ),
+                        singleLine = true,
+                        label = { Text(text = "Contact Address") },
+                        placeholder = { Text(text = "npub1... or user@example.com") },
+                        supportingText = {
+                            if (isError) {
+                                Text(text = "Contact address is invalid")
+                            } else {
+                                Text(text = "Only add contact you trust.")
+                            }
+                        },
+                    )
+                }
+            }
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun ContactListItem(
+    pubkey: PublicKey,
+    index: Int,
+    total: Int = 0,
+    onClick: () -> Unit,
+    onLongClick: () -> Unit,
+) {
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsStateWithLifecycle(initialValue = null)
+
+    SegmentedListItem(
+        onClick = onClick,
+        onLongClick = onLongClick,
+        shapes = ListItemDefaults.segmentedShapes(
+            index = index,
+            count = total
+        ),
+        leadingContent = {
+            Avatar(
+                picture = profile?.picture,
+                description = profile?.name,
+                size = 36.dp
+            )
+        },
+        supportingContent = { Text(pubkey.short()) },
+        content = {
+            Text(
+                text = profile?.name ?: "No name",
+                style = MaterialTheme.typography.titleMedium,
+            )
+        }
+    )
+}
+
+fun verifyContact(address: String): Boolean {
+    return try {
+        if (address.contains("@")) Nip05Address.parse(address)
+        else PublicKey.parse(address)
+        true
+    } catch (e: Exception) {
+        println("Failed to parse contact: ${e.message}")
+        false
+    }
+}

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

@@ -13,9 +13,10 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -59,7 +60,6 @@ import androidx.compose.material3.rememberTooltipState
 import androidx.compose.material3.toShape
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -72,56 +72,69 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.ClipEntry
 import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.core.app.NotificationManagerCompat
 import androidx.lifecycle.compose.LifecycleResumeEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
+import coop.composeapp.generated.resources.ic_close
 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.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
 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.flow
 import su.reya.coop.shared.Avatar
-import su.reya.coop.shared.displayNameFlow
-import su.reya.coop.shared.pictureFlow
-import su.reya.coop.short
+import su.reya.coop.shared.getExpressiveFontFamily
+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 viewModel = LocalNostrViewModel.current
-
-    val currentUser = viewModel.currentUser() ?: return
-    val currentUserProfile = viewModel.getMetadata(currentUser) ?: return
-
-    val userProfile by currentUserProfile.collectAsStateWithLifecycle()
-    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()
-    val isPartialProcessedGiftWrap by viewModel.isPartialProcessedGiftWrap.collectAsState(initial = false)
-    val isBannerDismissed by viewModel.isNotificationBannerDismissed.collectAsState()
 
     val scope = rememberCoroutineScope()
-    val sheetState = rememberModalBottomSheetState()
+    val sheetState = rememberModalBottomSheetState(true)
     val listState = rememberLazyListState()
     val pullToRefreshState = rememberPullToRefreshState()
 
+    val userProfile by accountViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()
+
+    val isRelayListEmpty by accountViewModel.isRelayListEmpty.collectAsStateWithLifecycle()
+    val isSyncing by chatViewModel.isSyncing.collectAsStateWithLifecycle()
+    val isPartialProcessedGiftWrap by chatViewModel.isPartialProcessedGiftWrap.collectAsStateWithLifecycle()
+
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val isBannerDismissed = accountState.isNotificationBannerDismissed
+
     val expandedFab by remember { derivedStateOf { listState.firstVisibleItemIndex == 0 } }
     var showBottomSheet by remember { mutableStateOf(false) }
     var isRefreshing by remember { mutableStateOf(false) }
+    var isBusy by remember { mutableStateOf(false) }
 
     var isNotificationEnabled by remember {
         mutableStateOf(NotificationManagerCompat.from(context).areNotificationsEnabled())
@@ -133,13 +146,18 @@ fun HomeScreen() {
         // State will be updated by LifecycleResumeEffect
     }
 
+    // Partition chat rooms into requests and ongoing
+    val (requests, ongoing) = remember(chatRooms) {
+        chatRooms.partition { it.kind == RoomKind.Request }
+    }
+
     LifecycleResumeEffect(context) {
         isNotificationEnabled = NotificationManagerCompat.from(context).areNotificationsEnabled()
         onPauseOrDispose { }
     }
 
-    LaunchedEffect(Unit) {
-        viewModel.getChatRooms()
+    LaunchedEffect(accountState.signerRequired) {
+        chatViewModel.refreshChatRooms()
     }
 
     LaunchedEffect(qrScanResult.content) {
@@ -147,7 +165,7 @@ fun HomeScreen() {
             runCatching { PublicKey.parse(result) }
                 .onSuccess { pubkey ->
                     try {
-                        val roomId = viewModel.createChatRoom(listOf(pubkey))
+                        val roomId = chatViewModel.createChatRoom(listOf(pubkey))
                         navigator.navigate(Screen.Chat(roomId))
                     } catch (e: Exception) {
                         e.message?.let { snackbarHostState.showSnackbar(it) }
@@ -168,10 +186,18 @@ fun HomeScreen() {
                     containerColor = MaterialTheme.colorScheme.surfaceContainer,
                 ),
                 title = {
-                    Text(
-                        text = "Coop",
-                        style = MaterialTheme.typography.titleMediumEmphasized
-                    )
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        Text(
+                            text = "Coop",
+                            style = MaterialTheme.typography.titleMediumEmphasized
+                        )
+                        if (isSyncing) {
+                            LoadingIndicator(modifier = Modifier.size(24.dp))
+                        }
+                    }
                 },
                 actions = {
                     // QR Scanner
@@ -184,8 +210,8 @@ fun HomeScreen() {
                     // User
                     IconButton(onClick = { showBottomSheet = true }) {
                         Avatar(
-                            picture = userProfile?.asRecord()?.picture,
-                            description = userProfile?.asRecord()?.displayName,
+                            picture = userProfile?.picture,
+                            description = userProfile?.name ?: "No name",
                             size = 32.dp,
                         )
                     }
@@ -255,7 +281,7 @@ fun HomeScreen() {
                                 horizontalArrangement = Arrangement.spacedBy(8.dp),
                             ) {
                                 TextButton(
-                                    onClick = { viewModel.dismissNotificationBanner() },
+                                    onClick = { accountViewModel.dismissNotificationBanner() },
                                     modifier = Modifier.weight(1f),
                                 ) {
                                     Text(text = "Maybe later")
@@ -294,11 +320,9 @@ fun HomeScreen() {
                         isRefreshing = isRefreshing,
                         state = pullToRefreshState,
                         onRefresh = {
-                            scope.launch {
-                                isRefreshing = true
-                                viewModel.refreshChatRooms()
-                                isRefreshing = false
-                            }
+                            isRefreshing = true
+                            chatViewModel.refreshChatRooms()
+                            isRefreshing = false
                         },
                         indicator = {
                             PullToRefreshDefaults.LoadingIndicator(
@@ -343,7 +367,11 @@ fun HomeScreen() {
                                 state = listState,
                                 modifier = Modifier.fillMaxSize()
                             ) {
-                                items(chatRooms.toList(), key = { it.id }) { room ->
+                                if (requests.isNotEmpty()) {
+                                    item { NewRequests(requests) }
+                                }
+
+                                items(ongoing, key = { it.id }) { room ->
                                     ChatRoom(
                                         room = room,
                                         onClick = { navigator.navigate(Screen.Chat(room.id)) }
@@ -352,115 +380,327 @@ fun HomeScreen() {
                             }
                         }
                     }
+                }
+            }
+        },
+    )
 
-                    if (showBottomSheet) {
-                        ModalBottomSheet(
-                            onDismissRequest = { showBottomSheet = false },
-                            sheetState = sheetState,
-                            modifier = Modifier
-                                .imePadding()
-                                .navigationBarsPadding(),
-                        ) {
-                            val pubkey = viewModel.currentUser()
-                            val shortPubkey = pubkey?.short() ?: "Not available"
+    if (showBottomSheet) {
+        ModalBottomSheet(
+            onDismissRequest = { showBottomSheet = false },
+            sheetState = sheetState,
+        ) {
+            val dismissAndRun: (suspend () -> Unit) -> Unit = { action ->
+                scope.launch {
+                    sheetState.hide()
+                    showBottomSheet = false
+                    action()
+                }
+            }
 
-                            val userName =
-                                userProfile?.asRecord()?.displayName
-                                    ?: userProfile?.asRecord()?.name
-                                    ?: "No name"
-
-                            val dismissAndRun: (suspend () -> Unit) -> Unit = { action ->
+            Column(
+                modifier = Modifier
+                    .padding(16.dp)
+                    .fillMaxWidth(),
+            ) {
+                Column(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(84.dp)
+                            .clip(MaterialShapes.Cookie9Sided.toShape()),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Avatar(
+                            picture = userProfile?.picture,
+                            description = userProfile?.name ?: "No name",
+                            shape = MaterialShapes.Cookie9Sided.toShape(),
+                            modifier = Modifier.fillMaxSize()
+                        )
+                    }
+                    Spacer(modifier = Modifier.size(8.dp))
+                    Box(
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Text(
+                            text = userProfile?.name ?: "No name",
+                            style = MaterialTheme.typography.titleLargeEmphasized,
+                        )
+                    }
+                    Spacer(modifier = Modifier.size(8.dp))
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        OutlinedButton(
+                            onClick = {
                                 scope.launch {
-                                    sheetState.hide()
-                                    showBottomSheet = false
-                                    action()
+                                    userProfile?.publicKey?.let {
+                                        val bech32 = it.toBech32()
+                                        val data = ClipData.newPlainText(bech32, bech32)
+                                        clipboardManager.setClipEntry(ClipEntry(data))
+                                    }
                                 }
-                            }
+                            },
+                        ) {
+                            Text(text = userProfile?.shortPublicKey ?: "Unknown")
+                        }
+                        FilledIconButton(
+                            onClick = {
+                                dismissAndRun { navigator.navigate(Screen.MyQr) }
+                            },
+                            shape = MaterialShapes.Square.toShape()
+                        ) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_qr),
+                                contentDescription = "My QR"
+                            )
+                        }
+                    }
+                }
+                Spacer(modifier = Modifier.size(16.dp))
+                BottomMenuList(
+                    onDismiss = dismissAndRun,
+                    accountViewModel = accountViewModel,
+                    chatViewModel = chatViewModel
+                )
+            }
+        }
+    }
 
-                            Column(
-                                modifier = Modifier
-                                    .padding(16.dp)
-                                    .fillMaxWidth(),
-                            ) {
-                                Column(
-                                    modifier = Modifier.fillMaxWidth(),
-                                    horizontalAlignment = Alignment.CenterHorizontally,
-                                ) {
-                                    Box(
-                                        modifier = Modifier
-                                            .size(84.dp)
-                                            .clip(MaterialShapes.Cookie9Sided.toShape()),
-                                        contentAlignment = Alignment.Center
-                                    ) {
-                                        Avatar(
-                                            picture = userProfile?.asRecord()?.picture,
-                                            description = userProfile?.asRecord()?.displayName,
-                                            shape = MaterialShapes.Cookie9Sided.toShape(),
-                                            modifier = Modifier.fillMaxSize()
-                                        )
-                                    }
-                                    Spacer(modifier = Modifier.size(8.dp))
-                                    Box(
-                                        contentAlignment = Alignment.Center
-                                    ) {
-                                        Text(
-                                            text = userName,
-                                            style = MaterialTheme.typography.titleLargeEmphasized,
-                                        )
-                                    }
-                                    Spacer(modifier = Modifier.size(8.dp))
-                                    Row(
-                                        verticalAlignment = Alignment.CenterVertically,
-                                    ) {
-                                        OutlinedButton(
-                                            onClick = {
-                                                scope.launch {
-                                                    pubkey?.let {
-                                                        val bech32 = it.toBech32()
-                                                        val data =
-                                                            ClipData.newPlainText(bech32, bech32)
-                                                        clipboardManager.setClipEntry(ClipEntry(data))
-                                                    }
-                                                }
-                                            },
-                                        ) {
-                                            Text(text = shortPubkey)
-                                        }
-                                        FilledIconButton(
-                                            onClick = {
-                                                dismissAndRun { navigator.navigate(Screen.MyQr) }
-                                            },
-                                            shape = MaterialShapes.Square.toShape()
-                                        ) {
-                                            Icon(
-                                                painter = painterResource(Res.drawable.ic_qr),
-                                                contentDescription = "My QR"
-                                            )
-                                        }
-                                    }
-                                }
-                                Spacer(modifier = Modifier.size(16.dp))
-                                BottomMenuList(onDismiss = dismissAndRun)
-                            }
+    // Show the relay setup dialog if the msg relay list is empty
+    if (isRelayListEmpty) {
+        ModalBottomSheet(
+            onDismissRequest = { accountViewModel.dismissRelayWarning() },
+            sheetState = sheetState,
+            containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .fillMaxHeight(0.5f)
+                    .padding(horizontal = 24.dp)
+                    .navigationBarsPadding(),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                Text(
+                    text = "Messaging Relays are missing",
+                    style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                        fontWeight = FontWeight.SemiBold,
+                        fontFamily = getExpressiveFontFamily()
+                    ),
+                    textAlign = TextAlign.Center,
+                    color = MaterialTheme.colorScheme.primary,
+                )
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    Surface(
+                        modifier = Modifier.size(24.dp),
+                        shape = MaterialShapes.Circle.toShape(),
+                        color = MaterialTheme.colorScheme.error,
+                    ) {
+                        Box(
+                            modifier = Modifier.fillMaxSize(),
+                            contentAlignment = Alignment.Center,
+                        ) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_close),
+                                contentDescription = "X",
+                                modifier = Modifier.size(16.dp),
+                                tint = MaterialTheme.colorScheme.onError
+                            )
+                        }
+                    }
+                    Text(
+                        text = "Other people won't be able to send you messages.",
+                        style = MaterialTheme.typography.titleSmallEmphasized,
+                    )
+                }
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    Surface(
+                        modifier = Modifier.size(24.dp),
+                        shape = MaterialShapes.Circle.toShape(),
+                        color = MaterialTheme.colorScheme.error,
+                    ) {
+                        Box(
+                            modifier = Modifier.fillMaxSize(),
+                            contentAlignment = Alignment.Center,
+                        ) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_close),
+                                contentDescription = "X",
+                                modifier = Modifier.size(16.dp),
+                                tint = MaterialTheme.colorScheme.onError
+                            )
+                        }
+                    }
+                    Text(
+                        text = "You cannot store your messages.",
+                        style = MaterialTheme.typography.titleSmallEmphasized,
+                    )
+                }
+                Text(
+                    text = "Please click the button below to continue with the default set of relays. You can always change them later in the settings.",
+                    style = MaterialTheme.typography.bodySmall.copy(
+                        fontStyle = FontStyle.Italic,
+                    ),
+                )
+                Text(
+                    text = "If you believe this is a mistake, please click the Retry button to check again.",
+                    style = MaterialTheme.typography.bodySmall.copy(
+                        fontStyle = FontStyle.Italic,
+                    ),
+                )
+                Spacer(modifier = Modifier.weight(1f))
+                if (isBusy) {
+                    Box(
+                        modifier = Modifier.fillMaxWidth(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        LoadingIndicator()
+                    }
+                } else {
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        TextButton(
+                            enabled = !isBusy,
+                            onClick = {
+                                isBusy = true
+                                accountViewModel.refetchMsgRelays()
+                                isBusy = false
+                            },
+                            modifier = Modifier
+                                .weight(1f)
+                                .height(ButtonDefaults.MediumContainerHeight),
+                        ) {
+                            Text(
+                                text = "Retry",
+                                style = MaterialTheme.typography.titleMediumEmphasized,
+                            )
+                        }
+                        Button(
+                            enabled = !isBusy,
+                            onClick = {
+                                accountViewModel.useDefaultMsgRelayList()
+                                scope.launch { sheetState.hide() }
+                            },
+                            modifier = Modifier
+                                .weight(1f)
+                                .height(ButtonDefaults.MediumContainerHeight),
+                        ) {
+                            Text(
+                                text = "Use Default",
+                                style = MaterialTheme.typography.titleMediumEmphasized,
+                            )
                         }
                     }
                 }
             }
+        }
+    }
+}
+
+@Composable
+fun NewRequests(requests: List<Room>) {
+    val navigator = LocalNavigator.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).flow(profileCache)
+        .collectAsStateWithLifecycle(RoomUiState())
+    val secondRoomState by (secondRoom ?: firstRoom).flow(profileCache)
+        .collectAsStateWithLifecycle(RoomUiState())
+
+    val supportingText = when {
+        total == 1 -> {
+            val message = firstRoom.lastMessage ?: ""
+            "${firstRoomState.name}: $message"
+        }
+
+        total == 2 -> {
+            "${firstRoomState.name} and ${secondRoomState.name}"
+        }
+
+        total > 2 -> {
+            val othersCount = total - 2
+            val othersText = if (othersCount == 1) "1 other" else "$othersCount others"
+            "${firstRoomState.name}, ${secondRoomState.name} and $othersText"
+        }
+
+        else -> ""
+    }
+
+    ListItem(
+        modifier = Modifier.clickable {
+            navigator.navigate(Screen.RequestList)
         },
+        leadingContent = {
+            Box(
+                modifier = Modifier
+                    .size(48.dp)
+                    .clip(MaterialShapes.Clover4Leaf.toShape()),
+                contentAlignment = Alignment.Center
+            ) {
+                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
+                        )
+                    }
+                }
+            }
+        },
+        headlineContent = {
+            Text(
+                text = "Requests",
+                style = MaterialTheme.typography.titleMediumEmphasized
+            )
+        },
+        supportingContent = {
+            if (supportingText.isNotEmpty()) {
+                Text(
+                    text = supportingText,
+                    style = MaterialTheme.typography.bodyMedium,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis
+                )
+            }
+        },
+        colors = ListItemDefaults.colors(
+            containerColor = MaterialTheme.colorScheme.surface
+        )
     )
 }
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun ChatRoom(room: Room, onClick: () -> Unit) {
-    val viewModel = LocalNostrViewModel.current
-    val displayName by remember(room) { room.displayNameFlow(viewModel) }.collectAsState("Loading...")
-    val picture by remember(room) { room.pictureFlow(viewModel) }.collectAsState(null)
+    val profileCache = LocalProfileCache.current
+    val roomState by room.flow(profileCache).collectAsStateWithLifecycle(RoomUiState())
 
     ListItem(
         modifier = Modifier.clickable(onClick = onClick),
         leadingContent = {
-            Avatar(picture = picture, description = displayName)
+            Avatar(picture = roomState.picture, description = roomState.picture)
         },
         headlineContent = {
             Row(
@@ -468,7 +708,7 @@ fun ChatRoom(room: Room, onClick: () -> Unit) {
                 verticalAlignment = Alignment.CenterVertically
             ) {
                 Text(
-                    text = displayName,
+                    text = roomState.name,
                     style = MaterialTheme.typography.titleMediumEmphasized,
                     modifier = Modifier.weight(1f)
                 )
@@ -482,8 +722,10 @@ fun ChatRoom(room: Room, onClick: () -> Unit) {
         supportingContent = {
             if (!room.lastMessage.isNullOrBlank()) {
                 Text(
-                    text = room.lastMessage!!,
-                    style = MaterialTheme.typography.bodyMedium
+                    text = room.lastMessage ?: "",
+                    style = MaterialTheme.typography.bodyMedium,
+                    overflow = TextOverflow.Ellipsis,
+                    maxLines = 1,
                 )
             }
         },
@@ -496,15 +738,15 @@ 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 viewModel = LocalNostrViewModel.current
 
     val defaultMenuList = listOf(
         "Update Profile" to { navigator.navigate(Screen.UpdateProfile) },
-        "Contact List" to { },
-        "Spams & Blocks" to { },
+        "Contact List" to { navigator.navigate(Screen.ContactList) },
         "Relay Management" to { navigator.navigate(Screen.Relay) },
         "Settings" to { }
     )
@@ -530,7 +772,14 @@ fun BottomMenuList(
         }
         Spacer(modifier = Modifier.size(16.dp))
         FilledTonalButton(
-            onClick = { viewModel.logout() },
+            onClick = {
+                onDismiss {
+                    accountViewModel.logout(onLogout = {
+                        accountViewModel.resetInternalState()
+                        chatViewModel.resetInternalState()
+                    })
+                }
+            },
             colors = ButtonDefaults.filledTonalButtonColors(
                 containerColor = MaterialTheme.colorScheme.error,
                 contentColor = MaterialTheme.colorScheme.onError

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

@@ -22,7 +22,6 @@ import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.LoadingIndicator
-import androidx.compose.material3.MaterialShapes
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
@@ -30,86 +29,85 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.material3.toShape
 import androidx.compose.runtime.Composable
 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.draw.clip
 import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.platform.LocalFocusManager
 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.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_arrow_back
 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.Keys
 import rust.nostr.sdk.NostrConnectUri
-import rust.nostr.sdk.PublicKey
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 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.shared.getExpressiveFontFamily
-import su.reya.coop.short
+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 viewModel = LocalNostrViewModel.current
-
-    val scope = rememberCoroutineScope()
-
-    val isBusy by viewModel.isBusy.collectAsStateWithLifecycle(false)
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
     var secret by remember { mutableStateOf("") }
-    var pubkey by remember { mutableStateOf<PublicKey?>(null) }
-
-    // Get metadata when pubkey changes
-    val metadata by remember(pubkey) {
-        pubkey?.let(viewModel::getMetadata) ?: flowOf(null)
-    }.collectAsStateWithLifecycle(null)
-
-    val profile = metadata?.asRecord()
-    val displayName = profile?.displayName ?: profile?.name ?: pubkey?.short() ?: "Unknown"
-    val picture = profile?.picture
+    var password by remember { mutableStateOf("") }
+    var requirePassword by remember { mutableStateOf(false) }
 
     LaunchedEffect(qrScanResult.content) {
         qrScanResult.content?.let { result ->
             runCatching {
-                if (result.startsWith("nsec")) {
+                if (result.startsWith("nsec1") || result.startsWith("ncryptsec1")) {
                     Keys.parse(result)
                 } else if (result.startsWith("bunker://")) {
                     NostrConnectUri.parse(result)
                 } else {
-                    throw IllegalArgumentException("Invalid secret: $result")
+                    throw IllegalArgumentException("Unsupported secret format")
                 }
+            }.onSuccess {
+                secret = result
+            }.onFailure { e ->
+                e.message?.let { snackbarHostState.showSnackbar(it) }
             }
-                .onSuccess { it -> secret = result }
-                .onFailure { e -> println("Failed to parse QR: ${e.message}") }
-
             // Clear the nav state
             qrScanResult.clear()
         }
     }
 
+    LaunchedEffect(secret) {
+        if (secret.startsWith("ncryptsec1")) {
+            requirePassword = true
+        }
+    }
+
+    // Navigate to Home on successful import (signerRequired becomes false)
+    LaunchedEffect(accountState.signerRequired) {
+        if (accountState.signerRequired == false) {
+            navigator.navigate(Screen.Home)
+        }
+    }
+
+    // Show import errors via snackbar
+    LaunchedEffect(accountState.importError) {
+        accountState.importError?.let {
+            snackbarHostState.showSnackbar(it)
+        }
+    }
+
     Scaffold(
         containerColor = MaterialTheme.colorScheme.surfaceContainer,
         snackbarHost = { SnackbarHost(snackbarHostState) },
@@ -149,35 +147,6 @@ fun ImportScreen() {
                     .padding(top = innerPadding.calculateTopPadding())
                     .imePadding(),
             ) {
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .weight(1f),
-                    verticalArrangement = Arrangement.Center,
-                    horizontalAlignment = Alignment.CenterHorizontally
-                ) {
-                    Box(
-                        modifier = Modifier
-                            .size(120.dp)
-                            .clip(MaterialShapes.Cookie9Sided.toShape()),
-                        contentAlignment = Alignment.Center
-                    ) {
-                        Avatar(
-                            picture = picture,
-                            description = "Profile picture",
-                            modifier = Modifier.fillMaxSize(),
-                            shape = MaterialShapes.Cookie9Sided.toShape(),
-                        )
-                    }
-                    Spacer(modifier = Modifier.size(8.dp))
-                    Text(
-                        text = displayName,
-                        textAlign = TextAlign.Center,
-                        style = MaterialTheme.typography.titleLargeEmphasized.copy(
-                            fontFamily = getExpressiveFontFamily()
-                        ),
-                    )
-                }
                 Surface(
                     modifier = Modifier
                         .fillMaxWidth()
@@ -188,7 +157,7 @@ fun ImportScreen() {
                     Column(
                         modifier = Modifier
                             .fillMaxSize()
-                            .padding(24.dp)
+                            .padding(24.dp),
                     ) {
                         Column(
                             modifier = Modifier
@@ -205,9 +174,9 @@ fun ImportScreen() {
                             BasicTextField(
                                 value = secret,
                                 onValueChange = { secret = it },
-                                enabled = !isBusy,
+                                enabled = !accountState.isImporting,
                                 modifier = Modifier.fillMaxWidth(),
-                                maxLines = 4,
+                                singleLine = true,
                                 keyboardOptions = KeyboardOptions(
                                     imeAction = ImeAction.Done,
                                 ),
@@ -239,32 +208,57 @@ fun ImportScreen() {
                                     }
                                 }
                             )
+                            Spacer(modifier = Modifier.size(8.dp))
+                            if (requirePassword) {
+                                Text(
+                                    text = "Decrypt Password:",
+                                    style = MaterialTheme.typography.titleMediumEmphasized.copy(
+                                        fontWeight = FontWeight.SemiBold,
+                                    ),
+                                )
+                                BasicTextField(
+                                    value = password,
+                                    onValueChange = { password = it },
+                                    enabled = !accountState.isImporting && requirePassword,
+                                    modifier = Modifier.fillMaxWidth(),
+                                    singleLine = true,
+                                    keyboardOptions = KeyboardOptions(
+                                        imeAction = ImeAction.Done,
+                                    ),
+                                    keyboardActions = KeyboardActions(
+                                        onDone = {
+                                            focusManager.clearFocus()
+                                        }
+                                    ),
+                                    visualTransformation = PasswordVisualTransformation('*'),
+                                    textStyle = MaterialTheme.typography.bodyMediumEmphasized.copy(
+                                        color = MaterialTheme.colorScheme.tertiaryFixedDim,
+                                        fontWeight = FontWeight.SemiBold,
+                                    ),
+                                    cursorBrush = SolidColor(MaterialTheme.colorScheme.tertiaryContainer),
+                                    decorationBox = { innerTextField ->
+                                        Box(contentAlignment = Alignment.CenterStart) {
+                                            innerTextField()
+                                        }
+                                    }
+                                )
+                            }
                         }
                         Spacer(modifier = Modifier.size(16.dp))
                         Button(
                             onClick = {
-                                scope.launch {
-                                    if (pubkey == null) {
-                                        viewModel.verifyIdentity(secret).let { pubkey = it }
-                                    } else {
-                                        // Import the identity
-                                        viewModel.importIdentity(secret)
-                                        // Navigate to the home screen
-                                        navigator.navigate(Screen.Home)
-                                    }
-                                }
-
+                                viewModel.importIdentity(secret, password)
                             },
                             modifier = Modifier
                                 .fillMaxWidth()
                                 .height(ButtonDefaults.MediumContainerHeight),
-                            enabled = secret.isNotBlank() && !isBusy,
+                            enabled = secret.isNotBlank() && !accountState.isImporting,
                         ) {
-                            if (isBusy) {
+                            if (accountState.isImporting) {
                                 LoadingIndicator()
                             } else {
                                 Text(
-                                    text = if (pubkey == null) "Verify" else "Click again to Continue",
+                                    text = "Continue",
                                     style = MaterialTheme.typography.titleMediumEmphasized,
                                 )
                             }

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

@@ -13,22 +13,23 @@ import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 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 viewModel = LocalNostrViewModel.current
-    val currentUser = viewModel.currentUser() ?: return
+    val currentUser by viewModel.currentUserProfile.collectAsStateWithLifecycle()
 
     Scaffold(
         snackbarHost = { SnackbarHost(snackbarHostState) },
@@ -59,7 +60,7 @@ fun MyQrScreen() {
                 horizontalAlignment = Alignment.CenterHorizontally,
             ) {
                 Image(
-                    painter = rememberQrCodePainter(currentUser.toBech32()),
+                    painter = rememberQrCodePainter(currentUser?.publicKey?.toBech32() ?: ""),
                     contentDescription = "My QR"
                 )
             }

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

@@ -46,6 +46,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.text.font.FontWeight
 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_arrow_next
@@ -55,30 +56,35 @@ import kotlinx.coroutines.delay
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
 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 viewModel = LocalNostrViewModel.current
+    val contactList by accountViewModel.contactList.collectAsStateWithLifecycle()
+    var query by remember { mutableStateOf("") }
 
-    val contactList by viewModel.contactList.collectAsState(initial = emptySet())
     val createGroup = remember { mutableStateOf(false) }
     val searchResults = remember { mutableStateListOf<PublicKey>() }
     val selectedReceivers = remember { mutableStateListOf<PublicKey>() }
-    var query by remember { mutableStateOf("") }
 
     LaunchedEffect(query) {
         if (query.length >= 3) {
-            delay(500) // 500ms debounce
+            delay(500.milliseconds)
 
             if (query.startsWith("npub1")) {
                 val pubkey = try {
@@ -91,14 +97,16 @@ fun NewChatScreen() {
                     selectedReceivers.add(pubkey)
                 }
             } else if (query.contains("@")) {
-                val pubkey = viewModel.searchByAddress(query)
-                if (pubkey != null) {
-                    selectedReceivers.add(pubkey)
+                accountViewModel.searchByAddress(query) { pubkey ->
+                    if (pubkey != null) {
+                        selectedReceivers.add(pubkey)
+                    }
                 }
             } else {
-                val results = viewModel.searchByNostr(query)
-                searchResults.clear()
-                searchResults.addAll(results)
+                accountViewModel.searchByNostr(query) { results ->
+                    searchResults.clear()
+                    searchResults.addAll(results)
+                }
             }
 
             query = ""
@@ -108,14 +116,13 @@ fun NewChatScreen() {
     LaunchedEffect(qrScanResult.content) {
         qrScanResult.content?.let { result ->
             // Verify the content
-            runCatching { PublicKey.parse(result) }
-                .onSuccess { pubkey ->
-                    selectedReceivers.add(pubkey)
-                }
-                .onFailure { e ->
-                    println("Failed to parse QR: ${e.message}")
-                }
-
+            runCatching {
+                PublicKey.parse(result)
+            }.onSuccess { pubkey ->
+                selectedReceivers.add(pubkey)
+            }.onFailure { e ->
+                snackbarHostState.showSnackbar("Invalid address: ${e.message}")
+            }
             // Clear the nav state
             qrScanResult.clear()
         }
@@ -167,7 +174,7 @@ fun NewChatScreen() {
                 ) {
                     ExtendedFloatingActionButton(
                         onClick = {
-                            val roomId = viewModel.createChatRoom(selectedReceivers.toList())
+                            val roomId = chatViewModel.createChatRoom(selectedReceivers.toList())
                             navigator.navigate(Screen.Chat(roomId))
                         },
                         expanded = false,
@@ -258,7 +265,7 @@ fun NewChatScreen() {
                             items = searchResults,
                             selectedReceivers = selectedReceivers,
                             onContactClick = { pubkey ->
-                                val roomId = viewModel.createChatRoom(listOf(pubkey))
+                                val roomId = chatViewModel.createChatRoom(listOf(pubkey))
                                 navigator.navigate(Screen.Chat(roomId))
                             },
                         )
@@ -269,7 +276,7 @@ fun NewChatScreen() {
                             items = contactList.toList(),
                             selectedReceivers = selectedReceivers,
                             onContactClick = { pubkey ->
-                                val roomId = viewModel.createChatRoom(listOf(pubkey))
+                                val roomId = chatViewModel.createChatRoom(listOf(pubkey))
                                 navigator.navigate(Screen.Chat(roomId))
                             }
                         )
@@ -286,13 +293,9 @@ fun ReceiverChip(
     pubkey: PublicKey,
     onRemove: () -> Unit
 ) {
-    val viewModel = LocalNostrViewModel.current
-    val metadataFlow = remember(pubkey) { viewModel.getMetadata(pubkey) }
-    val metadata by metadataFlow.collectAsState(initial = null)
-
-    val profile = metadata?.asRecord()
-    val displayName = profile?.name ?: profile?.displayName ?: pubkey.short()
-    val picture = profile?.picture
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsState(initial = null)
 
     CompositionLocalProvider(LocalMinimumInteractiveComponentSize provides 0.dp) {
         InputChip(
@@ -300,7 +303,7 @@ fun ReceiverChip(
             onClick = onRemove,
             label = {
                 Text(
-                    text = displayName,
+                    text = profile?.name ?: "No name",
                     style = MaterialTheme.typography.bodyMedium.copy(
                         fontWeight = FontWeight.SemiBold
                     )
@@ -308,8 +311,8 @@ fun ReceiverChip(
             },
             avatar = {
                 Avatar(
-                    picture = picture,
-                    description = displayName,
+                    picture = profile?.picture,
+                    description = profile?.name ?: "No name",
                     size = 24.dp
                 )
             },
@@ -372,13 +375,9 @@ fun ContactListItem(
     onClick: () -> Unit,
     onLongClick: () -> Unit
 ) {
-    val viewModel = LocalNostrViewModel.current
-    val metadataFlow = remember(pubkey) { viewModel.getMetadata(pubkey) }
-    val metadata by metadataFlow.collectAsState(initial = null)
-
-    val profile = metadata?.asRecord()
-    val displayName = profile?.name ?: profile?.displayName ?: pubkey.short()
-    val picture = profile?.picture
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsState(initial = null)
 
     SegmentedListItem(
         selected = isSelected,
@@ -390,15 +389,15 @@ fun ContactListItem(
         ),
         leadingContent = {
             Avatar(
-                picture = picture,
-                description = displayName,
+                picture = profile?.picture,
+                description = profile?.name ?: "",
                 size = 36.dp
             )
         },
         supportingContent = { Text(text = pubkey.short()) },
         content = {
             Text(
-                text = displayName,
+                text = profile?.name ?: "",
                 style = MaterialTheme.typography.titleMediumEmphasized,
             )
         }

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

@@ -2,31 +2,25 @@ package su.reya.coop.screens
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import kotlinx.coroutines.launch
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.Screen
 import su.reya.coop.shared.ProfileEditor
+import su.reya.coop.viewmodel.AccountViewModel
 
 @Composable
-fun NewIdentityScreen() {
-    val viewModel = LocalNostrViewModel.current
+fun NewIdentityScreen(viewModel: AccountViewModel) {
     val navigator = LocalNavigator.current
-    val scope = rememberCoroutineScope()
-    val isBusy by viewModel.isBusy.collectAsStateWithLifecycle(false)
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
 
     ProfileEditor(
         title = "Create a new identity",
         buttonLabel = "Continue",
-        isBusy = isBusy,
+        isBusy = accountState.isImporting,
         onBack = { navigator.goBack() },
         onConfirm = { name, bio, bytes, type ->
-            scope.launch {
-                viewModel.createIdentity(name, bio, bytes, type)
-                navigator.navigate(Screen.Home)
-            }
+            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,28 +43,43 @@ 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.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 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 viewModel = LocalNostrViewModel.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)
+        }
+    }
+
+    // Show connection errors
+    LaunchedEffect(accountState.importError) {
+        accountState.importError?.let {
+            snackbarHostState.showSnackbar(it)
+        }
+    }
+
     val logoPainter = painterResource(Res.drawable.coop)
     val expressiveFont = getExpressiveFontFamily()
-    
+
     val annotatedText = buildAnnotatedString {
         append("By using Coop, you agree to accept\nour ")
         // Push "Terms of Use" link
@@ -157,15 +174,12 @@ fun OnboardingScreen() {
                             Spacer(modifier = Modifier.size(8.dp))
                             FilledTonalButton(
                                 onClick = {
-                                    scope.launch {
-                                        if (viewModel.isExternalSignerAvailable()) {
-                                            try {
-                                                viewModel.connectExternalSigner()
-                                                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

@@ -27,7 +27,6 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.toShape
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -37,6 +36,7 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.platform.LocalContext
 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_arrow_back
 import coop.composeapp.generated.resources.ic_chat
@@ -45,36 +45,40 @@ import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
 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 viewModel = LocalNostrViewModel.current
-
+    val profileCache = LocalProfileCache.current
     val scope = rememberCoroutineScope()
-    val metadataFlow = remember(pubkey) { viewModel.getMetadata(pubkey) }
-    val metadata by metadataFlow.collectAsState(initial = null)
 
-    val profile = metadata?.asRecord()
-    val displayName = profile?.displayName ?: profile?.name ?: "No name"
-    val nip05 = profile?.nip05 ?: pubkey.short()
-    val picture = profile?.picture
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsStateWithLifecycle()
+
+    val metadata = profile?.metadata?.asRecord()
+    val nip05 = metadata?.nip05 ?: pubkey.short()
+    val picture = metadata?.picture
+
     val details = remember(profile) {
         listOf(
-            "Username:" to (profile?.name ?: "None"),
-            "Website:" to (profile?.website ?: "None"),
-            "Lightning Address:" to (profile?.lud16 ?: "None"),
+            "Username:" to (metadata?.name ?: "None"),
+            "Website:" to (metadata?.website ?: "None"),
+            "₿ Lightning Address:" to (metadata?.lud16 ?: "None"),
         )
     }
 
@@ -83,7 +87,7 @@ fun ProfileScreen(pubkey: String) {
         snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
             TopAppBar(
-                title = { },
+                title = { /* empty */ },
                 navigationIcon = {
                     IconButton(onClick = { navigator.goBack() }) {
                         Icon(
@@ -132,7 +136,7 @@ fun ProfileScreen(pubkey: String) {
                         verticalArrangement = Arrangement.spacedBy(4.dp),
                     ) {
                         Text(
-                            text = displayName,
+                            text = profile?.name ?: "No name",
                             textAlign = TextAlign.Center,
                             style = MaterialTheme.typography.titleLargeEmphasized.copy(
                                 fontFamily = getExpressiveFontFamily()
@@ -158,7 +162,8 @@ fun ProfileScreen(pubkey: String) {
                                 onClick = {
                                     scope.launch {
                                         try {
-                                            val roomId = viewModel.createChatRoom(listOf(pubkey))
+                                            val roomId =
+                                                chatViewModel.createChatRoom(listOf(pubkey))
                                             navigator.navigate(Screen.Chat(roomId))
                                         } catch (e: Exception) {
                                             e.message?.let { snackbarHostState.showSnackbar(it) }
@@ -237,4 +242,4 @@ fun ProfileScreen(pubkey: String) {
             }
         }
     )
-}
+}

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

@@ -3,48 +3,80 @@ package su.reya.coop.screens
 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.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.selection.selectableGroup
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.ExtendedFloatingActionButton
 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.PlainTooltip
+import androidx.compose.material3.RadioButton
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SegmentedListItem
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TooltipAnchorPosition
+import androidx.compose.material3.TooltipBox
+import androidx.compose.material3.TooltipDefaults
 import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberTooltipState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateMapOf
+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.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.semantics.Role
+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
+import coop.composeapp.generated.resources.ic_close
+import coop.composeapp.generated.resources.ic_plus
+import kotlinx.coroutines.launch
 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 viewModel = LocalNostrViewModel.current
 
+    val scope = rememberCoroutineScope()
     val msgRelayList = remember { mutableStateListOf<RelayUrl>() }
     val relayList = remember { mutableStateMapOf<RelayUrl, RelayMetadata?>() }
 
@@ -60,9 +92,29 @@ fun RelayScreen() {
         }
     }
 
+    var openAddRelayDialog by remember { mutableStateOf(false) }
+    var relayToDelete by remember { mutableStateOf<String?>(null) }
+
     LaunchedEffect(Unit) {
-        relayList.putAll(viewModel.currentUserRelayList())
-        msgRelayList.addAll(viewModel.currentUserMsgRelayList())
+        viewModel.loadCurrentUserRelayList()
+        viewModel.loadCurrentUserMsgRelayList()
+    }
+
+    val loadedRelayList by viewModel.userRelayList.collectAsStateWithLifecycle()
+    val loadedMsgRelayList by viewModel.userMsgRelayList.collectAsStateWithLifecycle()
+
+    LaunchedEffect(loadedRelayList) {
+        if (loadedRelayList.isNotEmpty()) {
+            relayList.clear()
+            relayList.putAll(loadedRelayList)
+        }
+    }
+
+    LaunchedEffect(loadedMsgRelayList) {
+        if (loadedMsgRelayList.isNotEmpty()) {
+            msgRelayList.clear()
+            msgRelayList.addAll(loadedMsgRelayList)
+        }
     }
 
     Scaffold(
@@ -86,9 +138,33 @@ fun RelayScreen() {
                             contentDescription = "Back"
                         )
                     }
-                }
+                },
             )
         },
+        floatingActionButton = {
+            TooltipBox(
+                positionProvider = TooltipDefaults.rememberTooltipPositionProvider(
+                    TooltipAnchorPosition.Above,
+                    spacingBetweenTooltipAndAnchor = 8.dp,
+                ),
+                tooltip = {
+                    PlainTooltip { Text("New Relay") }
+                },
+                state = rememberTooltipState(),
+            ) {
+                ExtendedFloatingActionButton(
+                    onClick = { openAddRelayDialog = true },
+                    expanded = false,
+                    icon = {
+                        Icon(
+                            painter = painterResource(Res.drawable.ic_plus),
+                            contentDescription = "New Relay"
+                        )
+                    },
+                    text = { Text("New Relay") },
+                )
+            }
+        },
         content = { innerPadding ->
             Column(
                 modifier = Modifier
@@ -113,7 +189,8 @@ fun RelayScreen() {
                         if (msgRelayList.isNotEmpty()) {
                             msgRelayList.forEachIndexed { index, relayUrl ->
                                 SegmentedListItem(
-                                    onClick = { },
+                                    onClick = { /* No action */ },
+                                    onLongClick = { relayToDelete = relayUrl.toString() },
                                     shapes = ListItemDefaults.segmentedShapes(
                                         index = index,
                                         count = msgRelayList.size
@@ -233,4 +310,216 @@ fun RelayScreen() {
             }
         }
     )
-}
+
+    if (openAddRelayDialog) {
+        AddRelayDialog(
+            viewModel = viewModel,
+            onDismissRequest = { openAddRelayDialog = false },
+            onMsgRelayAdded = { newRelay ->
+                msgRelayList.add(RelayUrl.parse(newRelay))
+            },
+            onRelayAdded = { newRelay, metadata ->
+                relayList[RelayUrl.parse(newRelay)] = metadata
+            }
+        )
+    }
+
+    if (relayToDelete != null) {
+        AlertDialog(
+            onDismissRequest = { relayToDelete = null },
+            title = { Text("Remove Relay") },
+            text = { Text("Are you sure you want to remove $relayToDelete?") },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        if (msgRelayList.size == 1) {
+                            scope.launch {
+                                snackbarHostState.showSnackbar("You must have at least one relay")
+                            }
+                            relayToDelete = null
+                            return@TextButton
+                        }
+                        viewModel.removeMsgRelay(relayToDelete!!)
+                        msgRelayList.removeIf { it.toString() == relayToDelete }
+                        relayToDelete = null
+                    }
+                ) {
+                    Text("Confirm")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { relayToDelete = null }) {
+                    Text("Cancel")
+                }
+            }
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun AddRelayDialog(
+    viewModel: AccountViewModel,
+    onDismissRequest: () -> Unit,
+    onMsgRelayAdded: (newRelay: String) -> Unit,
+    onRelayAdded: (newRelay: String, metadata: RelayMetadata?) -> Unit,
+) {
+    val snackbarHostState = LocalSnackbarHostState.current
+    val focusRequester = remember { FocusRequester() }
+
+    var relayAddress by remember { mutableStateOf("") }
+    var isError by remember { mutableStateOf(false) }
+    val roles = listOf("Messaging", "Inbox", "Outbox")
+    val (selected, onSelected) = remember { mutableStateOf(roles[0]) }
+
+    LaunchedEffect(Unit) {
+        focusRequester.requestFocus()
+    }
+
+    Dialog(
+        onDismissRequest = { onDismissRequest() },
+        properties = DialogProperties(
+            usePlatformDefaultWidth = false,
+            dismissOnBackPress = true,
+            decorFitsSystemWindows = false,
+        ),
+    ) {
+        Scaffold(
+            modifier = Modifier.fillMaxSize(),
+            snackbarHost = { SnackbarHost(snackbarHostState) },
+            containerColor = MaterialTheme.colorScheme.surface,
+            topBar = {
+                TopAppBar(
+                    colors = TopAppBarDefaults.topAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                    ),
+                    title = {
+                        Text(
+                            text = "New Relay",
+                            style = MaterialTheme.typography.titleMediumEmphasized
+                        )
+                    },
+                    navigationIcon = {
+                        IconButton(onClick = { onDismissRequest() }) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_close),
+                                contentDescription = "Close"
+                            )
+                        }
+                    },
+                    actions = {
+                        IconButton(onClick = {
+                            if (!isError) {
+                                when (selected) {
+                                    "Messaging" -> {
+                                        viewModel.addMsgRelay(relayAddress)
+                                        onMsgRelayAdded(relayAddress)
+                                    }
+
+                                    "Inbox" -> {
+                                        viewModel.addInboxRelay(relayAddress)
+                                        onRelayAdded(relayAddress, RelayMetadata.WRITE)
+                                    }
+
+                                    "Outbox" -> {
+                                        viewModel.addOutboxRelay(relayAddress)
+                                        onRelayAdded(relayAddress, RelayMetadata.READ)
+                                    }
+                                }
+                                onDismissRequest()
+                            }
+                        }) {
+                            Icon(
+                                painter = painterResource(Res.drawable.ic_check),
+                                contentDescription = "Add"
+                            )
+                        }
+                    },
+                )
+            },
+            content = { innerPadding ->
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(innerPadding)
+                        .padding(16.dp),
+                    verticalArrangement = Arrangement.spacedBy(16.dp),
+                ) {
+                    OutlinedTextField(
+                        value = relayAddress,
+                        onValueChange = { relayAddress = it },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .focusRequester(focusRequester),
+                        isError = isError,
+                        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+                        keyboardActions = KeyboardActions(
+                            onDone = {
+                                isError = relayAddress.isNotEmpty() && !verifyRelayUrl(relayAddress)
+                            }
+                        ),
+                        singleLine = true,
+                        label = { Text(text = "Relay Address") },
+                        placeholder = { Text(text = "wss://relay.example.com") },
+                        supportingText = {
+                            if (isError) {
+                                Text(text = "Invalid format. Must start with wss://")
+                            } else {
+                                Text(text = "Only add relays you trust.")
+                            }
+                        },
+                    )
+                    Column(
+                        modifier = Modifier.fillMaxWidth(),
+                        verticalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        Text(
+                            text = "Relay Roles",
+                            style = MaterialTheme.typography.titleMediumEmphasized
+                        )
+                        Column(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .selectableGroup(),
+                        ) {
+                            roles.forEach { text ->
+                                Row(
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .height(48.dp)
+                                        .selectable(
+                                            onClick = { onSelected(text) },
+                                            selected = (text == selected),
+                                            role = Role.RadioButton
+                                        )
+                                        .padding(horizontal = 8.dp),
+                                    verticalAlignment = Alignment.CenterVertically
+                                ) {
+                                    RadioButton(
+                                        selected = (text == selected),
+                                        onClick = null
+                                    )
+                                    Spacer(modifier = Modifier.size(16.dp))
+                                    Text(
+                                        text = text,
+                                        style = MaterialTheme.typography.bodyMedium,
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        )
+    }
+}
+
+fun verifyRelayUrl(url: String): Boolean {
+    return try {
+        RelayUrl.parse(url)
+        true
+    } catch (e: Exception) {
+        println("Failed to parse relay url: ${e.message}")
+        false
+    }
+}

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

@@ -0,0 +1,152 @@
+package su.reya.coop.screens
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+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.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.pulltorefresh.PullToRefreshBox
+import androidx.compose.material3.pulltorefresh.PullToRefreshDefaults
+import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
+import androidx.compose.runtime.Composable
+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.text.font.FontWeight
+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 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(viewModel: ChatViewModel) {
+    val navigator = LocalNavigator.current
+    val snackbarHostState = LocalSnackbarHostState.current
+
+    val listState = rememberLazyListState()
+    val pullToRefreshState = rememberPullToRefreshState()
+
+    var isRefreshing by remember { mutableStateOf(false) }
+    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()
+
+    // Get all request rooms
+    val requests = remember(chatRooms) {
+        chatRooms.filter { it.kind == RoomKind.Request }
+    }
+
+    Scaffold(
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        topBar = {
+            TopAppBar(
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainer,
+                ),
+                title = {
+                    Text(
+                        text = "New Requests",
+                        style = MaterialTheme.typography.titleMediumEmphasized
+                    )
+                },
+                navigationIcon = {
+                    IconButton(onClick = { navigator.goBack() }) {
+                        Icon(
+                            painter = org.jetbrains.compose.resources.painterResource(Res.drawable.ic_arrow_back),
+                            contentDescription = "Back"
+                        )
+                    }
+                },
+            )
+        },
+    ) { innerPadding ->
+        Column(
+            modifier = Modifier.padding(top = innerPadding.calculateTopPadding()),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Surface(
+                modifier = Modifier.fillMaxSize(),
+                color = MaterialTheme.colorScheme.surface,
+                shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
+            ) {
+                PullToRefreshBox(
+                    modifier = Modifier.fillMaxSize(),
+                    isRefreshing = isRefreshing,
+                    state = pullToRefreshState,
+                    onRefresh = {
+                        isRefreshing = true
+                        viewModel.refreshChatRooms()
+                        isRefreshing = false
+                    },
+                    indicator = {
+                        PullToRefreshDefaults.LoadingIndicator(
+                            state = pullToRefreshState,
+                            isRefreshing = isRefreshing,
+                            modifier = Modifier.align(Alignment.TopCenter),
+                        )
+                    }
+                ) {
+                    if (requests.isEmpty()) {
+                        Box(
+                            modifier = Modifier.fillMaxSize(),
+                            contentAlignment = Alignment.Center
+                        ) {
+                            Column(
+                                horizontalAlignment = Alignment.CenterHorizontally,
+                                verticalArrangement = Arrangement.spacedBy(4.dp),
+                            ) {
+                                Text(
+                                    text = "No requests yet",
+                                    style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                                        fontWeight = FontWeight.SemiBold
+                                    ),
+                                    color = MaterialTheme.colorScheme.onSurface
+                                )
+                                Text(
+                                    text = "New chat requests will appear here.",
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    color = MaterialTheme.colorScheme.outline
+                                )
+                            }
+                        }
+                    } else {
+                        LazyColumn(
+                            state = listState,
+                            modifier = Modifier.fillMaxSize()
+                        ) {
+                            items(requests.toList(), key = { it.id }) { room ->
+                                ChatRoom(
+                                    room = room,
+                                    onClick = { navigator.navigate(Screen.Chat(room.id, true)) }
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -5,16 +5,15 @@ import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.CenterAlignedTopAppBar
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.Text
-import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
@@ -44,10 +43,10 @@ fun ScanScreen() {
     Scaffold(
         snackbarHost = { SnackbarHost(snackbarHostState) },
         topBar = {
-            TopAppBar(
+            CenterAlignedTopAppBar(
                 title = {
                     Text(
-                        text = "Scan QR",
+                        text = "Scan a Nostr Address",
                         style = MaterialTheme.typography.titleMediumEmphasized
                     )
                 },
@@ -97,14 +96,6 @@ fun ScanScreen() {
                     .align(Alignment.Center)
                     .border(2.dp, Color.White, RoundedCornerShape(12.dp))
             )
-            Text(
-                text = "Scan a Nostr address",
-                style = MaterialTheme.typography.titleSmallEmphasized,
-                color = Color.White,
-                modifier = Modifier
-                    .align(Alignment.BottomCenter)
-                    .padding(bottom = 64.dp)
-            )
         }
     }
 }

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

@@ -1,26 +1,18 @@
 package su.reya.coop.screens
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import kotlinx.coroutines.launch
 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 viewModel = LocalNostrViewModel.current
+fun UpdateProfileScreen(viewModel: AccountViewModel) {
     val navigator = LocalNavigator.current
-    val scope = rememberCoroutineScope()
-
-    val currentUser = viewModel.currentUser() ?: return
-    val metadata by viewModel.getMetadata(currentUser).collectAsState(initial = null)
-    val isBusy by viewModel.isBusy.collectAsStateWithLifecycle(false)
-
-    val profile = metadata?.asRecord()
+    val currentUser by viewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val profile = currentUser?.metadata?.asRecord()
+    val isUpdatingProfile by viewModel.isUpdatingProfile.collectAsStateWithLifecycle()
 
     ProfileEditor(
         title = "Update profile",
@@ -28,13 +20,11 @@ fun UpdateProfileScreen() {
         initialName = profile?.displayName ?: profile?.name ?: "",
         initialBio = profile?.about ?: "",
         initialPicture = profile?.picture,
-        isBusy = isBusy,
+        isBusy = isUpdatingProfile,
         onBack = { navigator.goBack() },
         onConfirm = { name, bio, bytes, type ->
-            scope.launch {
-                viewModel.updateProfile(name, bio, bytes, type)
-                navigator.goBack()
-            }
+            viewModel.updateProfile(name, bio, bytes, type)
+            navigator.goBack()
         }
     )
-}
+}

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

@@ -0,0 +1,172 @@
+package su.reya.coop.screens.chat
+
+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.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialShapes
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.toShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+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.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 org.jetbrains.compose.resources.painterResource
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.Timestamp
+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(viewModel: AccountViewModel, room: Room) {
+    val pubkey = room.members.firstOrNull() ?: return
+
+    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) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsStateWithLifecycle()
+
+    LaunchedEffect(pubkey) {
+        // 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(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp)
+            .padding(top = 48.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Column(
+            modifier = Modifier.fillMaxWidth(),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Avatar(
+                picture = profile?.picture,
+                description = "Profile picture",
+                modifier = Modifier.size(120.dp),
+                shape = MaterialShapes.Cookie12Sided.toShape(),
+            )
+            Column(
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+                horizontalAlignment = Alignment.CenterHorizontally,
+            ) {
+                Text(
+                    text = profile?.name ?: "No name",
+                    textAlign = TextAlign.Center,
+                    style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                        fontFamily = getExpressiveFontFamily()
+                    ),
+                )
+                Text(
+                    text = pubkey.short(),
+                    textAlign = TextAlign.Center,
+                    style = MaterialTheme.typography.labelMedium,
+                    color = MaterialTheme.colorScheme.outline
+                )
+            }
+        }
+        Column(
+            modifier = Modifier.fillMaxWidth(),
+            verticalArrangement = Arrangement.spacedBy(4.dp),
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Icon(
+                    painter = painterResource(
+                        if (isContact) Res.drawable.ic_check_circle else Res.drawable.ic_cancel
+                    ),
+                    contentDescription = "Warning",
+                    tint = if (isContact) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error
+                )
+                Text(
+                    text = if (isContact) "Contact" else "Not a contact",
+                    style = MaterialTheme.typography.labelMediumEmphasized
+                )
+            }
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Icon(
+                    painter = painterResource(
+                        if (mutualContacts.isNotEmpty()) Res.drawable.ic_check_circle else Res.drawable.ic_cancel
+                    ),
+                    contentDescription = "Warning",
+                    tint = if (mutualContacts.isNotEmpty()) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error
+                )
+                Text(
+                    text = if (mutualContacts.isEmpty()) "No contacts in common" else "${mutualContacts.size} contacts in common",
+                    style = MaterialTheme.typography.labelMediumEmphasized
+                )
+            }
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Icon(
+                    painter = painterResource(Res.drawable.ic_check_circle),
+                    contentDescription = "Warning",
+                    tint = if (lastActivity != null) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.outline
+                )
+                Text(
+                    text = if (lastActivity == null) "Don't have any public activities" else "Last activity at ${lastActivity?.humanReadable()}",
+                    style = MaterialTheme.typography.labelMediumEmphasized
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun DateSeparator(date: String) {
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 16.dp),
+        contentAlignment = Alignment.Center
+    ) {
+        Text(
+            text = date,
+            style = MaterialTheme.typography.labelMedium,
+            color = MaterialTheme.colorScheme.outline
+        )
+    }
+}

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

@@ -0,0 +1,105 @@
+package su.reya.coop.screens.chat
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.layout.Row
+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
+import androidx.compose.material3.IconButtonDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.material3.TextFieldDefaults
+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
+import coop.composeapp.generated.resources.ic_audio
+import coop.composeapp.generated.resources.ic_send
+import org.jetbrains.compose.resources.painterResource
+
+@Composable
+fun ChatInput(
+    value: String,
+    onValueChange: (String) -> Unit,
+    onSend: () -> Unit,
+    onUpload: () -> Unit,
+    onMicClick: () -> Unit
+) {
+    Row(
+        modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+        verticalAlignment = Alignment.Bottom
+    ) {
+        TextField(
+            modifier = Modifier.weight(1f),
+            shape = RoundedCornerShape(28.dp),
+            colors = TextFieldDefaults.colors(
+                focusedIndicatorColor = Color.Transparent,
+                unfocusedIndicatorColor = Color.Transparent
+            ),
+            value = value,
+            onValueChange = onValueChange,
+            placeholder = { Text("Message") },
+            maxLines = 5,
+            keyboardOptions = KeyboardOptions(
+                capitalization = KeyboardCapitalization.Sentences,
+                imeAction = ImeAction.Default
+            ),
+            leadingIcon = {
+                IconButton(onClick = onUpload) {
+                    Icon(
+                        painter = painterResource(Res.drawable.ic_add_circle),
+                        contentDescription = "Upload",
+                    )
+                }
+            },
+        )
+        Spacer(modifier = Modifier.size(8.dp))
+        AnimatedContent(
+            targetState = value.isNotEmpty(),
+            transitionSpec = { (scaleIn() + fadeIn()) togetherWith (scaleOut() + fadeOut()) },
+            label = "send_mic_transition"
+        ) { isNotEmpty ->
+            if (isNotEmpty) {
+                IconButton(
+                    onClick = onSend,
+                    modifier = Modifier.size(56.dp),
+                    colors = IconButtonDefaults.iconButtonColors(
+                        containerColor = MaterialTheme.colorScheme.surfaceVariant,
+                        contentColor = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                ) {
+                    Icon(
+                        painter = painterResource(Res.drawable.ic_send),
+                        contentDescription = "Send"
+                    )
+                }
+            } else {
+                FilledTonalIconButton(
+                    onClick = onMicClick,
+                    modifier = Modifier.size(56.dp),
+                ) {
+                    Icon(
+                        painter = painterResource(Res.drawable.ic_audio),
+                        contentDescription = "Speech to Text"
+                    )
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,196 @@
+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.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.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+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.draw.clip
+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
+import androidx.compose.ui.text.TextLinkStyles
+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 coil3.compose.AsyncImage
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.URL_REGEX
+import su.reya.coop.formatAsTime
+import su.reya.coop.isImageUrl
+import su.reya.coop.removeImageUrls
+
+@Immutable
+data class MessageModel(
+    val id: EventId,
+    val author: PublicKey,
+    val annotatedContent: AnnotatedString,
+    val images: List<String>,
+    val timestamp: String,
+    val isMine: Boolean,
+    val replyEventIds: List<EventId>
+)
+
+@Composable
+fun rememberMessageModel(event: UnsignedEvent, currentUser: PublicKey? = null): MessageModel {
+    return remember(event, currentUser) {
+        val id = event.ensureId().id()!!
+        val isMine = currentUser == event.author()
+        val content = event.content()
+        val replyEventIds = event.tags().eventIds()
+
+        val images = URL_REGEX.findAll(content).map { it.value }.filter { it.isImageUrl() }.toList()
+        val cleanedContent = content.removeImageUrls()
+
+        val annotatedString = buildAnnotatedString {
+            var lastIndex = 0
+            URL_REGEX.findAll(cleanedContent).forEach { matchResult ->
+                append(cleanedContent.substring(lastIndex, matchResult.range.first))
+                val url = matchResult.value
+                pushLink(
+                    LinkAnnotation.Url(
+                        url = url,
+                        styles = TextLinkStyles(
+                            style = SpanStyle(
+                                textDecoration = TextDecoration.Underline,
+                                fontWeight = FontWeight.Medium
+                            )
+                        )
+                    )
+                )
+                append(url)
+                pop()
+                lastIndex = matchResult.range.last + 1
+            }
+            append(cleanedContent.substring(lastIndex))
+        }
+
+        MessageModel(
+            id = id,
+            author = event.author(),
+            annotatedContent = annotatedString,
+            images = images,
+            timestamp = event.createdAt().formatAsTime(),
+            isMine = isMine,
+            replyEventIds = replyEventIds
+        )
+    }
+}
+
+@Composable
+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)
+    } else {
+        RoundedCornerShape(topStart = 4.dp, topEnd = 20.dp, bottomStart = 20.dp, bottomEnd = 20.dp)
+    }
+
+    val containerColor =
+        if (!model.isMine) MaterialTheme.colorScheme.surfaceContainer else MaterialTheme.colorScheme.primaryContainer
+
+    val contentColor =
+        if (!model.isMine) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onPrimaryContainer
+
+    Box(
+        modifier = modifier
+            .onGloballyPositioned { layoutCoordinates = it }
+            .fillMaxWidth()
+            .padding(vertical = 4.dp),
+        contentAlignment = if (model.isMine) Alignment.CenterEnd else Alignment.CenterStart
+    ) {
+        Column(
+            modifier = Modifier.combinedClickable(
+                interactionSource = remember { MutableInteractionSource() },
+                indication = null,
+                onClick = { isMessageClicked = !isMessageClicked },
+                onLongClick = {
+                    layoutCoordinates?.let { coords ->
+                        onLongClick(coords.boundsInWindow())
+                    }
+                }
+            ),
+            horizontalAlignment = if (model.isMine) Alignment.End else Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(4.dp)
+        ) {
+            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
+                    )
+                }
+            }
+            AnimatedVisibility(
+                visible = isMessageClicked,
+                enter = fadeIn() + expandVertically(),
+                exit = fadeOut() + shrinkVertically()
+            ) {
+                Text(
+                    text = model.timestamp,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.outline,
+                    modifier = Modifier.align(
+                        if (model.isMine) Alignment.End else Alignment.Start
+                    )
+                )
+            }
+        }
+    }
+}

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

@@ -0,0 +1,596 @@
+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
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+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
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+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.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.UnsignedEvent
+import su.reya.coop.LocalNavigator
+import su.reya.coop.LocalProfileCache
+import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.RoomUiState
+import su.reya.coop.Screen
+import su.reya.coop.flow
+import su.reya.coop.formatAsGroup
+import su.reya.coop.shared.Avatar
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatScreenViewModel
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+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 profileCache = LocalProfileCache.current
+    val scope = rememberCoroutineScope()
+    val listState = rememberLazyListState()
+
+    val currentUser by viewModel.currentUser.collectAsStateWithLifecycle()
+    val pubkey = currentUser?.publicKey
+
+    val room by viewModel.room.collectAsStateWithLifecycle()
+    val roomState by room.flow(profileCache, pubkey).collectAsStateWithLifecycle(RoomUiState())
+
+    val loading = viewModel.loading
+    val newOtherMessages = viewModel.newOtherMessages
+    val requireScreening = viewModel.requireScreening
+    val messages = viewModel.messages
+
+    val groupedMessages =
+        remember { derivedStateOf { messages.groupBy { it.createdAt().formatAsGroup() } } }
+
+    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 sendFile = { uri: Uri ->
+        scope.launch {
+            // 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)
+        }
+    }
+
+    val fileLauncher =
+        rememberLauncherForActivityResult(ActivityResultContracts.GetContent()) { uri ->
+            uri?.let { sendFile(it) }
+        }
+
+    val sttLauncher =
+        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+            if (result.resultCode == Activity.RESULT_OK) {
+                val data = result.data
+                val results = data?.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)
+                if (!results.isNullOrEmpty()) text = results[0]
+            }
+        }
+
+    LaunchedEffect(messages.size) {
+        if (messages.isNotEmpty()) {
+            listState.animateScrollToItem(0)
+        }
+    }
+
+    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()))
+                                }
+                            }
+                        ) {
+                            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())
+                                    }
+                                }
+                            }
+                        ) {
+                            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(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(bottom = innerPadding.calculateBottomPadding())
+                    ) {
+                        if (requireScreening) {
+                            ScreenerCard(accountViewModel, room)
+                        }
+
+                        when (messages.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 model = rememberMessageModel(event, pubkey)
+
+                                            val replyPreview =
+                                                remember(model.replyEventIds, messages.size) {
+                                                    model.replyEventIds.firstOrNull()
+                                                        ?.let { replyId ->
+                                                            messages.find { it.id() == replyId }
+                                                        }
+                                                }
+
+                                            Column(
+                                                modifier = Modifier.fillMaxWidth(),
+                                                verticalArrangement = Arrangement.spacedBy(2.dp)
+                                            ) {
+                                                replyPreview?.let {
+                                                    ReplyPreview(it, model.isMine)
+                                                }
+                                                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
+                                        )
+                                    }
+                                }
+                            }
+                        }
+
+                        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,
+                                        )
+                                    }
+                                    FilledTonalButton(
+                                        onClick = { viewModel.requireScreening = false },
+                                        modifier = Modifier
+                                            .weight(1f)
+                                            .size(ButtonDefaults.MediumContainerHeight)
+                                    ) {
+                                        Text(
+                                            text = "Accept",
+                                            style = MaterialTheme.typography.titleMedium,
+                                        )
+                                    }
+                                }
+                            }
+
+                            else -> {
+                                replyingTo?.let {
+                                    ReplyBox(it) { replyingTo = null }
+                                }
+                                ChatInput(
+                                    value = text,
+                                    onValueChange = { text = it },
+                                    onSend = {
+                                        viewModel.sendMessage(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")
+                                            }
+                                        }
+                                    }
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+        )
+
+        AnimatedVisibility(
+            visible = selectedMessage != null,
+            enter = fadeIn(),
+            exit = fadeOut()
+        ) {
+            val (model, bounds) = selectedMessage ?: return@AnimatedVisibility
+
+            val density = LocalDensity.current
+            val windowInfo = LocalWindowInfo.current
+            val windowHeight = windowInfo.containerSize.height
+            val scrollState = rememberScrollState()
+
+            var menuHeight by remember { mutableFloatStateOf(0f) }
+            val spacing = with(density) { 12.dp.toPx() }
+            val showAbove =
+                (windowHeight - bounds.bottom) < (menuHeight + spacing) && bounds.top > (menuHeight + spacing)
+
+            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
+                val contentBottom = with(density) { (bounds.bottom + totalExtraHeight).toDp() }
+
+                Spacer(modifier = Modifier.height(contentBottom + 200.dp))
+
+                ChatMessage(
+                    model = model,
+                    modifier = Modifier
+                        .offset { IntOffset(0, bounds.top.toInt()) }
+                        .padding(horizontal = 16.dp)
+                )
+
+                val menuOffset = if (showAbove) {
+                    bounds.top - menuHeight - spacing
+                } else {
+                    bounds.bottom + spacing
+                }
+
+                Box(
+                    modifier = Modifier
+                        .offset { IntOffset(0, menuOffset.toInt().coerceAtLeast(0)) }
+                        .onGloballyPositioned { menuHeight = it.size.height.toFloat() }
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp),
+                    contentAlignment = if (model.isMine) Alignment.CenterEnd else Alignment.CenterStart
+                ) {
+                    ContextMenu { 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) {
+    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),
+            color = MaterialTheme.colorScheme.tertiaryContainer,
+            shape = bubbleShape,
+        ) {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+            ) {
+                Text(
+                    text = profile?.name ?: "Unknown",
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onTertiaryContainer.copy(
+                        alpha = 0.6f
+                    ),
+                )
+                Text(
+                    text = event.content(),
+                    style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onTertiaryContainer,
+                    maxLines = 1,
+                )
+            }
+        }
+    }
+}
+
+@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,
+        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/ProfileEditor.kt

@@ -38,6 +38,7 @@ 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
@@ -53,7 +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.CoroutineScope
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -70,11 +71,14 @@ fun ProfileEditor(
     initialPicture: Any? = null, // Accepts Uri (picked) or String (current URL)
     isBusy: Boolean = false,
     onBack: () -> Unit,
-    onConfirm: (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
     val focusManager = LocalFocusManager.current
+    val scope = rememberCoroutineScope()
+
     var name by remember(initialName) { mutableStateOf(initialName) }
     var bio by remember(initialBio) { mutableStateOf(initialBio) }
     var picture by remember(initialPicture) { mutableStateOf(initialPicture) }
@@ -264,16 +268,19 @@ fun ProfileEditor(
                             .fillMaxWidth()
                             .size(ButtonDefaults.MediumContainerHeight),
                         onClick = {
-                            val scope = CoroutineScope(Dispatchers.Main)
                             scope.launch {
-                                val bytes = withContext(Dispatchers.IO) {
-                                    (picture as? Uri)?.let {
-                                        context.contentResolver.openInputStream(it)?.readBytes()
+                                try {
+                                    val bytes = withContext(ioDispatcher) {
+                                        (picture as? Uri)?.let {
+                                            context.contentResolver.openInputStream(it)?.readBytes()
+                                        }
                                     }
+                                    val type =
+                                        (picture as? Uri)?.let { context.contentResolver.getType(it) }
+                                    onConfirm(name, bio, bytes, type)
+                                } catch (e: Exception) {
+                                    snackbarHostState.showSnackbar(e.message ?: "Error")
                                 }
-                                val type =
-                                    (picture as? Uri)?.let { context.contentResolver.getType(it) }
-                                onConfirm(name, bio, bytes, type)
                             }
                         },
                         enabled = name.isNotBlank() && !isBusy

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

@@ -1,40 +0,0 @@
-package su.reya.coop.shared
-
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.map
-import su.reya.coop.NostrViewModel
-import su.reya.coop.Room
-import su.reya.coop.short
-
-fun Room.displayNameFlow(viewModel: NostrViewModel): Flow<String> {
-    // Return early if there's a custom subject/room name
-    subject?.takeIf { it.isNotBlank() }?.let { return flowOf(it) }
-
-    val displayMembers = if (isGroup()) members.take(2) else members.take(1)
-    if (displayMembers.isEmpty()) return flowOf("Unknown")
-
-    return combine(displayMembers.map { viewModel.getMetadata(it) }) { metadataArray ->
-        val names = metadataArray.mapIndexed { i, metadata ->
-            val profile = metadata?.asRecord()
-            profile?.name?.takeIf { it.isNotBlank() }
-                ?: profile?.displayName?.takeIf { it.isNotBlank() }
-                ?: displayMembers[i].short()
-        }
-
-        if (isGroup()) {
-            val combined = names.joinToString(", ")
-            val extraCount = members.size - names.size
-            if (extraCount > 0) "$combined, +$extraCount" else combined
-        } else {
-            val name = names.first()
-            if (displayMembers.first() == viewModel.currentUser()) "$name (you)" else name
-        }
-    }
-}
-
-fun Room.pictureFlow(viewModel: NostrViewModel): Flow<String?> {
-    val firstMember = members.firstOrNull() ?: return flowOf(null)
-    return viewModel.getMetadata(firstMember).map { it?.asRecord()?.picture }
-}

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
-    }
-}

gradle/libs.versions.toml

@@ -10,14 +10,14 @@ androidx-espresso = "3.7.0"
 androidx-lifecycle = "2.10.0"
 androidx-testExt = "1.3.0"
 androidx-splashscreen = "1.2.0"
-composeMultiplatform = "1.11.0"
+composeMultiplatform = "1.11.1"
 datastorePreferences = "1.2.1"
 junit = "4.13.2"
-kotlin = "2.3.21"
+kotlin = "2.4.0"
 kotlinx-serialization = "1.11.0"
 material3 = "1.11.0-alpha07"
 multiplatform-nav3-ui = "1.1.1"
-ktor = "3.5.0"
+ktor = "3.5.1"
 
 [libraries]
 androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastorePreferences" }

shared/build.gradle.kts

@@ -3,6 +3,8 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
+    alias(libs.plugins.composeMultiplatform)
+    alias(libs.plugins.composeCompiler)
     kotlin("plugin.serialization") version libs.versions.kotlin.get()
 }
 
@@ -31,10 +33,12 @@ kotlin {
             implementation(libs.ktor.serialization.kotlinx.json)
             implementation(libs.androidx.lifecycle.viewmodelCompose)
             implementation(libs.androidx.lifecycle.runtimeCompose)
-            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
+            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.2.6")
-            implementation("com.squareup.okio:okio:3.16.2")
+            implementation("su.reya:nostr-sdk-kmp:0.3.2")
+            implementation("com.squareup.okio:okio:3.17.0")
         }
         androidMain.dependencies {
             implementation(libs.ktor.client.okhttp)

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/Extensions.kt

@@ -0,0 +1,24 @@
+package su.reya.coop
+
+import rust.nostr.sdk.PublicKey
+
+val URL_REGEX = Regex("(https?://\\S+)", RegexOption.IGNORE_CASE)
+private val imageExtensions = setOf("jpg", "jpeg", "png", "gif", "webp", "bmp", "avif")
+
+fun String.removeImageUrls(): String {
+    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/Nostr.kt

@@ -1,903 +0,0 @@
-package su.reya.coop
-
-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.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.supervisorScope
-import rust.nostr.sdk.AckPolicy
-import rust.nostr.sdk.Alphabet
-import rust.nostr.sdk.AsyncNostrSigner
-import rust.nostr.sdk.Client
-import rust.nostr.sdk.ClientBuilder
-import rust.nostr.sdk.ClientNotification
-import rust.nostr.sdk.Contact
-import rust.nostr.sdk.Event
-import rust.nostr.sdk.EventBuilder
-import rust.nostr.sdk.EventId
-import rust.nostr.sdk.Filter
-import rust.nostr.sdk.GossipConfig
-import rust.nostr.sdk.Keys
-import rust.nostr.sdk.Kind
-import rust.nostr.sdk.KindStandard
-import rust.nostr.sdk.LogLevel
-import rust.nostr.sdk.Metadata
-import rust.nostr.sdk.MetadataRecord
-import rust.nostr.sdk.Nip05Address
-import rust.nostr.sdk.Nip05Profile
-import rust.nostr.sdk.NostrDatabase
-import rust.nostr.sdk.NostrGossip
-import rust.nostr.sdk.PublicKey
-import rust.nostr.sdk.RelayCapabilities
-import rust.nostr.sdk.RelayMessageEnum
-import rust.nostr.sdk.RelayMetadata
-import rust.nostr.sdk.RelayStatus
-import rust.nostr.sdk.RelayUrl
-import rust.nostr.sdk.ReqExitPolicy
-import rust.nostr.sdk.ReqTarget
-import rust.nostr.sdk.SendEventTarget
-import rust.nostr.sdk.SignerAuthenticator
-import rust.nostr.sdk.SingleLetterTag
-import rust.nostr.sdk.SleepWhenIdle
-import rust.nostr.sdk.SubscribeAutoCloseOptions
-import rust.nostr.sdk.Tag
-import rust.nostr.sdk.Timestamp
-import rust.nostr.sdk.UnsignedEvent
-import rust.nostr.sdk.UnwrappedGift
-import rust.nostr.sdk.extractRelayList
-import rust.nostr.sdk.initLogger
-import rust.nostr.sdk.nip17ExtractRelayList
-import rust.nostr.sdk.nip59MakeGiftWrapAsync
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
-
-object NostrManager {
-    val instance = Nostr()
-
-    val BOOTSTRAP_RELAYS = listOf(
-        "wss://relay.primal.net",
-        "wss://purplepag.es"
-    )
-
-    val INDEXER_RELAY = listOf(
-        "wss://indexer.coracle.social",
-    )
-
-    val ALL_RELAYS = BOOTSTRAP_RELAYS + INDEXER_RELAY
-}
-
-class Nostr {
-    var client: Client? = null
-        private set
-    var signer: UniversalSigner = UniversalSigner(Keys.generate())
-        private set
-    var deviceSigner: AsyncNostrSigner? = null
-        private set
-    var sentEvents: MutableMap<EventId, List<RelayUrl>> = mutableMapOf()
-        private set
-    var rumorMap: MutableMap<EventId, EventId> = mutableMapOf()
-        private set
-
-    private val isInitialized = MutableStateFlow(false)
-
-    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
-    val newEvents = _newEvents.asSharedFlow()
-
-    private val _metadataUpdates =
-        MutableSharedFlow<Pair<PublicKey, Metadata>>(extraBufferCapacity = 100)
-    val metadataUpdates = _metadataUpdates.asSharedFlow()
-
-    private val _contactListUpdates = MutableSharedFlow<List<PublicKey>>(extraBufferCapacity = 100)
-    val contactListUpdates = _contactListUpdates.asSharedFlow()
-
-    private val _subscriptionClosed = MutableSharedFlow<Unit>(extraBufferCapacity = 10)
-    val subscriptionClosed = _subscriptionClosed.asSharedFlow()
-
-    suspend fun emitNewEvent(event: UnsignedEvent) = _newEvents.emit(event)
-
-    suspend fun emitSubscriptionClosed() = _subscriptionClosed.emit(Unit)
-
-    suspend fun emitMetadataUpdate(pubkey: PublicKey, metadata: Metadata) =
-        _metadataUpdates.emit(pubkey to metadata)
-
-    suspend fun emitContactListUpdate(contacts: List<PublicKey>) =
-        _contactListUpdates.emit(contacts)
-
-    suspend fun init(
-        dbPath: String,
-        logLevel: LogLevel = LogLevel.WARN
-    ) {
-        try {
-            if (isInitialized.value) return
-
-            // Initialize the logger for nostr client
-            initLogger(logLevel)
-
-            // Initialize configurations for nostr client
-            val lmdb = NostrDatabase.lmdb(dbPath)
-            val gossip = NostrGossip.inMemory()
-            val authenticator = SignerAuthenticator(signer)
-            val idleTimeout = Duration.parse("5m")
-
-            client =
-                ClientBuilder()
-                    .authenticator(authenticator)
-                    .database(lmdb)
-                    .gossip(gossip)
-                    .gossipConfig(
-                        GossipConfig()
-                            .noBackgroundRefresh()
-                            .fetchTimeout(Duration.parse("2s"))
-                    )
-                    .verifySubscriptions(false)
-                    .sleepWhenIdle(SleepWhenIdle.Enabled(idleTimeout))
-                    .build()
-
-            isInitialized.value = true
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to initialize Nostr client: ${e.message}", e)
-        }
-    }
-
-    suspend fun waitUntilInitialized() {
-        isInitialized.first { it }
-    }
-
-    suspend fun connectBootstrapRelays() {
-        NostrManager.BOOTSTRAP_RELAYS.forEach { url ->
-            client?.addRelay(RelayUrl.parse(url))
-        }
-        NostrManager.INDEXER_RELAY.forEach { url ->
-            client?.addRelay(
-                url = RelayUrl.parse(url),
-                capabilities = RelayCapabilities.gossip()
-            )
-        }
-        // Connect to all bootstrap relays
-        client?.connect()
-    }
-
-    suspend fun reconnect() {
-        NostrManager.ALL_RELAYS.forEach { url ->
-            try {
-                client?.relay(RelayUrl.parse(url)).let { relay ->
-                    if (relay != null) {
-                        if (relay.status() != RelayStatus.CONNECTED) {
-                            relay.connect()
-                        }
-                    }
-                }
-            } catch (e: Exception) {
-                println("Failed to reconnect relay: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun disconnect() {
-        NostrManager.ALL_RELAYS.forEach { url ->
-            try {
-                client?.disconnectRelay(RelayUrl.parse(url))
-            } catch (e: Exception) {
-                println("Failed to disconnect relay: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun exit() {
-        signer.switch(Keys.generate())
-        deviceSigner = null
-    }
-
-    suspend fun setSigner(new: AsyncNostrSigner) {
-        try {
-            signer.switch(new)
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to set signer: ${e.message}", e)
-        }
-    }
-
-    fun isSignedByUser(event: Event): Boolean {
-        return try {
-            signer.currentUser == event.author()
-        } catch (e: Exception) {
-            println("Failed to check if event is signed by user: ${e.message}")
-            false
-        }
-    }
-
-    suspend fun getUserMetadata() {
-        try {
-            val author = signer.currentUser ?: throw IllegalStateException("User not signed in")
-
-            // Get the latest metadata event
-            val metadataFilter =
-                Filter().kind(Kind.fromStd(KindStandard.METADATA)).author(author).limit(1u)
-
-            // Get the latest contact list event
-            val contactFilter =
-                Filter().kind(Kind.fromStd(KindStandard.CONTACT_LIST)).author(author).limit(1u)
-
-            // Get the latest messaging relay list event
-            val msgRelayFilter =
-                Filter().kind(Kind.fromStd(KindStandard.INBOX_RELAYS)).author(author).limit(1u)
-
-            // Construct a target that includes all filters
-            val target = ReqTarget.auto(listOf(metadataFilter, contactFilter, msgRelayFilter))
-            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
-
-            client?.subscribe(target = target, id = "user-metadata", closeOn = opts)
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to fetch user metadata: ${e.message}", e)
-        }
-    }
-
-    suspend fun getUserMessages(msgRelayList: Event) {
-        try {
-            val author = signer.currentUser ?: throw IllegalStateException("User not signed in")
-            val relays = nip17ExtractRelayList(msgRelayList)
-
-            // Ensure relay connections
-            relays.forEach { relay ->
-                client?.addRelay(relay)
-                client?.connectRelay(relay)
-            }
-
-            // Construct a filter for gift wrap events
-            val filter = Filter().kind(Kind.fromStd(KindStandard.GIFT_WRAP)).pubkey(author)
-            val target = mutableMapOf<RelayUrl, List<Filter>>()
-            relays.forEach { relay ->
-                target[relay] = listOf(filter)
-            }
-
-            client?.subscribe(
-                target = ReqTarget.manual(target),
-                id = "gift-wraps"
-            )
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to fetch user messages: ${e.message}", e)
-        }
-    }
-
-    suspend fun handleNotifications(
-        onMetadataUpdate: (PublicKey, Metadata) -> Unit,
-        onContactListUpdate: (List<PublicKey>) -> Unit,
-        onNewMessage: (UnsignedEvent) -> Unit,
-        onSubscriptionClose: () -> Unit,
-    ) = supervisorScope {
-        val now = Timestamp.now()
-        val processedEvent = mutableSetOf<EventId>()
-        val notifications = client?.notifications() ?: return@supervisorScope
-
-        var eoseTrackerJob: Job? = null
-
-        while (true) {
-            val notification = notifications.next() ?: continue
-
-            when (notification) {
-                is ClientNotification.Message -> {
-                    val relayUrl = notification.relayUrl
-
-                    when (val message = notification.message.asEnum()) {
-                        is RelayMessageEnum.EventMsg -> {
-                            val event = message.event
-
-                            // Prevent processing duplicate events
-                            if (processedEvent.contains(event.id())) continue
-                            processedEvent.add(event.id())
-
-                            if (event.kind().asStd()?.equals(KindStandard.METADATA) == true) {
-                                try {
-                                    val metadata = Metadata.fromJson(event.content())
-                                    onMetadataUpdate(event.author(), metadata)
-                                } catch (e: Exception) {
-                                    println("Failed to parse metadata: $e")
-                                }
-                            }
-
-                            if (event.kind().asStd()?.equals(KindStandard.CONTACT_LIST) == true) {
-                                if (isSignedByUser(event = event)) {
-                                    onContactListUpdate(event.tags().publicKeys())
-                                }
-                            }
-
-                            if (event.kind().asStd()?.equals(KindStandard.INBOX_RELAYS) == true) {
-                                // Get all gift wrap events for the current user
-                                if (isSignedByUser(event = event)) {
-                                    getUserMessages(msgRelayList = event)
-                                }
-                            }
-
-                            if (event.kind().asStd()?.equals(KindStandard.GIFT_WRAP) == true) {
-                                try {
-                                    val rumor = extractRumor(event)
-
-                                    // Logic to notify UI after processing
-                                    // Cancel previous tracker if it exists
-                                    eoseTrackerJob?.cancel()
-                                    // Start a new tracker
-                                    eoseTrackerJob = launch {
-                                        delay(10000.milliseconds) // Wait for 10 seconds
-                                        onSubscriptionClose()
-                                    }
-
-                                    // Handle new message
-                                    rumor?.createdAt()?.asSecs()?.let {
-                                        if (it >= now.asSecs()) {
-                                            onNewMessage(rumor)
-                                        }
-                                    }
-                                } catch (e: Exception) {
-                                    println("Failed to extract rumor: $e")
-                                }
-                            }
-                        }
-
-                        is RelayMessageEnum.EndOfStoredEvents -> {
-                            val subscriptionId = message.subscriptionId
-
-                            if (subscriptionId == "gift-wraps") {
-                                onSubscriptionClose()
-                            }
-                        }
-
-                        is RelayMessageEnum.Ok -> {
-                            if (sentEvents.containsKey(message.eventId)) {
-                                val currentRelays = sentEvents[message.eventId] ?: emptyList()
-                                sentEvents[message.eventId] = currentRelays + relayUrl
-                            }
-                        }
-
-                        else -> {
-                            /* Ignore other message types */
-                        }
-                    }
-                }
-
-                is ClientNotification.Shutdown -> {
-                    break
-                }
-
-                else -> {
-                    /* Ignore other message types */
-                }
-            }
-        }
-    }
-
-    private suspend fun getCachedRumor(giftId: EventId): UnsignedEvent? {
-        try {
-            val filter = Filter().identifier(giftId.toHex())
-            val event = client?.database()?.query(filter)?.first()
-
-            return event?.content()?.let { UnsignedEvent.fromJson(it) }
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to get cached rumor: ${e.message}", e)
-        }
-    }
-
-    private suspend fun setCachedRumor(giftId: EventId, rumor: UnsignedEvent) {
-        try {
-            val currentUser =
-                signer.currentUser ?: throw IllegalStateException("User not signed in")
-
-            // Construct the room id
-            val roomId = rumor.roomId()
-
-            // Construct reference tags
-            val tags = listOf(
-                Tag.identifier(giftId.toHex()),
-                Tag.event(rumor.id()!!),
-                Tag.custom("a", listOf(roomId.toString())),
-                Tag.custom("k", listOf("14"))
-            )
-
-            // Set event kind
-            val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA);
-
-            val event = EventBuilder(kind, rumor.asJson())
-                .tags(tags)
-                .finalizeUnsigned(currentUser)
-                .signAsync(Keys.generate())
-
-            client?.database()?.saveEvent(event)
-        } catch (e: Exception) {
-            println("Failed to set cached rumor: ${e.message}")
-        }
-    }
-
-    private suspend fun extractRumor(event: Event): UnsignedEvent? {
-        // Check if the rumor is already cached
-        val cachedRumor = getCachedRumor(event.id())
-        if (cachedRumor != null) return cachedRumor
-
-        // Get all signers
-        val signers = listOfNotNull(signer, deviceSigner)
-        if (signers.isEmpty()) return null
-
-        // Try to unwrap the gift with each signer
-        for (signer in signers) {
-            try {
-                val gift = UnwrappedGift.fromGiftWrapAsync(signer = signer, giftWrap = event)
-                val rumor = gift.rumor()
-                // Save the rumor to the database
-                setCachedRumor(event.id(), rumor)
-                // Return the rumor
-                return rumor
-            } catch (e: Exception) {
-                println("Failed to unwrap gift: ${e.message}")
-                continue
-            }
-        }
-
-        return null
-    }
-
-    private suspend fun getDefaultRelayList(): Map<RelayUrl, RelayMetadata> {
-        // Construct a list of relays
-        val relayList = mapOf<RelayUrl, RelayMetadata>(
-            RelayUrl.parse("wss://relay.damus.io") to RelayMetadata.READ,
-            RelayUrl.parse("wss://relay.primal.net") to RelayMetadata.READ,
-            RelayUrl.parse("wss://relay.nostr.net") to RelayMetadata.WRITE,
-            RelayUrl.parse("wss://nostr.superfriends.online") to RelayMetadata.WRITE
-        )
-
-        // Ensure all relays are added and connected
-        relayList.forEach { (relay, metadata) ->
-            client?.addRelay(
-                url = relay,
-                capabilities =
-                    if (metadata == RelayMetadata.READ) RelayCapabilities.read()
-                    else if (metadata == RelayMetadata.WRITE) RelayCapabilities.write()
-                    else RelayCapabilities.none()
-            )
-            client?.connectRelay(relay)
-        }
-
-        return relayList
-    }
-
-    suspend fun getDefaultMsgRelayList(): List<RelayUrl> {
-        // Construct a list of messaging relays
-        val msgRelayList = listOf(
-            RelayUrl.parse("wss://relay.0xchat.com"),
-            RelayUrl.parse("wss://nip17.com"),
-        )
-
-        // Ensure all relays are added and connected
-        msgRelayList.forEach { relay ->
-            client?.addRelay(relay, RelayCapabilities.none())
-            client?.connectRelay(relay)
-        }
-
-        return msgRelayList
-    }
-
-    suspend fun createIdentity(keys: Keys, name: String, bio: String?, picture: String?) {
-        // Send relay list event
-        val relayList = getDefaultRelayList()
-        val relayListEvent = EventBuilder.relayList(relayList).finalizeAsync(keys);
-
-        client?.sendEvent(
-            event = relayListEvent,
-            target = SendEventTarget.broadcast(),
-            ackPolicy = AckPolicy.all(),
-            okTimeout = Duration.parse("3s")
-        )
-
-        // Send messaging relay list event
-        val msgRelayList = getDefaultMsgRelayList()
-        val msgRelayListEvent = EventBuilder.nip17RelayList(msgRelayList).finalizeAsync(keys)
-
-        client?.sendEvent(
-            event = msgRelayListEvent,
-            target = SendEventTarget.toNip65(),
-            ackPolicy = AckPolicy.none()
-        )
-
-        // Send metadata event
-        val metadata =
-            Metadata.fromRecord(MetadataRecord(displayName = name, about = bio, picture = picture))
-        val metadataEvent = EventBuilder.metadata(metadata).finalizeAsync(keys)
-
-        client?.sendEvent(
-            event = metadataEvent,
-            target = SendEventTarget.broadcast(),
-            ackPolicy = AckPolicy.none()
-        )
-
-        // Send contact list event
-        val defaultContact =
-            Contact(PublicKey.parse("npub1j3rz3ndl902lya6ywxvy5c983lxs8mpukqnx4pa4lt5wrykwl5ys7wpw3x"))
-        val contactListEvent = EventBuilder.contactList(listOf(defaultContact)).finalizeAsync(keys)
-
-        client?.sendEvent(
-            event = contactListEvent,
-            target = SendEventTarget.toNip65(),
-            ackPolicy = AckPolicy.none()
-        )
-
-        setSigner(keys)
-    }
-
-    suspend fun updateProfile(
-        name: String? = null,
-        bio: String? = null,
-        picture: String? = null
-    ): Metadata {
-        val currentUser = signer.currentUser ?: 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)
-
-            client?.sendEvent(
-                event = event,
-                target = SendEventTarget.broadcast(),
-                ackPolicy = AckPolicy.none()
-            )
-
-            return newMetadata
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to update identity: ${e.message}", e)
-        }
-    }
-
-    private suspend fun getLatestMetadata(pubkey: PublicKey): Metadata? {
-        return try {
-            val kind = Kind.fromStd(KindStandard.METADATA);
-            val filter = Filter().kind(kind).author(pubkey).limit(1u)
-            val event = client?.database()?.query(filter)?.first() ?: return null
-
-            Metadata.fromJson(event.content())
-        } catch (e: Exception) {
-            println("Failed to get latest metadata: ${e.message}")
-            null
-        }
-    }
-
-    suspend fun getAllCacheMetadata(): Map<PublicKey, Metadata> {
-        try {
-            val filter = Filter().kind(Kind.fromStd(KindStandard.METADATA)).limit(100u)
-            val events = client?.database()?.query(filter)
-            val results = mutableMapOf<PublicKey, Metadata>()
-
-            events?.toVec()?.forEach { event ->
-                try {
-                    val metadata = Metadata.fromJson(event.content())
-                    results[event.author()] = metadata
-                } catch (e: Exception) {
-                    println("Failed to parse metadata: $e")
-                }
-            }
-
-            return results
-        } catch (e: Exception) {
-            println("Failed to get all cache metadata: ${e.message}")
-            return emptyMap()
-        }
-    }
-
-    suspend fun fetchMetadataBatch(keys: List<PublicKey>) {
-        try {
-            val limit = keys.size.toULong() * 4u;
-            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
-
-            // Construct a filter for metadata events
-            val filter = Filter()
-                .kind(Kind.fromStd(KindStandard.METADATA))
-                .authors(keys)
-                .limit(limit)
-
-            // Construct a target that includes all filters
-            val target =
-                ReqTarget.manual(
-                    mapOf(
-                        RelayUrl.parse("wss://purplepag.es") to listOf(filter),
-                        RelayUrl.parse("wss://relay.primal.net") to listOf(filter),
-                    )
-                )
-
-            client?.subscribe(target = target, closeOn = opts)
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to fetch metadata batch: ${e.message}", e)
-        }
-    }
-
-    suspend fun setMsgRelays(urls: List<RelayUrl>) {
-        try {
-            val event = EventBuilder.nip17RelayList(urls).finalizeAsync(signer)
-
-            client?.sendEvent(
-                event = event,
-                target = SendEventTarget.toNip65(),
-                ackPolicy = AckPolicy.none(),
-            )
-
-            val kind = Kind.fromStd(KindStandard.INBOX_RELAYS);
-            val filter = Filter().kind(kind).author(signer.currentUser!!).limit(1u)
-            val target = ReqTarget.auto(listOf(filter))
-            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
-
-            client?.subscribe(target = target, closeOn = opts)
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to set msg relays: ${e.message}", e)
-        }
-    }
-
-    suspend fun getMsgRelays(publicKey: PublicKey): List<RelayUrl> {
-        try {
-            val kind = Kind.fromStd(KindStandard.INBOX_RELAYS)
-            val filter = Filter().kind(kind).author(publicKey).limit(1u)
-            val events = client?.database()?.query(filter)
-
-            return nip17ExtractRelayList(events?.toVec()?.firstOrNull() ?: return emptyList())
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to get 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 getChatRooms(): Set<Room>? {
-        try {
-            val userPubkey = signer.currentUser ?: throw IllegalStateException("User not signed in")
-            val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA)
-            val kTag = SingleLetterTag.lowercase(Alphabet.K)
-
-            // Get all events sent by the user
-            val filter = Filter().kind(kind).author(userPubkey).customTags(kTag, listOf("14", "dm"))
-            val events = client?.database()?.query(filter)
-
-            // Collect rooms
-            val roomsMap: MutableMap<Long, Room> = 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]
-
-                    // Check if the room already exists
-                    if (existingRoom == null || newRoom.createdAt.asSecs() > existingRoom.createdAt.asSecs()) {
-                        val filter =
-                            Filter().kind(kind).author(userPubkey).pubkeys(newRoom.members.toList())
-
-                        // Determine if it's an ongoing room
-                        val isOngoing = client?.database()?.query(filter)?.isEmpty() == false
-
-                        // Append room to map
-                        roomsMap[newRoom.id] =
-                            if (isOngoing) newRoom.copy(kind = RoomKind.Ongoing) else newRoom
-                    }
-                }
-
-            return roomsMap.values.sortedByDescending { it.createdAt.asSecs() }.toSet()
-        } catch (e: Exception) {
-            println("Failed to get chat rooms: ${e.message}")
-            return null
-        }
-    }
-
-    suspend fun getChatRoomMessages(roomId: Long): List<UnsignedEvent> {
-        try {
-            val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA)
-            val filter = Filter().kind(kind).reference(roomId.toString())
-            val events = client?.database()?.query(filter)
-
-            // Merge the events
-            return events
-                ?.toVec()
-                ?.map { UnsignedEvent.fromJson(it.content()) }
-                // Filter out events without public keys (receivers)
-                ?.filter { it.tags().publicKeys().isNotEmpty() }
-                ?.sortedByDescending { it.createdAt().asSecs() } ?: emptyList()
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to get chat room messages: ${e.message}", e)
-        }
-    }
-
-    suspend fun chatRoomConnect(members: List<PublicKey>): Map<PublicKey, List<RelayUrl>> {
-        try {
-            val results = mutableMapOf<PublicKey, MutableList<RelayUrl>>()
-
-            members.forEach { member ->
-                results[member] = mutableListOf<RelayUrl>()
-                val kind = Kind.fromStd(KindStandard.INBOX_RELAYS)
-                val filter = Filter().kind(kind).author(member).limit(1u)
-
-                val stream = client?.streamEvents(
-                    target = ReqTarget.auto(listOf(filter)),
-                    id = "room-${member.toBech32().substring(0, 10)}",
-                    timeout = Duration.parse("3s"),
-                    policy = ReqExitPolicy.ExitOnEose
-                )
-
-                stream?.next()?.let { res ->
-                    if (res.event != null) {
-                        // Connect to the msg relays
-                        connectMsgRelays(res.event!!)
-                        // Mark the member as connected
-                        results[member]?.add(res.relayUrl)
-                    }
-                }
-            }
-
-            return results
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to fetch relays: ${e.message}", e)
-        }
-    }
-
-    suspend fun connectMsgRelays(event: Event) {
-        try {
-            val urls = nip17ExtractRelayList(event);
-            for (url in urls) {
-                if (client?.relay(url) == null) {
-                    client?.addRelay(url)
-                    client?.connectRelay(url)
-                }
-            }
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to connect to relays: ${e.message}", e)
-        }
-    }
-
-    suspend fun sendMessage(
-        to: Set<PublicKey>,
-        content: String,
-        subject: String? = null,
-        replies: List<EventId> = emptyList(),
-        onRumorCreated: ((UnsignedEvent) -> Unit)? = null,
-    ) {
-        try {
-            val currentUser =
-                signer.currentUser ?: throw IllegalStateException("User not signed in")
-
-            val tags = mutableListOf<Tag>()
-
-            // Add a subject tag if provided
-            if (subject != null) {
-                tags.add(Tag.custom("subject", listOf(subject)))
-            }
-
-            // Add event tags for replies
-            if (replies.isNotEmpty()) {
-                replies.forEach { replyId ->
-                    tags.add(Tag.event(replyId))
-                }
-            }
-
-            // Add public key tags for each recipient
-            to.forEach { pubkey ->
-                tags.add(Tag.publicKey(pubkey))
-            }
-
-            for (receiver in setOf(currentUser) + to) {
-                // Construct the rumor event
-                // NEVER SIGN this event with the current user signer
-                val rumor = EventBuilder(Kind.fromStd(KindStandard.PRIVATE_DIRECT_MESSAGE), content)
-                    .tags(tags)
-                    .finalizeUnsigned(currentUser)
-
-                // 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 sent events
-                    sentEvents[output.id] = emptyList()
-                    if (rumor.id() != null) rumorMap[rumor.id()!!] = output.id
-
-                    // Collect failed outputs
-                    output.failed.forEach { (relayUrl, reason) ->
-                        println("Failed to send event to relay $relayUrl: $reason")
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to send message: ${e.message}", e)
-        }
-    }
-
-    suspend fun profileFromAddress(client: HttpClient, address: Nip05Address): Nip05Profile {
-        try {
-            val response: HttpResponse = client.get(address.url())
-            val bodyString: String = response.body()
-
-            return Nip05Profile.fromJson(address, bodyString)
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to fetch profile from address: ${e.message}", e)
-        }
-    }
-
-    suspend fun searchByAddress(query: String): PublicKey {
-        try {
-            val address = Nip05Address.parse(query)
-            val profile = profileFromAddress(HttpClient(), address)
-
-            return profile.publicKey()
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to search address: ${e.message}", e)
-        }
-    }
-
-    suspend fun searchByNostr(query: String): List<PublicKey> {
-        try {
-            // Add search relay
-            val searchRelay = RelayUrl.parse("wss://antiprimal.net")
-            if (client?.relay(searchRelay) == null) {
-                client?.addRelay(url = searchRelay, capabilities = RelayCapabilities.read())
-                client?.connectRelay(searchRelay)
-            }
-
-            val kinds = listOf(Kind.fromStd(KindStandard.METADATA))
-            val filter = Filter().kinds(kinds).search(query).limit(10u)
-            val target = ReqTarget.manual(mapOf(searchRelay to listOf(filter)))
-
-            val stream = client?.streamEvents(
-                target = target,
-                id = "search",
-                timeout = Duration.parse("3s"),
-                policy = ReqExitPolicy.ExitOnEose
-            )
-
-            // Collect the results
-            val results = mutableListOf<PublicKey>()
-
-            // Keep searching until the stream is closed or timeout
-            stream?.next()?.let { event ->
-                if (event.event != null) {
-                    results.add(event.event!!.author())
-                }
-            }
-
-            return results
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to search nostr: ${e.message}", e)
-        }
-    }
-}

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

@@ -1,735 +0,0 @@
-package su.reya.coop
-
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.repeatOnLifecycle
-import androidx.lifecycle.viewModelScope
-import io.ktor.client.HttpClient
-import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
-import io.ktor.serialization.kotlinx.json.json
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.receiveAsFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import kotlinx.coroutines.withTimeoutOrNull
-import kotlinx.serialization.json.Json
-import rust.nostr.sdk.AsyncNostrSigner
-import rust.nostr.sdk.EventBuilder
-import rust.nostr.sdk.EventId
-import rust.nostr.sdk.Keys
-import rust.nostr.sdk.Kind
-import rust.nostr.sdk.KindStandard
-import rust.nostr.sdk.Metadata
-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.Tag
-import rust.nostr.sdk.UnsignedEvent
-import su.reya.coop.blossom.BlossomClient
-import su.reya.coop.storage.SecretStorage
-import kotlin.time.Clock
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
-
-class NostrViewModel(
-    private val nostr: Nostr,
-    private val secretStore: SecretStorage,
-    private val externalSignerHandler: ExternalSignerHandler? = null,
-) : ViewModel() {
-    private val _isNotificationBannerDismissed = MutableStateFlow(false)
-    val isNotificationBannerDismissed = _isNotificationBannerDismissed.asStateFlow()
-
-    private val _signerRequired = MutableStateFlow<Boolean?>(null)
-    val signerRequired = _signerRequired.asStateFlow()
-
-    private val _isBusy = MutableStateFlow(false)
-    val isBusy = _isBusy.asStateFlow()
-
-    private val _isPartialProcessedGiftWrap = MutableStateFlow(false)
-    val isPartialProcessedGiftWrap = _isPartialProcessedGiftWrap.asStateFlow()
-
-    private val _isRelayListEmpty = MutableStateFlow(false)
-    val isRelayListEmpty = _isRelayListEmpty.asStateFlow()
-
-    private val _chatRooms = MutableStateFlow<Set<Room>>(emptySet())
-    val chatRooms = _chatRooms.asStateFlow()
-
-    private val _contactList = MutableStateFlow<Set<PublicKey>>(emptySet())
-    val contactList = _contactList.asStateFlow()
-
-    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
-    val newEvents = _newEvents.asSharedFlow()
-
-    private val _sentReports = MutableSharedFlow<Map<EventId, List<RelayUrl>>>()
-    val sentReport = _sentReports.asSharedFlow()
-
-    private val _errorEvents = Channel<String>(Channel.BUFFERED)
-    val errorEvents = _errorEvents.receiveAsFlow()
-
-    private val _metadataStore = mutableMapOf<PublicKey, MutableStateFlow<Metadata?>>()
-    private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
-    private val seenPublicKeys = mutableSetOf<PublicKey>()
-
-    init {
-        // Skip the splash screen if a user is already logged in
-        if (nostr.signer.currentUser != null) {
-            _signerRequired.value = false
-        }
-
-        // Check if the notification banner has been dismissed
-        checkNotificationBannerDismissedStatus()
-
-        // Check local stored secret (secret key or bunker)
-        login()
-
-        // Automatically reconnect bootstrap relays
-        reconnect()
-
-        // Observe the signer state and verify the relay list
-        observeSignerAndCheckRelays()
-
-        // Get all local stored metadata
-        getCacheMetadata()
-    }
-
-    fun bindLifecycle(lifecycle: Lifecycle) {
-        viewModelScope.launch {
-            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                coroutineScope {
-                    launch { refreshChatRooms() }
-                    launch { runObserver() }
-                    launch { runMetadataBatching() }
-                }
-            }
-        }
-    }
-
-    override fun onCleared() {
-        super.onCleared()
-
-        // Disconnect to all bootstrap relays
-        viewModelScope.launch {
-            withContext(NonCancellable) {
-                nostr.disconnect()
-            }
-        }
-    }
-
-    private fun showError(message: String) {
-        viewModelScope.launch {
-            _errorEvents.send(message)
-        }
-    }
-
-    private fun checkNotificationBannerDismissedStatus() {
-        viewModelScope.launch {
-            _isNotificationBannerDismissed.value =
-                secretStore.get("notification_banner_dismissed") == "true"
-        }
-    }
-
-    private fun reconnect() {
-        viewModelScope.launch {
-            nostr.waitUntilInitialized()
-            nostr.reconnect()
-        }
-    }
-
-    private fun processIncomingEvent(event: UnsignedEvent) {
-        val roomId = event.roomId()
-        val existingRoom = _chatRooms.value.firstOrNull { it.id == roomId }
-
-        if (existingRoom == null) {
-            nostr.signer.currentUser?.let { user ->
-                val newRoom = Room.new(event, user)
-                _chatRooms.update { (it + newRoom).sortedDescending().toSet() }
-            }
-        } else {
-            updateRoomList(roomId, event)
-        }
-    }
-
-    private suspend fun runObserver() = coroutineScope {
-        // Observe new messages
-        launch {
-            nostr.newEvents.collect { event ->
-                val roomId = event.roomId()
-                val existingRoom = _chatRooms.value.firstOrNull { it.id == roomId }
-
-                if (existingRoom == null) {
-                    val currentUser = nostr.signer.currentUser
-                    if (currentUser != null) {
-                        val newRoom = Room.new(event, currentUser)
-                        _chatRooms.update { (it + newRoom).sortedDescending().toSet() }
-                    }
-                } else {
-                    updateRoomList(roomId, event)
-                }
-
-                _newEvents.emit(event)
-            }
-        }
-
-        // Observe contact list updates
-        launch {
-            nostr.contactListUpdates.collect { contacts ->
-                _contactList.value = contacts.toSet()
-            }
-        }
-
-        // Observe metadata updates
-        launch {
-            nostr.metadataUpdates.collect { (pubkey, metadata) ->
-                updateMetadata(pubkey, metadata)
-            }
-        }
-
-        // Observes subscription close
-        launch {
-            nostr.subscriptionClosed.collect {
-                getChatRooms()
-                _isPartialProcessedGiftWrap.value = true
-            }
-        }
-    }
-
-    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) {
-            val firstKey = metadataRequestChannel.receive()
-            batch.add(firstKey)
-            val lastFlushTime = Clock.System.now().toEpochMilliseconds()
-
-            while (batch.isNotEmpty()) {
-                val nextKey = withTimeoutOrNull(timeout.milliseconds) {
-                    metadataRequestChannel.receive()
-                }
-
-                // Only add the key 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.fetchMetadataBatch(keysToRequest)
-                }
-            }
-        }
-    }
-
-    private fun getCacheMetadata() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            val results = nostr.getAllCacheMetadata()
-            results.forEach { (pubkey, metadata) ->
-                // Update the metadata state
-                updateMetadata(pubkey, metadata)
-                // Update seenPublicKeys to avoid duplicate requests
-                seenPublicKeys.add(pubkey)
-            }
-        }
-    }
-
-    private fun login() {
-        viewModelScope.launch {
-            try {
-                val secret = withTimeoutOrNull(3.seconds) {
-                    secretStore.get("user_signer")
-                }
-
-                if (secret == null) {
-                    _signerRequired.value = true
-                    return@launch
-                }
-
-                runCatching {
-                    val signer = createSigner(secret)
-                    nostr.setSigner(signer)
-                }.onSuccess {
-                    _signerRequired.value = false
-                }.onFailure { e ->
-                    showError("Login failed: ${e.message}")
-                    _signerRequired.value = true
-                }
-            } catch (e: Exception) {
-                showError("Login failed: ${e.message}")
-                _signerRequired.value = true
-            }
-        }
-    }
-
-    private fun observeSignerAndCheckRelays() {
-        viewModelScope.launch {
-            while (true) {
-                val pubkey = nostr.signer.currentUser
-
-                if (pubkey != null) {
-                    // Get chat rooms
-                    val rooms = nostr.getChatRooms() ?: emptySet()
-                    if (rooms.isNotEmpty()) {
-                        mergeChatRooms(rooms)
-                        _isPartialProcessedGiftWrap.value = true
-                    }
-
-                    // Get all metadata for the current user
-                    nostr.getUserMetadata()
-
-                    // Small delay to ensure all relays are connected
-                    delay(3000.milliseconds)
-
-                    // Check if the relay list is empty
-                    val relays = nostr.getMsgRelays(pubkey)
-                    if (relays.isEmpty()) {
-                        _isRelayListEmpty.value = true
-                    }
-
-                    break
-                }
-
-                delay(500.milliseconds)
-            }
-        }
-    }
-
-    private fun requestMetadata(pubkey: PublicKey) {
-        if (seenPublicKeys.add(pubkey)) {
-            viewModelScope.launch {
-                metadataRequestChannel.send(pubkey)
-            }
-        }
-    }
-
-    private fun updateMetadata(pubkey: PublicKey, metadata: Metadata) {
-        _metadataStore.getOrPut(pubkey) { MutableStateFlow(null) }.value = metadata
-    }
-
-    fun getMetadata(pubkey: PublicKey): StateFlow<Metadata?> {
-        val flow = _metadataStore.getOrPut(pubkey) { MutableStateFlow(null) }
-        if (flow.value == null) {
-            requestMetadata(pubkey)
-        }
-        return flow.asStateFlow()
-    }
-
-    fun currentUser(): PublicKey? {
-        return nostr.signer.currentUser
-    }
-
-    fun logout() {
-        viewModelScope.launch {
-            secretStore.clear("user_signer")
-            nostr.signer.switch(Keys.generate())
-            _signerRequired.value = true
-        }
-    }
-
-    fun dismissNotificationBanner() {
-        viewModelScope.launch {
-            secretStore.set("notification_banner_dismissed", "true")
-            _isNotificationBannerDismissed.value = true
-        }
-    }
-
-    fun dismissRelayWarning() {
-        _isRelayListEmpty.value = false
-    }
-
-    private suspend fun getOrInitAppKeys(): Keys {
-        val secret = secretStore.get("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("app_keys", keys.secretKey().toBech32())
-
-        return keys
-    }
-
-    private suspend fun blossomUpload(file: ByteArray, contentType: String): String? {
-        try {
-            // Upload picture to Blossom
-            val blossom = BlossomClient(
-                url = "https://blossom.band",
-                client = HttpClient {
-                    install(ContentNegotiation) {
-                        json(Json {
-                            ignoreUnknownKeys = true
-                            prettyPrint = true
-                            isLenient = true
-                        })
-                    }
-                }
-            )
-
-            val descriptor = blossom.upload(
-                file = file,
-                contentType = contentType,
-                signer = nostr.signer.get()
-            )
-
-            return descriptor?.url
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return null
-        }
-    }
-
-    suspend fun updateProfile(
-        name: String? = null,
-        bio: String? = null,
-        picture: ByteArray? = null,
-        contentType: String? = null
-    ) {
-        _isBusy.value = true
-        try {
-            val avatarUrl = picture?.let { blossomUpload(it, contentType ?: "image/jpeg") }
-            val newMetadata = nostr.updateProfile(name, bio, avatarUrl)
-            // Update the metadata state after successfully published
-            updateMetadata(nostr.signer.currentUser!!, newMetadata)
-            // Update local state
-            _isBusy.value = false
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun createIdentity(
-        name: String,
-        bio: String?,
-        picture: ByteArray?,
-        contentType: String? = null
-    ) {
-        _isBusy.value = true
-
-        val keys = Keys.generate()
-        val secret = keys.secretKey().toBech32()
-
-        try {
-            val avatarUrl = picture?.let { blossomUpload(it, contentType ?: "image/jpeg") }
-            // Create identity
-            nostr.createIdentity(keys = keys, name = name, bio, picture = avatarUrl)
-            // Persist the secret in the secret storage
-            secretStore.set("user_signer", secret)
-            // Update local states
-            _isBusy.value = false
-            _signerRequired.value = false
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    private suspend fun createSigner(secret: String): AsyncNostrSigner {
-        return when {
-            secret.startsWith("nsec1") -> Keys.parse(secret)
-
-            secret.startsWith("bunker://") -> {
-                val appKeys = getOrInitAppKeys()
-                val bunker = NostrConnectUri.parse(secret)
-                val timeout = 50.seconds // or Duration.parse("50s")
-                NostrConnect(uri = bunker, appKeys, timeout, 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)
-            }
-
-            else -> throw IllegalArgumentException("Invalid secret format")
-        }
-    }
-
-    suspend fun verifyIdentity(secret: String): PublicKey? {
-        try {
-            val signer = createSigner(secret)
-            if (secret.startsWith("bunker://")) {
-                showError("Please approve the connection.")
-            }
-            return signer.getPublicKeyAsync()
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return null
-        }
-    }
-
-    suspend fun importIdentity(secret: String) {
-        _isBusy.value = true
-        try {
-            val signer = createSigner(secret)
-            // Update signer
-            nostr.setSigner(signer)
-            // Persist the secret in the secret storage
-            secretStore.set("user_signer", secret)
-            // Update local states
-            _signerRequired.value = false
-            _isBusy.value = false
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun connectExternalSigner() {
-        val handler = externalSignerHandler ?: throw IllegalStateException("Signer not available")
-        _isBusy.value = true
-        try {
-            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("user_signer", "nip55://${result.packageName}/${result.pubkey.toHex()}")
-            // Update local states
-            _signerRequired.value = false
-            _isBusy.value = false
-        } catch (e: Exception) {
-            throw Exception("Notice: ${e.message}")
-        }
-    }
-
-    fun isExternalSignerAvailable(): Boolean {
-        return externalSignerHandler?.isAvailable() == true
-    }
-
-    suspend fun useDefaultMsgRelayList() {
-        try {
-            val defaultRelays = nostr.getDefaultMsgRelayList()
-            nostr.setMsgRelays(defaultRelays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun currentUserRelayList(): Map<RelayUrl, RelayMetadata?> {
-        try {
-            return nostr.getRelayList(nostr.signer.currentUser!!)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyMap()
-        }
-    }
-
-    suspend fun currentUserMsgRelayList(): List<RelayUrl> {
-        try {
-            return nostr.getMsgRelays(nostr.signer.currentUser!!)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyList()
-        }
-    }
-
-    fun createChatRoom(to: List<PublicKey>): Long {
-        try {
-            if (nostr.signer.currentUser == null) throw IllegalStateException("User not signed in")
-            if (to.isEmpty()) throw IllegalArgumentException("At least one recipient is required")
-
-            val currentUser = nostr.signer.currentUser!!
-
-            // 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 = _chatRooms.value.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
-            _chatRooms.update { currentRooms ->
-                (currentRooms + room).sortedDescending().toSet()
-            }
-
-            return room.id
-        } catch (e: Exception) {
-            throw IllegalArgumentException("Failed to create room: ${e.message}")
-        }
-    }
-
-    fun getChatRoom(id: Long): Room? {
-        return chatRooms.value.firstOrNull { it.id == id }
-    }
-
-    private fun mergeChatRooms(rooms: Set<Room>) {
-        _chatRooms.update { currentRooms ->
-            val merged = currentRooms.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
-            merged.values.sortedDescending().toSet()
-        }
-    }
-
-    fun getChatRooms() {
-        viewModelScope.launch {
-            val rooms = nostr.getChatRooms() ?: emptySet()
-            mergeChatRooms(rooms)
-        }
-    }
-
-    suspend fun refreshChatRooms() {
-        try {
-            val rooms = nostr.getChatRooms() ?: emptySet()
-            mergeChatRooms(rooms)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun getChatRoomMessages(roomId: Long): List<UnsignedEvent> {
-        try {
-            return nostr.getChatRoomMessages(roomId)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-
-        return emptyList()
-    }
-
-    suspend fun chatRoomConnect(roomId: Long): Map<PublicKey, List<RelayUrl>> {
-        try {
-            val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
-            val members = room.members
-
-            return runCatching {
-                nostr.chatRoomConnect(members.toList())
-            }.getOrElse { e ->
-                showError("Error: ${e.message}")
-                members.associateWith { emptyList() }
-            }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyMap()
-        }
-    }
-
-    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.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}")
-            }
-        }
-    }
-
-    fun isMessageSent(id: EventId): Boolean {
-        val giftWrapId = nostr.rumorMap[id]
-
-        if (giftWrapId != null) {
-            val isSent = nostr.sentEvents[giftWrapId]?.isNotEmpty() ?: false
-            return isSent
-        } else {
-            return false
-        }
-    }
-
-    private fun updateRoomList(roomId: Long, newMessage: UnsignedEvent) {
-        _chatRooms.update { currentRooms ->
-            currentRooms.map { room ->
-                if (room.id == roomId) {
-                    room.copy(
-                        lastMessage = newMessage.content(),
-                        createdAt = newMessage.createdAt()
-                    )
-                } else {
-                    room
-                }
-            }.sortedDescending().toSet()
-        }
-    }
-
-    suspend fun searchByAddress(query: String): PublicKey? {
-        try {
-            return nostr.searchByAddress(query)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-        return null
-    }
-
-    suspend fun searchByNostr(query: String): List<PublicKey> {
-        try {
-            return nostr.searchByNostr(query)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-        return emptyList()
-    }
-}
-
-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

@@ -0,0 +1,20 @@
+package su.reya.coop
+
+import rust.nostr.sdk.Metadata
+import rust.nostr.sdk.PublicKey
+
+data class Profile(
+    val publicKey: PublicKey,
+    val metadata: Metadata
+) {
+    private val record by lazy { metadata.asRecord() }
+
+    val name: String
+        get() = record.displayName?.sanitizeName() ?: record.name ?: publicKey.short()
+
+    val picture: String?
+        get() = record.picture
+
+    val shortPublicKey: String
+        get() = publicKey.short()
+}

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

@@ -1,5 +1,8 @@
 package su.reya.coop
 
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flowOf
 import kotlinx.datetime.DateTimeUnit
 import kotlinx.datetime.TimeZone
 import kotlinx.datetime.minus
@@ -8,6 +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.ProfileCache
 import kotlin.time.Clock
 import kotlin.time.Instant
 
@@ -33,8 +37,7 @@ data class Room(
     }
 
     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()
 
@@ -59,24 +62,48 @@ data class Room(
         }
     }
 
-    fun setKind(kind: RoomKind): Room {
-        return this.copy(kind = kind)
+    fun isGroup(): Boolean = members.size > 1
+}
+
+data class RoomUiState(
+    val name: String = "Loading...",
+    val picture: String? = null,
+    val isGroup: Boolean = false
+)
+
+fun Room.flow(
+    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.sanitizeName(), isGroup = isGroup()))
     }
 
-    fun setCreatedAt(createdAt: Timestamp): Room {
-        return this.copy(createdAt = createdAt)
-    }
+    return combine(displayMembers.map { profileCache.getMetadata(it) }) { profiles ->
+        val names = profiles.mapIndexed { i, profile ->
+            profile?.name?.sanitizeName() ?: displayMembers[i].short()
+        }
 
-    fun setSubject(subject: String?): Room {
-        return this.copy(subject = subject)
-    }
+        val name = when {
+            isGroup() -> {
+                val combined = names.joinToString(", ")
+                val extra = members.size - names.size
+                if (extra > 0) "$combined, +$extra" else combined
+            }
 
-    fun setLastMessage(message: String?): Room {
-        return this.copy(lastMessage = message)
-    }
+            else -> {
+                val first = names.firstOrNull() ?: "Unknown"
+                if (displayMembers.firstOrNull() == currentUser) "$first (you)" else first
+            }
+        }
 
-    fun isGroup(): Boolean {
-        return members.size > 1
+        RoomUiState(
+            name = name,
+            picture = profiles.firstOrNull()?.picture,
+            isGroup = isGroup()
+        )
     }
 }
 
@@ -94,21 +121,25 @@ fun UnsignedEvent.roomId(): Long {
     return sortedUniqueKeys.hashCode().toLong()
 }
 
-fun Timestamp.ago(): String {
-    val SECONDS_IN_MINUTE = 60L
-    val MINUTES_IN_HOUR = 60L
-    val HOURS_IN_DAY = 24L
-    val DAYS_IN_MONTH = 30L
+fun Timestamp.formatAsTime(): String {
+    val timeZone = TimeZone.currentSystemDefault()
+    val inputInstant = Instant.fromEpochSeconds(this.asSecs().toLong())
+    val inputDateTime = inputInstant.toLocalDateTime(timeZone)
+    val hour = inputDateTime.hour.toString().padStart(2, '0')
+    val minute = inputDateTime.minute.toString().padStart(2, '0')
+    return "$hour:$minute"
+}
 
+fun Timestamp.ago(): String {
     val inputInstant = Instant.fromEpochSeconds(this.asSecs().toLong())
     val now = Clock.System.now()
     val duration = now - inputInstant
 
     return when {
-        duration.inWholeSeconds < SECONDS_IN_MINUTE -> "Now"
-        duration.inWholeMinutes < MINUTES_IN_HOUR -> "${duration.inWholeMinutes}m"
-        duration.inWholeHours < HOURS_IN_DAY -> "${duration.inWholeHours}h"
-        duration.inWholeDays < DAYS_IN_MONTH -> "${duration.inWholeDays}d"
+        duration.inWholeSeconds < 60L -> "Now"
+        duration.inWholeMinutes < 60L -> "${duration.inWholeMinutes}m"
+        duration.inWholeHours < 24L -> "${duration.inWholeHours}h"
+        duration.inWholeDays < 30L -> "${duration.inWholeDays}d"
         else -> {
             val localDateTime = inputInstant.toLocalDateTime(TimeZone.currentSystemDefault())
             val month =
@@ -119,7 +150,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/nostr/ExternalSignerHandler.kt

@@ -1,4 +1,4 @@
-package su.reya.coop
+package su.reya.coop.nostr
 
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json

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

@@ -1,4 +1,4 @@
-package su.reya.coop
+package su.reya.coop.nostr
 
 import rust.nostr.sdk.AsyncNostrSigner
 import rust.nostr.sdk.Event

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

@@ -0,0 +1,347 @@
+package su.reya.coop.nostr
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import rust.nostr.sdk.AckPolicy
+import rust.nostr.sdk.Alphabet
+import rust.nostr.sdk.Client
+import rust.nostr.sdk.Event
+import rust.nostr.sdk.EventBuilder
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.Filter
+import rust.nostr.sdk.Keys
+import rust.nostr.sdk.Kind
+import rust.nostr.sdk.KindStandard
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayCapabilities
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.ReqExitPolicy
+import rust.nostr.sdk.ReqTarget
+import rust.nostr.sdk.SendEventTarget
+import rust.nostr.sdk.SingleLetterTag
+import rust.nostr.sdk.Tag
+import rust.nostr.sdk.UnsignedEvent
+import rust.nostr.sdk.nip17ExtractRelayList
+import rust.nostr.sdk.nip59MakeGiftWrapAsync
+import su.reya.coop.Room
+import su.reya.coop.RoomKind
+import su.reya.coop.roomId
+import kotlin.time.Duration
+
+data class MessageSyncState(
+    val processedCount: Int = 0,
+    val isSyncing: Boolean = false
+)
+
+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()
+
+    fun updateSyncState(update: (MessageSyncState) -> MessageSyncState) {
+        _messageSyncState.update(update)
+    }
+
+    suspend fun getUserMessages(msgRelayList: Event) {
+        try {
+            val author =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            val relays = nip17ExtractRelayList(msgRelayList)
+
+            // Ensure relay connections
+            relays.forEach { relay ->
+                client?.addRelay(relay)
+                client?.connectRelay(relay)
+            }
+
+            // Construct a filter for gift wrap events
+            val filter = Filter().kind(Kind.fromStd(KindStandard.GIFT_WRAP)).pubkey(author)
+            val target = mutableMapOf<RelayUrl, List<Filter>>()
+            relays.forEach { relay ->
+                target[relay] = listOf(filter)
+            }
+
+            client?.subscribe(
+                target = ReqTarget.manual(target),
+                id = "gift-wraps"
+            )
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to fetch user messages: ${e.message}", e)
+        }
+    }
+
+    suspend fun extractRumor(event: Event): UnsignedEvent? {
+        try {
+            // Gift wrap must have at least one 'p' tag
+            if (event.tags().publicKeys().isEmpty()) {
+                println("No recipient tags found.")
+                return null
+            }
+
+            // Event must be a gift wrap
+            if (event.kind().asStd().let { it != KindStandard.GIFT_WRAP }) {
+                println("Event is not a gift wrap.")
+                return null
+            }
+
+            // Check if the rumor is already cached
+            val cachedRumor = getCachedRumor(event.id())
+            if (cachedRumor != null) return cachedRumor
+
+            // Decrypt the gift wrap event
+            val seal = signer.nip44DecryptAsync(event.author(), event.content())
+            val sealEvent = Event.fromJson(seal)
+
+            // Verify seal event
+            if (!sealEvent.verify()) {
+                println("Failed to verify seal event.")
+                return null
+            }
+
+            // Decrypt the rumor
+            val rumor = signer.nip44DecryptAsync(sealEvent.author(), sealEvent.content())
+            val unsignedEvent = UnsignedEvent.fromJson(rumor).ensureId()
+
+            // Ensure the rumor author matches the seal
+            if (unsignedEvent.author() != sealEvent.author()) {
+                println("Author mismatch.")
+                return null
+            }
+
+            // Cache the rumor for later use
+            setCachedRumor(event.id(), unsignedEvent)
+
+            return unsignedEvent
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            println("Failed to unwrap gift ${event.id().toHex()}: ${e.message}")
+            return null
+        }
+    }
+
+    private suspend fun getCachedRumor(giftId: EventId): UnsignedEvent? {
+        try {
+            val filter = Filter().identifier(giftId.toHex())
+            val event = client?.database()?.query(filter)?.first()
+
+            return event?.content()?.let { UnsignedEvent.fromJson(it).ensureId() }
+        } 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 {
+            // 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"))
+            )
+
+            // Set event kind
+            val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA)
+
+            // Construct event
+            val event = EventBuilder(kind, rumor.asJson())
+                .tags(tags)
+                .finalizeAsync(Keys.generate())
+
+            client?.database()?.saveEvent(event)
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            println("Failed to set cached rumor: ${e.message}")
+        }
+    }
+
+    suspend fun getChatRooms(): Set<Room>? {
+        try {
+            val userPubkey =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            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)?.toVec() ?: return null
+
+            // Collect rooms
+            val roomsMap: MutableMap<Long, Room> = mutableMapOf()
+
+            events
+                .map { UnsignedEvent.fromJson(it.content()) }
+                .filter { it.tags().publicKeys().isNotEmpty() }
+                .forEach { rumor ->
+                    val id = rumor.roomId()
+                    val isFromMe = rumor.author() == userPubkey
+                    val existing = roomsMap[id]
+                    val createdAt = rumor.createdAt()
+
+                    // If the room is new or the current rumor is newer than the existing one
+                    if (existing == null || createdAt.asSecs() > existing.createdAt.asSecs()) {
+                        // A room is "Ongoing" if it was already marked as such or if the current rumor is from the user
+                        val isOngoing = (existing?.kind == RoomKind.Ongoing) || isFromMe
+                        val room = Room.new(rumor = rumor, userPubkey = userPubkey, id = id)
+                        roomsMap[id] = if (isOngoing) room.copy(kind = RoomKind.Ongoing) else room
+                    } else if (isFromMe && existing.kind != RoomKind.Ongoing) {
+                        // If it's an older rumor but sent by the user, mark the room as Ongoing
+                        roomsMap[id] = existing.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
+        }
+    }
+
+    suspend fun getChatRoomMessages(roomId: Long): List<UnsignedEvent> {
+        try {
+            val kind = Kind.fromStd(KindStandard.APPLICATION_SPECIFIC_DATA)
+            val filter = Filter().kind(kind).reference(roomId.toString())
+            val events = client?.database()?.query(filter)
+
+            // Merge the events
+            return events
+                ?.toVec()
+                ?.map { UnsignedEvent.fromJson(it.content()).ensureId() }
+                // Filter out events without public keys (receivers)
+                ?.filter { it.tags().publicKeys().isNotEmpty() }
+                ?.sortedByDescending { it.createdAt().asSecs() } ?: emptyList()
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get chat room messages: ${e.message}", e)
+        }
+    }
+
+    suspend fun chatRoomConnect(members: List<PublicKey>) {
+        try {
+            members.forEach { member ->
+                val kind = Kind.fromStd(KindStandard.INBOX_RELAYS)
+                val filter = Filter().kind(kind).author(member).limit(1u)
+
+                val stream = client?.streamEvents(
+                    target = ReqTarget.auto(listOf(filter)),
+                    id = null,
+                    timeout = Duration.parse("3s"),
+                    policy = ReqExitPolicy.ExitOnEose
+                )
+
+                stream?.next()?.let { res ->
+                    val event = res.event ?: return@let
+                    connectMsgRelays(event)
+                }
+            }
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to fetch relays: ${e.message}", e)
+        }
+    }
+
+    suspend fun connectMsgRelays(event: Event) {
+        try {
+            val urls = nip17ExtractRelayList(event)
+            for (url in urls) {
+                client?.addRelay(url, RelayCapabilities.gossip())
+                client?.connectRelay(url)
+            }
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to connect to relays: ${e.message}", e)
+        }
+    }
+
+    suspend fun sendMessage(
+        to: Set<PublicKey>,
+        content: String,
+        subject: String? = null,
+        replies: List<EventId> = emptyList(),
+        onRumorCreated: ((UnsignedEvent) -> Unit)? = null,
+    ) {
+        try {
+            val currentUser =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            val tags = mutableListOf<Tag>()
+
+            // Add a subject tag if provided
+            if (subject != null) {
+                tags.add(Tag.custom("subject", listOf(subject)))
+            }
+
+            // Add event tags for replies
+            if (replies.isNotEmpty()) {
+                replies.forEach { replyId ->
+                    tags.add(Tag.event(replyId))
+                }
+            }
+
+            // Add public key tags for each recipient
+            to.forEach { pubkey ->
+                tags.add(Tag.publicKey(pubkey))
+            }
+
+            for (receiver in setOf(currentUser) + to) {
+                // Construct the rumor event
+                // NEVER SIGN this event with the current user signer
+                val rumor = EventBuilder(Kind.fromStd(KindStandard.PRIVATE_DIRECT_MESSAGE), content)
+                    .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 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
+
+                    // Collect failed outputs
+                    output.failed.forEach { (relayUrl, reason) ->
+                        println("Failed to send event to relay $relayUrl: $reason")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to send message: ${e.message}", e)
+        }
+    }
+}

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

@@ -0,0 +1,264 @@
+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
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.supervisorScope
+import rust.nostr.sdk.AsyncNostrSigner
+import rust.nostr.sdk.Client
+import rust.nostr.sdk.ClientBuilder
+import rust.nostr.sdk.ClientNotification
+import rust.nostr.sdk.Event
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.GossipConfig
+import rust.nostr.sdk.Keys
+import rust.nostr.sdk.KindStandard
+import rust.nostr.sdk.LogLevel
+import rust.nostr.sdk.Metadata
+import rust.nostr.sdk.NostrDatabase
+import rust.nostr.sdk.NostrGossip
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayMessageEnum
+import rust.nostr.sdk.SignerAuthenticator
+import rust.nostr.sdk.SleepWhenIdle
+import rust.nostr.sdk.Timestamp
+import rust.nostr.sdk.UnsignedEvent
+import rust.nostr.sdk.initLogger
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+
+object NostrManager {
+    val instance = Nostr()
+}
+
+class Nostr(
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) {
+    var client: Client? = null
+        private set
+    var signer: UniversalSigner = UniversalSigner(Keys.generate())
+        private set
+
+    val messages = MessageManager(this)
+    val profiles = ProfileManager(this)
+    val relays = RelayManager(this)
+
+    private val isInitialized = MutableStateFlow(false)
+
+    private val _newEvents = MutableSharedFlow<UnsignedEvent>(
+        replay = 0,
+        extraBufferCapacity = 100,
+        onBufferOverflow = BufferOverflow.SUSPEND
+    )
+    val newEvents = _newEvents.asSharedFlow()
+
+    fun emitNewEvent(event: UnsignedEvent) {
+        _newEvents.tryEmit(event)
+    }
+
+    suspend fun init(dbPath: String, logLevel: LogLevel = LogLevel.WARN) {
+        try {
+            if (isInitialized.value) return
+
+            // Initialize the logger for nostr client
+            initLogger(logLevel)
+
+            // Initialize configurations for nostr client
+            val lmdb = NostrDatabase.lmdb(dbPath)
+            val gossip = NostrGossip.inMemory()
+
+            // Initialize the authenticator
+            val authenticator = SignerAuthenticator(signer)
+            val idleTimeout = Duration.parse("5m")
+
+            client =
+                ClientBuilder()
+                    .authenticator(authenticator)
+                    .database(lmdb)
+                    .gossip(gossip)
+                    .gossipConfig(
+                        GossipConfig()
+                            .noBackgroundRefresh()
+                            .fetchTimeout(Duration.parse("2s"))
+                    )
+                    .verifySubscriptions(false)
+                    .sleepWhenIdle(SleepWhenIdle.Enabled(idleTimeout))
+                    .build()
+
+            isInitialized.value = true
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to initialize Nostr client: ${e.message}", e)
+        }
+    }
+
+    suspend fun waitUntilInitialized() {
+        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()
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to prune database: ${e.message}", e)
+        }
+    }
+
+    suspend fun setSigner(new: AsyncNostrSigner) {
+        try {
+            signer.switch(new)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to set signer: ${e.message}", e)
+        }
+    }
+
+    fun isSignedByUser(event: Event): Boolean {
+        return try {
+            signer.publicKeyFlow.value == event.author()
+        } catch (e: Exception) {
+            println("Failed to check if event is signed by user: ${e.message}")
+            false
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    suspend fun handleNotifications(
+        onMetadataUpdate: (PublicKey, Metadata) -> Unit,
+        onContactListUpdate: (List<PublicKey>) -> Unit,
+        onNewMessage: (UnsignedEvent) -> Unit,
+    ) = supervisorScope {
+        val now = Timestamp.now()
+        val processedEvent = mutableSetOf<EventId>()
+        val notifications = client?.notifications() ?: return@supervisorScope
+
+        val giftWrapQueue = Channel<Event>(1024)
+        var processedCount = 0
+        var eoseReceived = false
+
+        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()) {
+                        onNewMessage(rumor)
+                    }
+                }
+
+                // Update sync state
+                messages.updateSyncState {
+                    it.copy(
+                        processedCount = processedCount,
+                        isSyncing = !eoseReceived || !giftWrapQueue.isEmpty
+                    )
+                }
+            }
+        }
+
+        while (true) {
+            val notification = notifications.next() ?: continue
+
+            when (notification) {
+                is ClientNotification.Message -> {
+                    val relayUrl = notification.relayUrl
+
+                    when (val message = notification.message.asEnum()) {
+                        is RelayMessageEnum.EventMsg -> {
+                            val event = message.event
+
+                            // Prevent processing duplicate events
+                            if (processedEvent.contains(event.id())) continue
+                            processedEvent.add(event.id())
+
+                            when (event.kind().asStd()) {
+                                KindStandard.METADATA -> {
+                                    try {
+                                        val metadata = Metadata.fromJson(event.content())
+                                        onMetadataUpdate(event.author(), metadata)
+                                    } catch (e: Exception) {
+                                        println("Failed to parse metadata: $e")
+                                    }
+                                }
+
+                                KindStandard.CONTACT_LIST -> {
+                                    if (isSignedByUser(event = event)) {
+                                        val pubkeys = event.tags().publicKeys()
+                                        // Get mutual contacts
+                                        profiles.syncMutualContacts(pubkeys)
+                                        // Emit contact list update
+                                        onContactListUpdate(pubkeys)
+                                    }
+                                }
+
+                                KindStandard.INBOX_RELAYS -> {
+                                    // Get all gift wrap events for the current user
+                                    if (isSignedByUser(event = event)) {
+                                        messages.updateSyncState { it.copy(isSyncing = true) }
+                                        messages.getUserMessages(msgRelayList = event)
+                                    }
+                                }
+
+                                KindStandard.GIFT_WRAP -> {
+                                    giftWrapQueue.send(event)
+                                }
+
+                                else -> {}
+                            }
+                        }
+
+                        is RelayMessageEnum.EndOfStoredEvents -> {
+                            if (message.subscriptionId == "gift-wraps") {
+                                eoseReceived = true
+                                if (giftWrapQueue.isEmpty) {
+                                    messages.updateSyncState { it.copy(isSyncing = false) }
+                                }
+                            }
+                        }
+
+                        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 */
+                        }
+                    }
+                }
+
+                is ClientNotification.Shutdown -> {
+                    break
+                }
+
+                else -> {
+                    /* Ignore other message types */
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,368 @@
+package su.reya.coop.nostr
+
+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
+import rust.nostr.sdk.Client
+import rust.nostr.sdk.Contact
+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.Metadata
+import rust.nostr.sdk.MetadataRecord
+import rust.nostr.sdk.Nip05Address
+import rust.nostr.sdk.Nip05Profile
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayCapabilities
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.ReqExitPolicy
+import rust.nostr.sdk.ReqTarget
+import rust.nostr.sdk.SendEventTarget
+import rust.nostr.sdk.SubscribeAutoCloseOptions
+import rust.nostr.sdk.Timestamp
+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>>(
+            replay = 0,
+            extraBufferCapacity = 100,
+            onBufferOverflow = BufferOverflow.SUSPEND
+        )
+    val metadataUpdates = _metadataUpdates.asSharedFlow()
+
+    private val _contactListUpdates =
+        MutableSharedFlow<List<PublicKey>>(
+            replay = 0,
+            extraBufferCapacity = 100,
+            onBufferOverflow = BufferOverflow.SUSPEND
+        )
+    val contactListUpdates = _contactListUpdates.asSharedFlow()
+
+    suspend fun emitMetadataUpdate(pubkey: PublicKey, metadata: Metadata) {
+        _metadataUpdates.emit(pubkey to metadata)
+    }
+
+    suspend fun emitContactListUpdate(contacts: List<PublicKey>) {
+        _contactListUpdates.emit(contacts)
+    }
+
+    suspend fun getUserMetadata() {
+        try {
+            val author =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            // Get the latest metadata event
+            val metadataFilter =
+                Filter().kind(Kind.fromStd(KindStandard.METADATA)).author(author).limit(1u)
+
+            // Get the latest contact list event
+            val contactFilter =
+                Filter().kind(Kind.fromStd(KindStandard.CONTACT_LIST)).author(author).limit(1u)
+
+            // Get the latest messaging relay list event
+            val msgRelayFilter =
+                Filter().kind(Kind.fromStd(KindStandard.INBOX_RELAYS)).author(author).limit(1u)
+
+            // Construct a target that includes all filters
+            val target = ReqTarget.auto(listOf(metadataFilter, contactFilter, msgRelayFilter))
+            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
+
+            client?.subscribe(target = target, id = "user-metadata", closeOn = opts)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to fetch user metadata: ${e.message}", e)
+        }
+    }
+
+    suspend fun syncMutualContacts(pubkeys: List<PublicKey>) {
+        try {
+            val kind = Kind.fromStd(KindStandard.CONTACT_LIST)
+            val filter = Filter().kind(kind).authors(pubkeys).limit(pubkeys.size.toULong())
+            val relays = RelayManager.BOOTSTRAP_RELAYS.map { RelayUrl.parse(it) }
+
+            client?.sync(filter, relays)
+        } catch (e: Exception) {
+            println("Failed to sync mutual contacts: ${e.message}")
+        }
+    }
+
+    suspend fun createIdentity(keys: Keys, name: String, bio: String?, picture: String?) {
+        // Send relay list event
+        val relayList = nostr.relays.getDefaultRelayList()
+        val relayListEvent = EventBuilder.relayList(relayList).finalizeAsync(keys)
+
+        client?.sendEvent(
+            event = relayListEvent,
+            target = SendEventTarget.broadcast(),
+            ackPolicy = AckPolicy.all(),
+            okTimeout = Duration.parse("3s")
+        )
+
+        // Send messaging relay list event
+        val msgRelayList = nostr.relays.getDefaultMsgRelayList()
+        val msgRelayListEvent = EventBuilder.nip17RelayList(msgRelayList).finalizeAsync(keys)
+
+        client?.sendEvent(
+            event = msgRelayListEvent,
+            target = SendEventTarget.toNip65(),
+            ackPolicy = AckPolicy.none()
+        )
+
+        // Send metadata event
+        val metadata =
+            Metadata.fromRecord(MetadataRecord(displayName = name, about = bio, picture = picture))
+        val metadataEvent = EventBuilder.metadata(metadata).finalizeAsync(keys)
+
+        client?.sendEvent(
+            event = metadataEvent,
+            target = SendEventTarget.broadcast(),
+            ackPolicy = AckPolicy.none()
+        )
+
+        // Send contact list event
+        val defaultContact =
+            Contact(PublicKey.parse("npub1j3rz3ndl902lya6ywxvy5c983lxs8mpukqnx4pa4lt5wrykwl5ys7wpw3x"))
+        val contactListEvent = EventBuilder.contactList(listOf(defaultContact)).finalizeAsync(keys)
+
+        client?.sendEvent(
+            event = contactListEvent,
+            target = SendEventTarget.toNip65(),
+            ackPolicy = AckPolicy.none()
+        )
+
+        nostr.setSigner(keys)
+    }
+
+    suspend fun updateProfile(
+        name: String? = null,
+        bio: String? = null,
+        picture: String? = null
+    ): Metadata {
+        try {
+            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(),
+                ackPolicy = AckPolicy.none()
+            )
+
+            return newMetadata
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to update identity: ${e.message}", e)
+        }
+    }
+
+    private suspend fun getLatestMetadata(pubkey: PublicKey): Metadata? {
+        return try {
+            val kind = Kind.fromStd(KindStandard.METADATA)
+            val filter = Filter().kind(kind).author(pubkey).limit(1u)
+            val event = client?.database()?.query(filter)?.first() ?: return null
+
+            Metadata.fromJson(event.content())
+        } catch (e: Exception) {
+            println("Failed to get latest metadata: ${e.message}")
+            null
+        }
+    }
+
+    suspend fun getAllCacheMetadata(): Map<PublicKey, Metadata> {
+        try {
+            val filter = Filter().kind(Kind.fromStd(KindStandard.METADATA)).limit(100u)
+            val events = client?.database()?.query(filter)
+            val results = mutableMapOf<PublicKey, Metadata>()
+
+            events?.toVec()?.forEach { event ->
+                try {
+                    val metadata = Metadata.fromJson(event.content())
+                    results[event.author()] = metadata
+                } catch (e: Exception) {
+                    println("Failed to parse metadata: $e")
+                }
+            }
+
+            return results
+        } catch (e: Exception) {
+            println("Failed to get all cache metadata: ${e.message}")
+            return emptyMap()
+        }
+    }
+
+    suspend fun fetchMetadataBatch(keys: List<PublicKey>) {
+        try {
+            val limit = keys.size.toULong() * 2u
+            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
+
+            // Construct a filter for metadata events
+            val filter = Filter()
+                .kind(Kind.fromStd(KindStandard.METADATA))
+                .authors(keys)
+                .limit(limit)
+
+            // Construct request target
+            val target = mutableMapOf<RelayUrl, List<Filter>>()
+            RelayManager.BOOTSTRAP_RELAYS.forEach { relay ->
+                target[RelayUrl.parse(relay)] = listOf(filter)
+            }
+
+            client?.subscribe(target = ReqTarget.manual(target), closeOn = opts)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to fetch metadata batch: ${e.message}", e)
+        }
+    }
+
+    suspend fun setContactList(contacts: List<PublicKey>) {
+        try {
+            val contactList = contacts.map { Contact(it) }
+            val event = EventBuilder.contactList(contactList).finalizeAsync(signer)
+
+            client?.sendEvent(
+                event = event,
+                target = SendEventTarget.broadcast(),
+                ackPolicy = AckPolicy.none(),
+            )
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to set contact list: ${e.message}", e)
+        }
+    }
+
+    suspend fun profileFromAddress(client: HttpClient, address: Nip05Address): Nip05Profile {
+        try {
+            val response: HttpResponse = client.get(address.url())
+            val bodyString: String = response.body()
+
+            return Nip05Profile.fromJson(address, bodyString)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to fetch profile from address: ${e.message}", e)
+        }
+    }
+
+    suspend fun searchByAddress(query: String): PublicKey {
+        try {
+            val address = Nip05Address.parse(query)
+            val profile = profileFromAddress(httpClient, address)
+
+            return profile.publicKey()
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to search address: ${e.message}", e)
+        }
+    }
+
+    suspend fun searchByNostr(query: String): List<PublicKey> {
+        try {
+            // Add search relay
+            val searchRelay = RelayUrl.parse("wss://antiprimal.net")
+            if (client?.relay(searchRelay) == null) {
+                client?.addRelay(url = searchRelay, capabilities = RelayCapabilities.read())
+                client?.connectRelay(searchRelay)
+            }
+
+            val kinds = listOf(Kind.fromStd(KindStandard.METADATA))
+            val filter = Filter().kinds(kinds).search(query).limit(10u)
+            val target = ReqTarget.manual(mapOf(searchRelay to listOf(filter)))
+
+            val stream = client?.streamEvents(
+                target = target,
+                id = "search",
+                timeout = Duration.parse("3s"),
+                policy = ReqExitPolicy.ExitOnEose
+            )
+
+            // Collect the results
+            val results = mutableListOf<PublicKey>()
+
+            // Keep searching until the stream is closed or timeout
+            stream?.next()?.let { event ->
+                val event = event.event ?: return@let
+                results.add(event.author())
+            }
+
+            return results
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to search nostr: ${e.message}", e)
+        }
+    }
+
+    suspend fun verifyActivity(pubkey: PublicKey): Timestamp? {
+        try {
+            val filter = Filter().author(pubkey).limit(3u)
+            val target = mutableMapOf<RelayUrl, List<Filter>>()
+            RelayManager.BOOTSTRAP_RELAYS.forEach { relay ->
+                target[RelayUrl.parse(relay)] = listOf(filter)
+            }
+
+            val events = client?.fetchEvents(
+                target = ReqTarget.manual(target),
+                timeout = Duration.parse("3s")
+            )
+
+            return events?.first()?.createdAt()
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get latest activity: ${e.message}", e)
+        }
+    }
+
+    suspend fun verifyContact(pubkey: PublicKey): Boolean {
+        try {
+            val currentUser =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            val kind = Kind.fromStd(KindStandard.CONTACT_LIST)
+            val filter = Filter().kind(kind).author(currentUser).limit(1u)
+
+            val events = client?.database()?.query(filter)
+            val pubkeys = events?.first()?.tags()?.publicKeys() ?: listOf()
+
+            return pubkeys.contains(pubkey)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get mutual contacts: ${e.message}", e)
+        }
+    }
+
+    suspend fun mutualContacts(pubkey: PublicKey): Set<PublicKey> {
+        try {
+            val currentUser =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            val kind = Kind.fromStd(KindStandard.CONTACT_LIST)
+            val filter = Filter().kind(kind).pubkey(pubkey).limit(1u)
+
+            val events = client?.database()?.query(filter)
+            val contacts = mutableSetOf<PublicKey>()
+
+            events?.toVec()?.filter { it.author() != currentUser }?.forEach { event ->
+                contacts.add(event.author())
+            }
+
+            return contacts.toSet()
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get mutual contacts: ${e.message}", e)
+        }
+    }
+}

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

@@ -0,0 +1,197 @@
+package su.reya.coop.nostr
+
+import rust.nostr.sdk.AckPolicy
+import rust.nostr.sdk.Client
+import rust.nostr.sdk.EventBuilder
+import rust.nostr.sdk.Filter
+import rust.nostr.sdk.Kind
+import rust.nostr.sdk.KindStandard
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayCapabilities
+import rust.nostr.sdk.RelayMetadata
+import rust.nostr.sdk.RelayStatus
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.ReqExitPolicy
+import rust.nostr.sdk.ReqTarget
+import rust.nostr.sdk.SendEventTarget
+import rust.nostr.sdk.SubscribeAutoCloseOptions
+import rust.nostr.sdk.extractRelayList
+import rust.nostr.sdk.nip17ExtractRelayList
+import kotlin.time.Duration
+
+class RelayManager(private val nostr: Nostr) {
+    companion object {
+        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
+    }
+
+    private val client: Client? get() = nostr.client
+    private val signer: UniversalSigner get() = nostr.signer
+
+    suspend fun connectBootstrapRelays() {
+        BOOTSTRAP_RELAYS.forEach { url ->
+            client?.addRelay(RelayUrl.parse(url))
+        }
+        INDEXER_RELAY.forEach { url ->
+            client?.addRelay(
+                url = RelayUrl.parse(url),
+                capabilities = RelayCapabilities.gossip()
+            )
+        }
+        // Connect to all bootstrap relays
+        client?.connect()
+    }
+
+    suspend fun reconnect() {
+        ALL_RELAYS.forEach { url ->
+            try {
+                client?.relay(RelayUrl.parse(url)).let { relay ->
+                    if (relay != null) {
+                        if (relay.status() != RelayStatus.CONNECTED) {
+                            relay.connect()
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                println("Failed to reconnect relay: ${e.message}")
+            }
+        }
+    }
+
+    suspend fun disconnect() {
+        ALL_RELAYS.forEach { url ->
+            try {
+                client?.disconnectRelay(RelayUrl.parse(url))
+            } catch (e: Exception) {
+                println("Failed to disconnect relay: ${e.message}")
+            }
+        }
+    }
+
+    internal suspend fun getDefaultRelayList(): Map<RelayUrl, RelayMetadata> {
+        // Construct a list of relays
+        val relayList = mapOf(
+            RelayUrl.parse("wss://relay.damus.io") to RelayMetadata.READ,
+            RelayUrl.parse("wss://relay.primal.net") to RelayMetadata.READ,
+            RelayUrl.parse("wss://relay.nostr.net") to RelayMetadata.WRITE,
+            RelayUrl.parse("wss://nostr.superfriends.online") to RelayMetadata.WRITE
+        )
+
+        // Ensure all relays are added and connected
+        relayList.forEach { (relay, metadata) ->
+            client?.addRelay(
+                url = relay,
+                capabilities =
+                    when (metadata) {
+                        RelayMetadata.READ -> RelayCapabilities.read()
+                        RelayMetadata.WRITE -> RelayCapabilities.write()
+                    }
+            )
+            client?.connectRelay(relay)
+        }
+
+        return relayList
+    }
+
+    internal suspend fun getDefaultMsgRelayList(): List<RelayUrl> {
+        // Construct a list of messaging relays
+        val msgRelayList = listOf(
+            RelayUrl.parse("wss://auth.nostr1.com"),
+            RelayUrl.parse("wss://nip17.com"),
+        )
+
+        // Ensure all relays are added and connected
+        msgRelayList.forEach { relay ->
+            client?.addRelay(relay, RelayCapabilities.none())
+            client?.connectRelay(relay)
+        }
+
+        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)
+
+            client?.sendEvent(
+                event = event,
+                target = SendEventTarget.toNip65(),
+                ackPolicy = AckPolicy.none(),
+            )
+
+            val currentUser =
+                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")
+
+            val kind = Kind.fromStd(KindStandard.INBOX_RELAYS)
+            val filter = Filter().kind(kind).author(currentUser).limit(1u)
+
+            val target = ReqTarget.auto(listOf(filter))
+            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)
+
+            client?.subscribe(target = target, closeOn = opts)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to set msg relays: ${e.message}", e)
+        }
+    }
+
+    suspend fun getMsgRelays(publicKey: PublicKey): List<RelayUrl> {
+        try {
+            val kind = Kind.fromStd(KindStandard.INBOX_RELAYS)
+            val filter = Filter().kind(kind).author(publicKey).limit(1u)
+            val events = client?.database()?.query(filter)
+            val event = events?.first() ?: return emptyList()
+
+            return nip17ExtractRelayList(event)
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get msg relays: ${e.message}", e)
+        }
+    }
+
+    suspend fun fetchMsgRelays(publicKey: PublicKey): List<RelayUrl> {
+        try {
+            val kind = Kind.fromStd(KindStandard.INBOX_RELAYS)
+            val filter = Filter().kind(kind).author(publicKey).limit(1u)
+            val target = ReqTarget.auto(listOf(filter))
+            val events = client?.fetchEvents(target, timeout = Duration.parse("3s"))
+
+            return nip17ExtractRelayList(events?.toVec()?.firstOrNull() ?: return emptyList())
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to fetch msg relays: ${e.message}", e)
+        }
+    }
+}

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

@@ -1,5 +1,7 @@
-package su.reya.coop
+package su.reya.coop.nostr
 
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withTimeoutOrNull
@@ -16,9 +18,8 @@ class UniversalSigner(initialSigner: AsyncNostrSigner) : AsyncNostrSigner {
     @Volatile
     private var signer: AsyncNostrSigner = initialSigner
 
-    @Volatile
-    var currentUser: PublicKey? = null
-        private set
+    private val _publicKeyFlow = MutableStateFlow<PublicKey?>(null)
+    val publicKeyFlow = _publicKeyFlow.asStateFlow()
 
     /**
      * Get the current signer.
@@ -28,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
-        currentUser = pubkey
     }
 
     override suspend fun getPublicKeyAsync(): PublicKey? {
@@ -63,4 +62,4 @@ class UniversalSigner(initialSigner: AsyncNostrSigner) : AsyncNostrSigner {
     override suspend fun nip44DecryptAsync(publicKey: PublicKey, payload: String): String {
         return get().nip44DecryptAsync(publicKey, payload)
     }
-}
+}

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

@@ -0,0 +1,597 @@
+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 importError: String? = null,
+)
+
+class AccountRepository(
+    private val nostr: Nostr,
+    private val storage: AppStorage,
+    private val mediaRepository: MediaRepository,
+    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 { pubkey ->
+            if (pubkey != null) currentUserProfileFlow(pubkey) else flowOf(null)
+        }
+        .stateIn(scope, SharingStarted.WhileSubscribed(5000), null)
+
+    private val _contactList = MutableStateFlow<Set<PublicKey>>(emptySet())
+    val contactList: StateFlow<Set<PublicKey>> = _contactList.asStateFlow()
+
+    private val _isRelayListEmpty = MutableStateFlow(false)
+    val isRelayListEmpty: StateFlow<Boolean> = _isRelayListEmpty.asStateFlow()
+
+    private val _userRelayList = MutableStateFlow<Map<RelayUrl, RelayMetadata?>>(emptyMap())
+    val userRelayList: StateFlow<Map<RelayUrl, RelayMetadata?>> = _userRelayList.asStateFlow()
+
+    private val _userMsgRelayList = MutableStateFlow<List<RelayUrl>>(emptyList())
+    val userMsgRelayList: StateFlow<List<RelayUrl>> = _userMsgRelayList.asStateFlow()
+
+    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
+                    _isRelayListEmpty.value = 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, importError = null) }
+            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, importError = e.message) }
+            }
+        }
+    }
+
+    fun connectExternalSigner() {
+        scope.launch {
+            _state.update { it.copy(isImporting = true, importError = null) }
+            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, importError = e.message) }
+            }
+        }
+    }
+
+    fun createIdentity(
+        name: String,
+        bio: String?,
+        picture: ByteArray?,
+        contentType: String? = null
+    ) {
+        scope.launch {
+            _state.update { it.copy(isImporting = true, importError = null) }
+            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, importError = e.message) }
+            }
+        }
+    }
+
+
+    @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 ->
+                _contactList.value = contacts.toSet()
+            }
+        }
+    }
+
+    fun resetInternalState() {
+        _contactList.value = emptySet()
+        _isRelayListEmpty.value = 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 _contactList.value) return@launch
+
+            try {
+                val updated = _contactList.value + pubkey
+                nostr.profiles.setContactList(updated.toList())
+                _contactList.update { it + pubkey }
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun removeContact(publicKey: PublicKey) {
+        scope.launch {
+            if (publicKey !in _contactList.value) return@launch
+
+            try {
+                val updated = _contactList.value - publicKey
+                nostr.profiles.setContactList(updated.toList())
+                _contactList.update { it - 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() {
+        _isRelayListEmpty.value = 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")
+                _userRelayList.value = nostr.relays.getRelayList(user)
+            } 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")
+                _userMsgRelayList.value = nostr.relays.getMsgRelays(user)
+            } 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,256 @@
+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.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.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 scope: CoroutineScope,
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : ErrorHost by createErrorHost() {
+    private val _state = MutableStateFlow(ChatState())
+    val state = _state.stateIn(
+        scope,
+        SharingStarted.WhileSubscribed(5000),
+        ChatState()
+    )
+
+    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 ->
+                    val roomId = event.roomId()
+                    val existingRoom = _state.value.rooms[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.id to newRoom)) }
+                    } else {
+                        updateRoomList(roomId, event)
+                    }
+
+                    _newEvents.tryEmit(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 refreshChatRooms() {
+        scope.launch(defaultDispatcher) {
+            try {
+                val rooms = nostr.messages.getChatRooms() ?: emptySet()
+                _state.update { currentState ->
+                    val newMap = currentState.rooms.toMutableMap()
+                    rooms.forEach { room -> newMap[room.id] = room }
+                    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 = { event ->
+                        updateRoomList(roomId, event)
+                        scope.launch(defaultDispatcher) { _newEvents.tryEmit(event) }
+                    },
+                )
+            } 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 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 room = currentState.rooms[roomId] ?: return@update currentState
+            val updatedRoom = room.copy(
+                lastMessage = newMessage.content(),
+                createdAt = newMessage.createdAt()
+            )
+            currentState.copy(rooms = currentState.rooms + (roomId to updatedRoom))
+        }
+    }
+
+    fun resetInternalState() {
+        _state.update {
+            it.copy(
+                rooms = emptyMap(),
+                isPartialProcessedGiftWrap = false,
+            )
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+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 {
+    private val httpClient = HttpClient {
+        install(ContentNegotiation) {
+            json(Json {
+                ignoreUnknownKeys = true
+                prettyPrint = true
+                isLenient = true
+            })
+        }
+    }
+
+    suspend fun blossomUpload(
+        signer: AsyncNostrSigner,
+        file: ByteArray,
+        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,
+            )
+            descriptor?.url
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            println("Upload failed: ${e.message}")
+            null
+        }
+    }
+}

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,72 @@
+package su.reya.coop.viewmodel
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
+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.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
+    val contactList: StateFlow<Set<PublicKey>> = repository.contactList
+    val isRelayListEmpty: StateFlow<Boolean> = repository.isRelayListEmpty
+    val userRelayList: StateFlow<Map<RelayUrl, RelayMetadata?>> = repository.userRelayList
+    val userMsgRelayList: StateFlow<List<RelayUrl>> = repository.userMsgRelayList
+
+    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/ChatScreenViewModel.kt

@@ -0,0 +1,84 @@
+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.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.Room
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.roomId
+
+class ChatScreenViewModel(
+    initialRoom: Room,
+    screening: Boolean,
+    accountRepository: AccountRepository,
+    private val chatRepository: ChatRepository,
+) : ViewModel(), ErrorHost by chatRepository {
+    var loading by mutableStateOf(true)
+    var newOtherMessages by mutableIntStateOf(0)
+    var requireScreening by mutableStateOf(screening)
+    val messages = mutableStateListOf<UnsignedEvent>()
+
+    val currentUser = accountRepository.currentUserProfile
+    val id = initialRoom.id
+    
+    val room: StateFlow<Room> = chatRepository.chatRooms
+        .map { rooms -> rooms.find { it.id == id } ?: initialRoom }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000),
+            initialValue = initialRoom
+        )
+
+    init {
+        loadMessages()
+        connect()
+        observeNewEvents()
+    }
+
+    private fun loadMessages() {
+        chatRepository.loadChatRoomMessages(id) { initialMessages ->
+            messages.clear()
+            messages.addAll(initialMessages.distinctBy { it.id() })
+            loading = false
+        }
+    }
+
+    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)
+                    }
+                } 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)
+    }
+}

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

@@ -0,0 +1,21 @@
+package su.reya.coop.viewmodel
+
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
+import rust.nostr.sdk.PublicKey
+import su.reya.coop.Room
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.ChatState
+
+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
+
+    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/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,
+    private val 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()
+    }
+}

zapstore.yaml

@@ -0,0 +1,70 @@
+# ═══════════════════════════════════════════════════════════════════
+# SOURCE CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════
+
+repository: https://git.reya.su/reya/coop-mobile
+release_source:
+  url: https://git.reya.su/reya/coop-mobile
+  type: gitea
+
+# ═══════════════════════════════════════════════════════════════════
+# APP METADATA
+# ═══════════════════════════════════════════════════════════════════
+
+name: Coop
+summary: Chat and Co-op Privately
+license: GPLv3
+website: https://reya.su/coop
+
+description: |
+  Coop is a simple, cozy chat app built for Nostr. It’s designed for folks who want to stay connected without sacrificing their privacy or control over their data.
+
+  **Features**:
+  - Private & Secure: Enjoy end-to-end encrypted messaging that keeps your private chats truly private.
+  - Friendly Socializing: Connect with friends across the open Nostr network in a clean, easy-to-use interface.
+  - No Identity Required: Get started without a phone number. Stay anonymous, use a pseudonym, or even your real name.
+
+tags:
+  - messaging
+  - privacy
+  - material3
+  - nostr
+
+# ═══════════════════════════════════════════════════════════════════
+# MEDIA
+# ═══════════════════════════════════════════════════════════════════
+
+icon: ./assets/icon.png
+
+images:
+  - ./assets/screenshot1.png
+  - ./assets/screenshot2.png
+  - ./assets/screenshot3.png
+  - ./assets/screenshot4.png
+  - ./assets/screenshot5.png
+
+# ═══════════════════════════════════════════════════════════════════
+# RELEASE CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════
+
+release_notes: ./CHANGELOG.md
+
+# ═══════════════════════════════════════════════════════════════════
+# NOSTR-SPECIFIC
+# ═══════════════════════════════════════════════════════════════════
+
+supported_nips:
+  - "01"
+  - "17"
+  - "46"
+  - "55"
+  - "59"
+
+min_allowed_version_code: 100
+
+# ═══════════════════════════════════════════════════════════════════
+# METADATA SOURCES
+# ═══════════════════════════════════════════════════════════════════
+
+metadata_sources:
+  - playstore