chore: bump version

chore: fix some crash and performance issues (#45 )
Reviewed-on: #45
2026-07-15 19:44:52 +07:00 · 2026-07-15 12:44:28 +00:00 · 2026-07-14 10:22:27 +00:00 · 2026-07-13 10:56:23 +00:00 · 2026-07-13 01:04:15 +00:00 · 2026-07-11 12:45:53 +00:00
42 changed files with 2236 additions and 1671 deletions
--- a/composeApp/build.gradle.kts
+++ b/composeApp/build.gradle.kts
@@ -69,7 +69,7 @@ android {
        minSdk = libs.versions.android.minSdk.get().toInt()
        targetSdk = libs.versions.android.targetSdk.get().toInt()
        versionCode = 1
-        versionName = "0.2.4"
+        versionName = "0.2.5"
    }
    packaging {
        resources {
--- a/composeApp/src/androidMain/composeResources/drawable/ic_copy.xml
+++ b/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>
--- a/composeApp/src/androidMain/composeResources/drawable/ic_info.xml
+++ b/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>
--- a/composeApp/src/androidMain/composeResources/drawable/ic_reply.xml
+++ b/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>
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/App.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/App.kt
@@ -26,7 +26,10 @@ import androidx.compose.runtime.setValue
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.platform.LocalContext
 import androidx.core.util.Consumer
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
 import androidx.navigation3.runtime.NavBackStack
 import androidx.navigation3.runtime.NavKey
@@ -34,8 +37,9 @@ import androidx.navigation3.runtime.entryProvider
 import androidx.navigation3.runtime.rememberNavBackStack
 import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
 import androidx.navigation3.ui.NavDisplay
-import su.reya.coop.repository.ErrorRepository
-import su.reya.coop.screens.chat.ChatScreen
+import kotlinx.coroutines.launch
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
 import su.reya.coop.screens.ContactListScreen
 import su.reya.coop.screens.HomeScreen
 import su.reya.coop.screens.ImportScreen
@@ -48,20 +52,14 @@ 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.viewmodel.AuthViewModel
+import su.reya.coop.screens.chat.ChatScreen
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatScreenViewModel
 import su.reya.coop.viewmodel.ChatViewModel
-import su.reya.coop.viewmodel.NostrViewModel
+import su.reya.coop.viewmodel.ProfileCache

-val LocalNostrViewModel = staticCompositionLocalOf<NostrViewModel> {
-    error("No NostrViewModel provided")
-}
-
-val LocalChatViewModel = staticCompositionLocalOf<ChatViewModel> {
-    error("No ChatViewModel provided")
-}
-
-val LocalAuthViewModel = staticCompositionLocalOf<AuthViewModel> {
-    error("No AuthViewModel provided")
+val LocalProfileCache = staticCompositionLocalOf<ProfileCache> {
+    error("No ProfileCache provided")
 }

 val LocalSnackbarHostState = staticCompositionLocalOf<SnackbarHostState> {
@@ -79,10 +77,33 @@ val LocalScanResult = staticCompositionLocalOf<QrScanResult> {
@OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
@Composable
 fun App(
-    nostrViewModel: NostrViewModel,
-    chatViewModel: ChatViewModel,
-    authViewModel: AuthViewModel,
+    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 backStack = rememberNavBackStack(Screen.Home)
@@ -90,8 +111,8 @@ fun App(
    val qrScanResult = remember { QrScanResult() }

    // Get the signer required state
-    val authState by authViewModel.state.collectAsStateWithLifecycle()
-    val signerRequired = authState.signerRequired
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val signerRequired = accountState.signerRequired

    // Snackbar
    val snackbarHostState = remember { SnackbarHostState() }
@@ -118,17 +139,29 @@ fun App(
    }

    LaunchedEffect(Unit) {
-        ErrorRepository.errors.collect { 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)
+            }
+        }
+    }

    LaunchedEffect(activity) {
        activity?.let {
            fun handleIntent(intent: Intent) {
                val screen = Screen.fromIntent(intent)
                // Prevent pushing the same screen
-                if (screen != null && backStack.lastOrNull() != screen) {
+                if ((screen != null) && (backStack.lastOrNull() != screen)) {
                    navigator.navigate(screen)
                }
            }
@@ -161,9 +194,7 @@ fun App(
        motionScheme = MotionScheme.expressive(),
    ) {
        CompositionLocalProvider(
-            LocalNostrViewModel provides nostrViewModel,
-            LocalChatViewModel provides chatViewModel,
-            LocalAuthViewModel provides authViewModel,
+            LocalProfileCache provides profileCache,
            LocalSnackbarHostState provides snackbarHostState,
            LocalNavigator provides navigator,
            LocalScanResult provides qrScanResult,
@@ -184,43 +215,62 @@ fun App(
                ),
                entryProvider = entryProvider {
                    entry<Screen.Home> {
-                        HomeScreen()
+                        HomeScreen(accountViewModel, chatViewModel)
                    }
                    entry<Screen.RequestList> {
-                        RequestListScreen()
+                        RequestListScreen(chatViewModel)
                    }
                    entry<Screen.Onboarding> {
-                        OnboardingScreen()
+                        OnboardingScreen(accountViewModel)
                    }
                    entry<Screen.Import> {
-                        ImportScreen()
+                        ImportScreen(accountViewModel)
                    }
                    entry<Screen.NewIdentity> {
-                        NewIdentityScreen()
+                        NewIdentityScreen(accountViewModel)
                    }
                    entry<Screen.Chat> { key ->
-                        ChatScreen(id = key.id, screening = key.screening)
+                        val factory = remember(key) {
+                            object : ViewModelProvider.Factory {
+                                override fun <T : ViewModel> create(modelClass: Class<T>): T {
+                                    @Suppress("UNCHECKED_CAST")
+                                    return ChatScreenViewModel(
+                                        key.id,
+                                        key.screening,
+                                        accountRepository,
+                                        chatRepository
+                                    ) as T
+                                }
+                            }
+                        }
+                        ChatScreen(
+                            viewModel<ChatScreenViewModel>(
+                                key = key.id.toString(),
+                                factory = factory
+                            ),
+                            accountViewModel
+                        )
                    }
                    entry<Screen.NewChat> {
-                        NewChatScreen()
+                        NewChatScreen(accountViewModel, chatViewModel)
                    }
                    entry<Screen.Profile> { key ->
-                        ProfileScreen(pubkey = key.pubkey)
+                        ProfileScreen(pubkey = key.pubkey, chatViewModel = chatViewModel)
                    }
                    entry<Screen.UpdateProfile> {
-                        UpdateProfileScreen()
+                        UpdateProfileScreen(accountViewModel)
                    }
                    entry<Screen.Scan> {
                        ScanScreen()
                    }
                    entry<Screen.MyQr> {
-                        MyQrScreen()
+                        MyQrScreen(accountViewModel)
                    }
                    entry<Screen.ContactList> {
-                        ContactListScreen()
+                        ContactListScreen(accountViewModel, chatViewModel)
                    }
                    entry<Screen.Relay> {
-                        RelayScreen()
+                        RelayScreen(accountViewModel)
                    }
                }
            )
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/ExternalSignerLauncher.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/ExternalSignerLauncher.kt
@@ -4,12 +4,15 @@ import android.content.Intent
 import androidx.activity.result.ActivityResult
 import androidx.activity.result.ActivityResultLauncher
 import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext

-class ExternalSignerLauncher {
+class ExternalSignerLauncher(
+    private val mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
+) {
    private var launcher: ActivityResultLauncher<Intent>? = null
    private var pendingResult: CompletableDeferred<ActivityResult>? = null
    private val mutex = Mutex()
@@ -19,7 +22,7 @@ class ExternalSignerLauncher {
    }

    suspend fun launch(intent: Intent): ActivityResult = mutex.withLock {
-        withContext(Dispatchers.Main) {
+        withContext(mainDispatcher) {
            val deferred = CompletableDeferred<ActivityResult>()
            pendingResult = deferred
            launcher?.launch(intent) ?: throw IllegalStateException("Signer not registered")
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/MainActivity.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/MainActivity.kt
@@ -8,14 +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.ViewModel
-import androidx.lifecycle.ViewModelProvider
+import kotlinx.coroutines.MainScope
 import su.reya.coop.nostr.NostrManager
-import su.reya.coop.viewmodel.AuthViewModel
-import su.reya.coop.viewmodel.ChatViewModel
-import su.reya.coop.viewmodel.NostrViewModel
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.MediaRepository
+import su.reya.coop.viewmodel.ProfileCache
 import kotlin.system.exitProcess

 class MainActivity : ComponentActivity() {
@@ -23,30 +22,20 @@ class MainActivity : ComponentActivity() {
        val externalSignerLauncher = ExternalSignerLauncher()
    }

-    private val factory by lazy {
-        object : ViewModelProvider.Factory {
-            private val storage = AppStore(this@MainActivity)
-            private val nostrViewModel = NostrViewModel(NostrManager.instance)
-            private val chatViewModel = ChatViewModel(NostrManager.instance)
-            private val androidSigner =
-                AndroidExternalSigner(this@MainActivity, externalSignerLauncher)
-            private val authViewModel =
-                AuthViewModel(NostrManager.instance, storage, androidSigner)
+    private val profileCache by lazy { ProfileCache(NostrManager.instance) }
+    private val scope = MainScope()

-            override fun <T : ViewModel> create(modelClass: Class<T>): T {
-                return when {
-                    modelClass.isAssignableFrom(NostrViewModel::class.java) -> nostrViewModel
-                    modelClass.isAssignableFrom(ChatViewModel::class.java) -> chatViewModel
-                    modelClass.isAssignableFrom(AuthViewModel::class.java) -> authViewModel
-                    else -> throw IllegalArgumentException("Unknown ViewModel class")
-                } as T
-            }
-        }
+    private val 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 nostrViewModel: NostrViewModel by viewModels { factory }
-    private val chatViewModel: ChatViewModel by viewModels { factory }
-    private val authViewModel: AuthViewModel by viewModels { factory }
+    private val chatRepository by lazy {
+        val mediaRepository = MediaRepository()
+        ChatRepository(NostrManager.instance, mediaRepository, scope)
+    }

    override fun onCreate(savedInstanceState: Bundle?) {
        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
@@ -85,14 +74,14 @@ class MainActivity : ComponentActivity() {

        // Keep the splash screen visible until the signer check is complete
        splashScreen.setKeepOnScreenCondition {
-            authViewModel.state.value.signerRequired == null
+            accountRepository.state.value.signerRequired == null
        }

        setContent {
            App(
-                nostrViewModel = nostrViewModel,
-                chatViewModel = chatViewModel,
-                authViewModel = authViewModel,
+                profileCache = profileCache,
+                accountRepository = accountRepository,
+                chatRepository = chatRepository,
            )
        }
    }
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/NostrForegroundService.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/NostrForegroundService.kt
@@ -14,6 +14,7 @@ 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
@@ -27,6 +28,8 @@ 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

--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/ContactListScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/ContactListScreen.kt
@@ -33,11 +33,9 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTooltipState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -55,27 +53,27 @@ import coop.composeapp.generated.resources.ic_check
 import coop.composeapp.generated.resources.ic_close
 import coop.composeapp.generated.resources.ic_plus
 import coop.composeapp.generated.resources.ic_scanner
-import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.Nip05Address
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
 import su.reya.coop.short
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun ContactListScreen() {
+fun ContactListScreen(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
    val navigator = LocalNavigator.current
    val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-
-    val contactList by nostrViewModel.contactList.collectAsStateWithLifecycle()
+    val contactList by accountViewModel.contactList.collectAsStateWithLifecycle()
    var openAddContactDialog by remember { mutableStateOf(false) }
    var contactToDelete by remember { mutableStateOf<PublicKey?>(null) }

@@ -191,7 +189,10 @@ fun ContactListScreen() {
    )

    if (openAddContactDialog) {
-        AddContactDialog(onDismissRequest = { openAddContactDialog = false })
+        AddContactDialog(
+            accountViewModel = accountViewModel,
+            onDismissRequest = { openAddContactDialog = false }
+        )
    }

    if (contactToDelete != null) {
@@ -202,7 +203,7 @@ fun ContactListScreen() {
            confirmButton = {
                TextButton(
                    onClick = {
-                        contactToDelete?.let { nostrViewModel.removeContact(it) }
+                        contactToDelete?.let { accountViewModel.removeContact(it) }
                        contactToDelete = null
                    }
                ) {
@@ -220,15 +221,15 @@ fun ContactListScreen() {

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun AddContactDialog(onDismissRequest: () -> Unit) {
+fun AddContactDialog(
+    accountViewModel: AccountViewModel,
+    onDismissRequest: () -> Unit,
+) {
    val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
    val focusRequester = remember { FocusRequester() }
    var contact by remember { mutableStateOf("") }
    var isError by remember { mutableStateOf(false) }

-    val scope = rememberCoroutineScope()
-
    LaunchedEffect(Unit) {
        focusRequester.requestFocus()
    }
@@ -266,10 +267,8 @@ fun AddContactDialog(onDismissRequest: () -> Unit) {
                    },
                    actions = {
                        IconButton(onClick = {
-                            scope.launch {
-                                val success = nostrViewModel.addContact(contact)
-                                if (success) onDismissRequest()
-                            }
+                            accountViewModel.addContact(contact)
+                            onDismissRequest()
                        }) {
                            Icon(
                                painter = painterResource(Res.drawable.ic_check),
@@ -326,9 +325,9 @@ fun ContactListItem(
    onClick: () -> Unit,
    onLongClick: () -> Unit,
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
-    val profile by profileFlow.collectAsState(initial = null)
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
+    val profile by profileFlow.collectAsStateWithLifecycle(initialValue = null)

    SegmentedListItem(
        onClick = onClick,
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/HomeScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/HomeScreen.kt
@@ -89,46 +89,47 @@ 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.LocalAuthViewModel
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Room
 import su.reya.coop.RoomKind
+import su.reya.coop.RoomUiState
 import su.reya.coop.Screen
 import su.reya.coop.ago
-import su.reya.coop.rememberUiState
 import su.reya.coop.shared.Avatar
 import su.reya.coop.shared.getExpressiveFontFamily
+import su.reya.coop.uiStateFlow
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
@Composable
-fun HomeScreen() {
+fun HomeScreen(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
    val context = LocalContext.current
    val navigator = LocalNavigator.current
    val qrScanResult = LocalScanResult.current
    val snackbarHostState = LocalSnackbarHostState.current
    val clipboardManager = LocalClipboard.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-    val authViewModel = LocalAuthViewModel.current

    val scope = rememberCoroutineScope()
    val sheetState = rememberModalBottomSheetState(true)
    val listState = rememberLazyListState()
    val pullToRefreshState = rememberPullToRefreshState()

-    val userProfile by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val userProfile by accountViewModel.currentUserProfile.collectAsStateWithLifecycle()
    val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()

-    val isRelayListEmpty by nostrViewModel.isRelayListEmpty.collectAsStateWithLifecycle()
+    val isRelayListEmpty by accountViewModel.isRelayListEmpty.collectAsStateWithLifecycle()
    val isSyncing by chatViewModel.isSyncing.collectAsStateWithLifecycle()
    val isPartialProcessedGiftWrap by chatViewModel.isPartialProcessedGiftWrap.collectAsStateWithLifecycle()

-    val authState by authViewModel.state.collectAsStateWithLifecycle()
-    val isBannerDismissed = authState.isNotificationBannerDismissed
+    val accountState by accountViewModel.state.collectAsStateWithLifecycle()
+    val isBannerDismissed = accountState.isNotificationBannerDismissed

    val expandedFab by remember { derivedStateOf { listState.firstVisibleItemIndex == 0 } }
    var showBottomSheet by remember { mutableStateOf(false) }
@@ -155,7 +156,7 @@ fun HomeScreen() {
        onPauseOrDispose { }
    }

-    LaunchedEffect(Unit) {
+    LaunchedEffect(accountState.signerRequired) {
        chatViewModel.refreshChatRooms()
    }

@@ -280,7 +281,7 @@ fun HomeScreen() {
                                horizontalArrangement = Arrangement.spacedBy(8.dp),
                            ) {
                                TextButton(
-                                    onClick = { authViewModel.dismissNotificationBanner() },
+                                    onClick = { accountViewModel.dismissNotificationBanner() },
                                    modifier = Modifier.weight(1f),
                                ) {
                                    Text(text = "Maybe later")
@@ -319,11 +320,9 @@ fun HomeScreen() {
                        isRefreshing = isRefreshing,
                        state = pullToRefreshState,
                        onRefresh = {
-                            scope.launch {
                            isRefreshing = true
                            chatViewModel.refreshChatRooms()
                            isRefreshing = false
-                            }
                        },
                        indicator = {
                            PullToRefreshDefaults.LoadingIndicator(
@@ -461,7 +460,11 @@ fun HomeScreen() {
                    }
                }
                Spacer(modifier = Modifier.size(16.dp))
-                BottomMenuList(onDismiss = dismissAndRun)
+                BottomMenuList(
+                    onDismiss = dismissAndRun,
+                    accountViewModel = accountViewModel,
+                    chatViewModel = chatViewModel
+                )
            }
        }
    }
@@ -469,7 +472,7 @@ fun HomeScreen() {
    // Show the relay setup dialog if the msg relay list is empty
    if (isRelayListEmpty) {
        ModalBottomSheet(
-            onDismissRequest = { nostrViewModel.dismissRelayWarning() },
+            onDismissRequest = { accountViewModel.dismissRelayWarning() },
            sheetState = sheetState,
            containerColor = MaterialTheme.colorScheme.surfaceContainer,
        ) {
@@ -573,15 +576,9 @@ fun HomeScreen() {
                        TextButton(
                            enabled = !isBusy,
                            onClick = {
-                                scope.launch {
                                isBusy = true
-                                    try {
-                                        nostrViewModel.refetchMsgRelays()
-                                    } catch (e: Exception) {
-                                        snackbarHostState.showSnackbar("Failed to refresh metadata: ${e.message}")
-                                    }
+                                accountViewModel.refetchMsgRelays()
                                isBusy = false
-                                }
                            },
                            modifier = Modifier
                                .weight(1f)
@@ -595,10 +592,8 @@ fun HomeScreen() {
                        Button(
                            enabled = !isBusy,
                            onClick = {
-                                scope.launch {
-                                    nostrViewModel.useDefaultMsgRelayList()
-                                    sheetState.hide()
-                                }
+                                accountViewModel.useDefaultMsgRelayList()
+                                scope.launch { sheetState.hide() }
                            },
                            modifier = Modifier
                                .weight(1f)
@@ -619,14 +614,16 @@ fun HomeScreen() {
@Composable
 fun NewRequests(requests: List<Room>) {
    val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
+    val profileCache = LocalProfileCache.current

    val total = requests.size
    val firstRoom = requests.getOrNull(0)
    val secondRoom = requests.getOrNull(1)

-    val firstRoomState by (firstRoom as Room).rememberUiState(nostrViewModel)
-    val secondRoomState by (secondRoom ?: firstRoom).rememberUiState(nostrViewModel)
+    val firstRoomState by (firstRoom as Room).uiStateFlow(profileCache)
+        .collectAsStateWithLifecycle(RoomUiState())
+    val secondRoomState by (secondRoom ?: firstRoom).uiStateFlow(profileCache)
+        .collectAsStateWithLifecycle(RoomUiState())

    val supportingText = when {
        total == 1 -> {
@@ -697,8 +694,8 @@ fun NewRequests(requests: List<Room>) {
@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
 fun ChatRoom(room: Room, onClick: () -> Unit) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val roomState by room.rememberUiState(nostrViewModel)
+    val profileCache = LocalProfileCache.current
+    val roomState by room.uiStateFlow(profileCache).collectAsStateWithLifecycle(RoomUiState())

    ListItem(
        modifier = Modifier.clickable(onClick = onClick),
@@ -741,12 +738,11 @@ fun ChatRoom(room: Room, onClick: () -> Unit) {
@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
 fun BottomMenuList(
-    onDismiss: (suspend () -> Unit) -> Unit
+    onDismiss: (suspend () -> Unit) -> Unit,
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel,
 ) {
    val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-    val authViewModel = LocalAuthViewModel.current

    val defaultMenuList = listOf(
        "Update Profile" to { navigator.navigate(Screen.UpdateProfile) },
@@ -778,8 +774,8 @@ fun BottomMenuList(
        FilledTonalButton(
            onClick = {
                onDismiss {
-                    authViewModel.logout(onLogout = {
-                        nostrViewModel.resetInternalState()
+                    accountViewModel.logout(onLogout = {
+                        accountViewModel.resetInternalState()
                        chatViewModel.resetInternalState()
                    })
                }
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/ImportScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/ImportScreen.kt
@@ -34,7 +34,6 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -44,33 +43,30 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_scanner
-import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.Keys
 import rust.nostr.sdk.NostrConnectUri
-import su.reya.coop.LocalAuthViewModel
 import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
+import su.reya.coop.viewmodel.AccountViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun ImportScreen() {
+fun ImportScreen(viewModel: AccountViewModel) {
    val snackbarHostState = LocalSnackbarHostState.current
    val navigator = LocalNavigator.current
    val qrScanResult = LocalScanResult.current
    val focusManager = LocalFocusManager.current
-    val authViewModel = LocalAuthViewModel.current
-    val scope = rememberCoroutineScope()
-
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
    var secret by remember { mutableStateOf("") }
    var password by remember { mutableStateOf("") }
    var requirePassword by remember { mutableStateOf(false) }
-    var loading by remember { mutableStateOf(false) }

    LaunchedEffect(qrScanResult.content) {
        qrScanResult.content?.let { result ->
@@ -98,6 +94,20 @@ fun ImportScreen() {
        }
    }

+    // 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) },
@@ -164,7 +174,7 @@ fun ImportScreen() {
                            BasicTextField(
                                value = secret,
                                onValueChange = { secret = it },
-                                enabled = !loading,
+                                enabled = !accountState.isImporting,
                                modifier = Modifier.fillMaxWidth(),
                                singleLine = true,
                                keyboardOptions = KeyboardOptions(
@@ -209,7 +219,7 @@ fun ImportScreen() {
                                BasicTextField(
                                    value = password,
                                    onValueChange = { password = it },
-                                    enabled = !loading && requirePassword,
+                                    enabled = !accountState.isImporting && requirePassword,
                                    modifier = Modifier.fillMaxWidth(),
                                    singleLine = true,
                                    keyboardOptions = KeyboardOptions(
@@ -237,25 +247,14 @@ fun ImportScreen() {
                        Spacer(modifier = Modifier.size(16.dp))
                        Button(
                            onClick = {
-                                scope.launch {
-                                    loading = true
-                                    try {
-                                        // Import the identity
-                                        authViewModel.importIdentity(secret, password)
-                                        // Navigate to the home screen
-                                        navigator.navigate(Screen.Home)
-                                    } catch (e: Exception) {
-                                        snackbarHostState.showSnackbar(e.message ?: "Error")
-                                        loading = false
-                                    }
-                                }
+                                viewModel.importIdentity(secret, password)
                            },
                            modifier = Modifier
                                .fillMaxWidth()
                                .height(ButtonDefaults.MediumContainerHeight),
-                            enabled = secret.isNotBlank() && !loading,
+                            enabled = secret.isNotBlank() && !accountState.isImporting,
                        ) {
-                            if (loading) {
+                            if (accountState.isImporting) {
                                LoadingIndicator()
                            } else {
                                Text(
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/MyQrScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/MyQrScreen.kt
@@ -22,15 +22,14 @@ import coop.composeapp.generated.resources.ic_arrow_back
 import io.github.alexzhirkevich.qrose.rememberQrCodePainter
 import org.jetbrains.compose.resources.painterResource
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.viewmodel.AccountViewModel

@Composable
-fun MyQrScreen() {
+fun MyQrScreen(viewModel: AccountViewModel) {
    val navigator = LocalNavigator.current
    val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val currentUser by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val currentUser by viewModel.currentUserProfile.collectAsStateWithLifecycle()

    Scaffold(
        snackbarHost = { SnackbarHost(snackbarHostState) },
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/NewChatScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/NewChatScreen.kt
@@ -55,26 +55,27 @@ import coop.composeapp.generated.resources.ic_scanner
 import kotlinx.coroutines.delay
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
 import su.reya.coop.short
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatViewModel
 import kotlin.time.Duration.Companion.milliseconds

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun NewChatScreen() {
+fun NewChatScreen(
+    accountViewModel: AccountViewModel,
+    chatViewModel: ChatViewModel
+) {
    val snackbarHostState = LocalSnackbarHostState.current
    val navigator = LocalNavigator.current
    val qrScanResult = LocalScanResult.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
-
-    val contactList by nostrViewModel.contactList.collectAsStateWithLifecycle()
+    val contactList by accountViewModel.contactList.collectAsStateWithLifecycle()
    var query by remember { mutableStateOf("") }

    val createGroup = remember { mutableStateOf(false) }
@@ -96,15 +97,17 @@ fun NewChatScreen() {
                    selectedReceivers.add(pubkey)
                }
            } else if (query.contains("@")) {
-                val pubkey = nostrViewModel.searchByAddress(query)
+                accountViewModel.searchByAddress(query) { pubkey ->
                    if (pubkey != null) {
                        selectedReceivers.add(pubkey)
                    }
+                }
            } else {
-                val results = nostrViewModel.searchByNostr(query)
+                accountViewModel.searchByNostr(query) { results ->
                    searchResults.clear()
                    searchResults.addAll(results)
                }
+            }

            query = ""
        }
@@ -290,8 +293,8 @@ fun ReceiverChip(
    pubkey: PublicKey,
    onRemove: () -> Unit
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
    val profile by profileFlow.collectAsState(initial = null)

    CompositionLocalProvider(LocalMinimumInteractiveComponentSize provides 0.dp) {
@@ -372,8 +375,8 @@ fun ContactListItem(
    onClick: () -> Unit,
    onLongClick: () -> Unit
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileCache = LocalProfileCache.current
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
    val profile by profileFlow.collectAsState(initial = null)

    SegmentedListItem(
@@ -394,7 +397,7 @@ fun ContactListItem(
        supportingContent = { Text(text = pubkey.short()) },
        content = {
            Text(
-                text = profile?.name ?: "",
+                text = profile?.name ?: "Unknown",
                style = MaterialTheme.typography.titleMediumEmphasized,
            )
        }
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/NewIdentityScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/NewIdentityScreen.kt
@@ -1,22 +1,25 @@
 package su.reya.coop.screens

 import androidx.compose.runtime.Composable
-import su.reya.coop.LocalAuthViewModel
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import su.reya.coop.LocalNavigator
 import su.reya.coop.Screen
 import su.reya.coop.shared.ProfileEditor
+import su.reya.coop.viewmodel.AccountViewModel

@Composable
-fun NewIdentityScreen() {
-    val authViewModel = LocalAuthViewModel.current
+fun NewIdentityScreen(viewModel: AccountViewModel) {
    val navigator = LocalNavigator.current
+    val accountState by viewModel.state.collectAsStateWithLifecycle()

    ProfileEditor(
        title = "Create a new identity",
        buttonLabel = "Continue",
+        isBusy = accountState.isImporting,
        onBack = { navigator.goBack() },
        onConfirm = { name, bio, bytes, type ->
-            authViewModel.createIdentity(name, bio, bytes, type)
+            viewModel.createIdentity(name, bio, bytes, type)
            navigator.navigate(Screen.Home)
        }
    )
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/OnboardingScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/OnboardingScreen.kt
@@ -24,6 +24,8 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
@@ -41,25 +43,40 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.core.net.toUri
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.coop
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
-import su.reya.coop.LocalAuthViewModel
 import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.getExpressiveFontFamily
+import su.reya.coop.viewmodel.AccountViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun OnboardingScreen() {
+fun OnboardingScreen(viewModel: AccountViewModel) {
    val context = LocalContext.current
    val snackbarHostState = LocalSnackbarHostState.current
    val navigator = LocalNavigator.current
-    val authViewModel = LocalAuthViewModel.current
+    val accountState by viewModel.state.collectAsStateWithLifecycle()
    val scope = rememberCoroutineScope()

+    // Navigate to Home on successful external signer connection
+    LaunchedEffect(accountState.signerRequired) {
+        if (accountState.signerRequired == false) {
+            navigator.navigate(Screen.Home)
+        }
+    }
+
+    // Show connection errors
+    LaunchedEffect(accountState.importError) {
+        accountState.importError?.let {
+            snackbarHostState.showSnackbar(it)
+        }
+    }
+
    val logoPainter = painterResource(Res.drawable.coop)
    val expressiveFont = getExpressiveFontFamily()

@@ -157,18 +174,12 @@ fun OnboardingScreen() {
                            Spacer(modifier = Modifier.size(8.dp))
                            FilledTonalButton(
                                onClick = {
-                                    scope.launch {
-                                        if (authViewModel.isExternalSignerAvailable()) {
-                                            try {
+                                    if (viewModel.isExternalSignerAvailable()) {
                                        // Connect to the external signer
                                        // TODO: show all available signers?
-                                                authViewModel.connectExternalSigner()
-                                                // Navigate to the home screen
-                                                navigator.navigate(Screen.Home)
-                                            } catch (e: Exception) {
-                                                e.message?.let { snackbarHostState.showSnackbar(it) }
-                                            }
+                                        viewModel.connectExternalSigner()
                                    } else {
+                                        scope.launch {
                                            val result = snackbarHostState.showSnackbar(
                                                message = "External signer not installed. Please install Amber or alternatives.",
                                                actionLabel = "Install",
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/ProfileScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/ProfileScreen.kt
@@ -44,28 +44,30 @@ import coop.composeapp.generated.resources.ic_share
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
 import su.reya.coop.shared.getExpressiveFontFamily
 import su.reya.coop.short
+import su.reya.coop.viewmodel.ChatViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun ProfileScreen(pubkey: String) {
+fun ProfileScreen(
+    pubkey: String,
+    chatViewModel: ChatViewModel
+) {
    val pubkey = runCatching { PublicKey.parse(pubkey) }.getOrNull() ?: return

    val context = LocalContext.current
    val snackbarHostState = LocalSnackbarHostState.current
    val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
+    val profileCache = LocalProfileCache.current
    val scope = rememberCoroutineScope()

-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
    val profile by profileFlow.collectAsStateWithLifecycle()

    val metadata = profile?.metadata?.asRecord()
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/RelayScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/RelayScreen.kt
@@ -56,6 +56,7 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_check
@@ -66,15 +67,14 @@ import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.RelayMetadata
 import rust.nostr.sdk.RelayUrl
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.viewmodel.AccountViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun RelayScreen() {
+fun RelayScreen(viewModel: AccountViewModel) {
    val navigator = LocalNavigator.current
    val snackbarHostState = LocalSnackbarHostState.current
-    val nostrViewModel = LocalNostrViewModel.current

    val scope = rememberCoroutineScope()
    val msgRelayList = remember { mutableStateListOf<RelayUrl>() }
@@ -96,8 +96,25 @@ fun RelayScreen() {
    var relayToDelete by remember { mutableStateOf<String?>(null) }

    LaunchedEffect(Unit) {
-        relayList.putAll(nostrViewModel.currentUserRelayList())
-        msgRelayList.addAll(nostrViewModel.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(
@@ -296,6 +313,7 @@ fun RelayScreen() {

    if (openAddRelayDialog) {
        AddRelayDialog(
+            viewModel = viewModel,
            onDismissRequest = { openAddRelayDialog = false },
            onMsgRelayAdded = { newRelay ->
                msgRelayList.add(RelayUrl.parse(newRelay))
@@ -314,20 +332,16 @@ fun RelayScreen() {
            confirmButton = {
                TextButton(
                    onClick = {
-                        scope.launch {
                        if (msgRelayList.size == 1) {
+                            scope.launch {
                                snackbarHostState.showSnackbar("You must have at least one relay")
-                                relayToDelete = null
-                                return@launch
                            }
-                            try {
-                                nostrViewModel.removeMsgRelay(relayToDelete!!)
+                            relayToDelete = null
+                            return@TextButton
+                        }
+                        viewModel.removeMsgRelay(relayToDelete!!)
                        msgRelayList.removeIf { it.toString() == relayToDelete }
                        relayToDelete = null
-                            } catch (e: Exception) {
-                                snackbarHostState.showSnackbar("Failed to remove relay: ${e.message}")
-                            }
-                        }
                    }
                ) {
                    Text("Confirm")
@@ -345,14 +359,12 @@ fun RelayScreen() {
@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
 fun AddRelayDialog(
+    viewModel: AccountViewModel,
    onDismissRequest: () -> Unit,
    onMsgRelayAdded: (newRelay: String) -> Unit,
    onRelayAdded: (newRelay: String, metadata: RelayMetadata?) -> Unit,
 ) {
-    val nostrViewModel = LocalNostrViewModel.current
    val snackbarHostState = LocalSnackbarHostState.current
-
-    val scope = rememberCoroutineScope()
    val focusRequester = remember { FocusRequester() }

    var relayAddress by remember { mutableStateOf("") }
@@ -397,27 +409,25 @@ fun AddRelayDialog(
                    },
                    actions = {
                        IconButton(onClick = {
-                            scope.launch {
                            if (!isError) {
                                when (selected) {
                                    "Messaging" -> {
-                                            nostrViewModel.addMsgRelay(relayAddress)
+                                        viewModel.addMsgRelay(relayAddress)
                                        onMsgRelayAdded(relayAddress)
                                    }

                                    "Inbox" -> {
-                                            nostrViewModel.addInboxRelay(relayAddress)
+                                        viewModel.addInboxRelay(relayAddress)
                                        onRelayAdded(relayAddress, RelayMetadata.WRITE)
                                    }

                                    "Outbox" -> {
-                                            nostrViewModel.addOutboxRelay(relayAddress)
+                                        viewModel.addOutboxRelay(relayAddress)
                                        onRelayAdded(relayAddress, RelayMetadata.READ)
                                    }
                                }
                                onDismissRequest()
                            }
-                            }
                        }) {
                            Icon(
                                painter = painterResource(Res.drawable.ic_check),
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/RequestListScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/RequestListScreen.kt
@@ -27,7 +27,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -36,26 +35,23 @@ import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
-import kotlinx.coroutines.launch
-import su.reya.coop.LocalChatViewModel
 import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.RoomKind
 import su.reya.coop.Screen
+import su.reya.coop.viewmodel.ChatViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
@Composable
-fun RequestListScreen() {
+fun RequestListScreen(viewModel: ChatViewModel) {
    val navigator = LocalNavigator.current
    val snackbarHostState = LocalSnackbarHostState.current
-    val chatViewModel = LocalChatViewModel.current

-    val scope = rememberCoroutineScope()
    val listState = rememberLazyListState()
    val pullToRefreshState = rememberPullToRefreshState()

    var isRefreshing by remember { mutableStateOf(false) }
-    val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()
+    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()

    // Get all request rooms
    val requests = remember(chatRooms) {
@@ -101,11 +97,9 @@ fun RequestListScreen() {
                    isRefreshing = isRefreshing,
                    state = pullToRefreshState,
                    onRefresh = {
-                        scope.launch {
                        isRefreshing = true
-                            chatViewModel.refreshChatRooms()
+                        viewModel.refreshChatRooms()
                        isRefreshing = false
-                        }
                    },
                    indicator = {
                        PullToRefreshDefaults.LoadingIndicator(
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/UpdateProfileScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/UpdateProfileScreen.kt
@@ -4,16 +4,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.shared.ProfileEditor
+import su.reya.coop.viewmodel.AccountViewModel

@Composable
-fun UpdateProfileScreen() {
-    val nostrViewModel = LocalNostrViewModel.current
+fun UpdateProfileScreen(viewModel: AccountViewModel) {
    val navigator = LocalNavigator.current
-
-    val currentUser by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
+    val currentUser by viewModel.currentUserProfile.collectAsStateWithLifecycle()
    val profile = currentUser?.metadata?.asRecord()
+    val isUpdatingProfile by viewModel.isUpdatingProfile.collectAsStateWithLifecycle()

    ProfileEditor(
        title = "Update profile",
@@ -21,9 +20,10 @@ fun UpdateProfileScreen() {
        initialName = profile?.displayName ?: profile?.name ?: "",
        initialBio = profile?.about ?: "",
        initialPicture = profile?.picture,
+        isBusy = isUpdatingProfile,
        onBack = { navigator.goBack() },
        onConfirm = { name, bio, bytes, type ->
-            nostrViewModel.updateProfile(name, bio, bytes, type)
+            viewModel.updateProfile(name, bio, bytes, type)
            navigator.goBack()
        }
    )
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatComponents.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatComponents.kt
@@ -18,52 +18,47 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_cancel
 import coop.composeapp.generated.resources.ic_check_circle
-import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.PublicKey
 import rust.nostr.sdk.Timestamp
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.Room
 import su.reya.coop.humanReadable
 import su.reya.coop.shared.Avatar
 import su.reya.coop.shared.getExpressiveFontFamily
 import su.reya.coop.short
+import su.reya.coop.viewmodel.AccountViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun ScreenerCard(room: Room) {
+fun ScreenerCard(viewModel: AccountViewModel, room: Room) {
    val pubkey = room.members.firstOrNull() ?: return

-    val nostrViewModel = LocalNostrViewModel.current
-    val scope = rememberCoroutineScope()
+    val profileCache = LocalProfileCache.current

    var isContact by remember { mutableStateOf(false) }
    var mutualContacts by remember { mutableStateOf<Set<PublicKey>>(emptySet()) }
    var lastActivity by remember { mutableStateOf<Timestamp?>(null) }

-    val profileFlow = remember(pubkey) { nostrViewModel.getMetadata(pubkey) }
+    val profileFlow = remember(pubkey) { profileCache.getMetadata(pubkey) }
    val profile by profileFlow.collectAsStateWithLifecycle()

    LaunchedEffect(pubkey) {
-        scope.launch {
        // Check contact
-            nostrViewModel.verifyContact(pubkey).let { isContact = it }
+        viewModel.verifyContact(pubkey) { isContact = it }
        // Get mutual contacts
-            nostrViewModel.mutualContacts(pubkey).let { mutualContacts = it }
+        viewModel.mutualContacts(pubkey) { mutualContacts = it }
        // Get the last activity
-            nostrViewModel.verifyActivity(pubkey)?.let { lastActivity = it }
-        }
+        viewModel.verifyActivity(pubkey) { lastActivity = it }
    }

    Column(
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatMessage.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatMessage.kt
@@ -5,7 +5,7 @@ import androidx.compose.animation.expandVertically
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.animation.shrinkVertically
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -26,8 +26,11 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.boundsInWindow
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.LinkAnnotation
 import androidx.compose.ui.text.SpanStyle
@@ -37,6 +40,7 @@ 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
@@ -45,27 +49,25 @@ import su.reya.coop.isImageUrl
 import su.reya.coop.removeImageUrls

@Immutable
-data class MessageUiModel(
-    val id: String,
+data class MessageModel(
+    val id: EventId,
+    val author: PublicKey,
    val annotatedContent: AnnotatedString,
    val images: List<String>,
    val timestamp: String,
-    val isMine: Boolean
+    val isMine: Boolean,
+    val replyEventIds: List<EventId>
 )

@Composable
-fun rememberMessageUiModel(
-    event: UnsignedEvent,
-    currentUserPublicKey: PublicKey?,
-    contentColor: Color
-): MessageUiModel {
-    return remember(event, currentUserPublicKey, contentColor) {
+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 images = URL_REGEX.findAll(content)
-            .map { it.value }
-            .filter { it.isImageUrl() }
-            .toList()
+        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 {
@@ -78,7 +80,6 @@ fun rememberMessageUiModel(
                        url = url,
                        styles = TextLinkStyles(
                            style = SpanStyle(
-                                color = contentColor,
                                textDecoration = TextDecoration.Underline,
                                fontWeight = FontWeight.Medium
                            )
@@ -92,19 +93,26 @@ fun rememberMessageUiModel(
            append(cleanedContent.substring(lastIndex))
        }

-        MessageUiModel(
-            id = event.id()?.toHex() ?: event.hashCode().toString(),
+        MessageModel(
+            id = id,
+            author = event.author(),
            annotatedContent = annotatedString,
            images = images,
            timestamp = event.createdAt().formatAsTime(),
-            isMine = event.author() == currentUserPublicKey
+            isMine = isMine,
+            replyEventIds = replyEventIds
        )
    }
 }

@Composable
-fun ChatMessage(model: MessageUiModel) {
+fun ChatMessage(
+    model: MessageModel,
+    modifier: Modifier = Modifier,
+    onLongClick: (Rect) -> Unit = {}
+) {
    var isMessageClicked by remember { mutableStateOf(false) }
+    var layoutCoordinates by remember { mutableStateOf<LayoutCoordinates?>(null) }

    val bubbleShape = if (model.isMine) {
        RoundedCornerShape(topStart = 20.dp, topEnd = 4.dp, bottomStart = 20.dp, bottomEnd = 20.dp)
@@ -119,27 +127,32 @@ fun ChatMessage(model: MessageUiModel) {
        if (!model.isMine) MaterialTheme.colorScheme.onSurface else MaterialTheme.colorScheme.onPrimaryContainer

    Box(
-        modifier = Modifier
+        modifier = modifier
+            .onGloballyPositioned { layoutCoordinates = it }
            .fillMaxWidth()
            .padding(vertical = 4.dp),
        contentAlignment = if (model.isMine) Alignment.CenterEnd else Alignment.CenterStart
    ) {
        Column(
-            modifier = Modifier.clickable(
+            modifier = Modifier.combinedClickable(
                interactionSource = remember { MutableInteractionSource() },
-                indication = null
-            ) {
-                isMessageClicked = !isMessageClicked
-            },
+                indication = null,
+                onClick = { isMessageClicked = !isMessageClicked },
+                onLongClick = {
+                    layoutCoordinates?.let { coords ->
+                        onLongClick(coords.boundsInWindow())
+                    }
+                }
+            ),
            horizontalAlignment = if (model.isMine) Alignment.End else Alignment.Start,
-            verticalArrangement = Arrangement.spacedBy(8.dp)
+            verticalArrangement = Arrangement.spacedBy(4.dp)
        ) {
            if (model.annotatedContent.isNotBlank()) {
                Surface(
+                    modifier = Modifier.widthIn(max = 280.dp),
                    color = containerColor,
                    contentColor = contentColor,
                    shape = bubbleShape,
-                    modifier = Modifier.widthIn(max = 280.dp)
                ) {
                    Text(
                        text = model.annotatedContent,
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatScreen.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/screens/chat/ChatScreen.kt
@@ -1,11 +1,17 @@
 package su.reya.coop.screens.chat

 import android.app.Activity
+import android.content.ClipData
 import android.content.Intent
 import android.net.Uri
 import android.speech.RecognizerIntent
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -16,24 +22,33 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.ime
+import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.union
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Badge
 import androidx.compose.material3.BadgedBox
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.DropdownMenuGroup
+import androidx.compose.material3.DropdownMenuItem
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.LoadingIndicator
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.MenuDefaults
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.ScaffoldDefaults
 import androidx.compose.material3.SnackbarHost
@@ -45,52 +60,67 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.blur
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.ClipEntry
+import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalWindowInfo
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
 import androidx.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.LocalChatViewModel
 import su.reya.coop.LocalNavigator
-import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalProfileCache
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Room
+import su.reya.coop.RoomUiState
 import su.reya.coop.Screen
-import su.reya.coop.formatAsGroupHeader
-import su.reya.coop.rememberUiState
-import su.reya.coop.roomId
+import su.reya.coop.formatAsGroup
 import su.reya.coop.shared.Avatar
+import su.reya.coop.uiStateFlow
+import su.reya.coop.viewmodel.AccountViewModel
+import su.reya.coop.viewmodel.ChatScreenViewModel

@OptIn(ExperimentalMaterial3ExpressiveApi::class)
@Composable
-fun ChatScreen(id: Long, screening: Boolean = false) {
+fun ChatScreen(
+    viewModel: ChatScreenViewModel,
+    accountViewModel: AccountViewModel,
+    coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) {
    val context = LocalContext.current
    val snackbarHostState = LocalSnackbarHostState.current
+    val clipboardManager = LocalClipboard.current
    val navigator = LocalNavigator.current
-    val nostrViewModel = LocalNostrViewModel.current
-    val chatViewModel = LocalChatViewModel.current
+    val profileCache = LocalProfileCache.current
    val scope = rememberCoroutineScope()
    val listState = rememberLazyListState()

-    // Get current user
-    val currentUser by nostrViewModel.currentUserProfile.collectAsStateWithLifecycle()
-
-    // Get chat room by ID
-    val chatRooms by chatViewModel.chatRooms.collectAsStateWithLifecycle()
+    val id = viewModel.id
+    val currentUser by viewModel.currentUser.collectAsStateWithLifecycle()
+    val chatRooms by viewModel.chatRooms.collectAsStateWithLifecycle()
    val room by remember(id) { derivedStateOf { chatRooms.firstOrNull { it.id == id } } }

    // Show empty screen
@@ -108,32 +138,38 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
        return
    }

-    val roomState by (room as Room).rememberUiState(nostrViewModel, currentUser?.publicKey)
-    var text by remember { mutableStateOf("") }
-    var loading by remember { mutableStateOf(true) }
-    var newOtherMessages by remember { mutableIntStateOf(0) }
-    var requireScreening by remember { mutableStateOf(screening) }
+    val loading = viewModel.loading
+    val newOtherMessages = viewModel.newOtherMessages
+    val requireScreening = viewModel.requireScreening
+    val messages = viewModel.messages

-    val messages = remember { mutableStateListOf<UnsignedEvent>() }
    val groupedMessages =
-        remember { derivedStateOf { messages.groupBy { it.createdAt().formatAsGroupHeader() } } }
+        remember { derivedStateOf { messages.groupBy { it.createdAt().formatAsGroup() } } }
+
+    val roomState by (room as Room).uiStateFlow(profileCache, currentUser?.publicKey)
+        .collectAsStateWithLifecycle(RoomUiState())
+
+    var text by remember { mutableStateOf("") }
+    var selectedMessage by remember { mutableStateOf<Pair<MessageModel, Rect>?>(null) }
+    var replyingTo by remember { mutableStateOf<MessageModel?>(null) }
+
+    val blurAmount by animateDpAsState(
+        targetValue = if (selectedMessage != null) 8.dp else 0.dp,
+        label = "blurAnimation"
+    )

    val sendFile = { uri: Uri ->
        scope.launch {
-            try {
-                // Read file
-                val file = withContext(Dispatchers.IO) {
+            // 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
-                chatViewModel.sendFileMessage(id, file, type)
-            } catch (e: Exception) {
-                snackbarHostState.showSnackbar("Error: ${e.message}")
-            }
+            // Send message (handles errors internally via ViewModel)
+            viewModel.sendFileMessage(file, type)
        }
    }

@@ -151,38 +187,17 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
            }
        }

-    LaunchedEffect(id) {
-        // Get messages
-        val initialMessages = chatViewModel.getChatRoomMessages(id)
-        messages.clear()
-        messages.addAll(initialMessages)
-
-        // Stop loading spinner
-        loading = false
-
-        // Get msg relays for each member
-        chatViewModel.chatRoomConnect(id)
-
-        // Handle new messages
-        chatViewModel.newEvents.collect { event ->
-            if (event.roomId() == id) {
-                if (event.id() !in messages.map { it.id() }) {
-                    messages.add(0, event)
-                }
-            } else {
-                // If the event is not in the current room, it's a new message from another user
-                newOtherMessages++
-            }
-        }
-    }
-
    LaunchedEffect(messages.size) {
        if (messages.isNotEmpty()) {
            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) },
@@ -250,34 +265,51 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
                            .padding(bottom = innerPadding.calculateBottomPadding())
                    ) {
                        if (requireScreening) {
-                        room?.let { ScreenerCard(it) }
+                            room?.let { ScreenerCard(accountViewModel, it) }
                        }

-                    val mineColor = MaterialTheme.colorScheme.onPrimaryContainer
-                    val otherColor = MaterialTheme.colorScheme.onSurface
-
                        when (messages.isNotEmpty()) {
                            true -> {
                                LazyColumn(
                                    modifier = Modifier
                                        .weight(1f)
                                        .fillMaxWidth(),
-                                contentPadding = PaddingValues(16.dp),
-                                reverseLayout = true,
                                    state = listState,
+                                    reverseLayout = true,
+                                    contentPadding = PaddingValues(16.dp),
                                ) {
                                    groupedMessages.value.forEach { (dateHeader, messagesInGroup) ->
                                        items(
                                            items = messagesInGroup,
-                                        key = { it.id()?.toHex() ?: it.hashCode().toString() }
+                                            key = { it.ensureId().id()?.toHex()!! }
                                        ) { event ->
-                                        val isMine = currentUser?.publicKey == event.author()
-                                        val uiModel = rememberMessageUiModel(
-                                            event = event,
-                                            currentUserPublicKey = currentUser?.publicKey,
-                                            contentColor = if (isMine) mineColor else otherColor
+                                            val model =
+                                                rememberMessageModel(event, currentUser?.publicKey)
+
+                                            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
+                                                    }
                                                )
-                                        ChatMessage(model = uiModel)
+                                            }
                                        }
                                        item {
                                            DateSeparator(dateHeader)
@@ -334,7 +366,7 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
                                        )
                                    }
                                    FilledTonalButton(
-                                    onClick = { requireScreening = false },
+                                        onClick = { viewModel.requireScreening = false },
                                        modifier = Modifier
                                            .weight(1f)
                                            .size(ButtonDefaults.MediumContainerHeight)
@@ -348,11 +380,14 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
                            }

                            else -> {
+                                replyingTo?.let {
+                                    ReplyBox(it) { replyingTo = null }
+                                }
                                ChatInput(
                                    value = text,
                                    onValueChange = { text = it },
                                    onSend = {
-                                    chatViewModel.sendMessage(id, text)
+                                        viewModel.sendMessage(text)
                                        text = ""
                                    },
                                    onUpload = {
@@ -365,7 +400,10 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
                                                    RecognizerIntent.EXTRA_LANGUAGE_MODEL,
                                                    RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
                                                )
-                                            putExtra(RecognizerIntent.EXTRA_PROMPT, "Speak now...")
+                                                putExtra(
+                                                    RecognizerIntent.EXTRA_PROMPT,
+                                                    "Speak now..."
+                                                )
                                            }
                                        try {
                                            sttLauncher.launch(intent)
@@ -382,4 +420,196 @@ fun ChatScreen(id: Long, screening: Boolean = false) {
                }
            }
        )
+
+        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) },
+            )
+        }
+    }
 }
--- a/composeApp/src/androidMain/kotlin/su/reya/coop/shared/ProfileEditor.kt
+++ b/composeApp/src/androidMain/kotlin/su/reya/coop/shared/ProfileEditor.kt
@@ -54,6 +54,7 @@ import coil3.compose.AsyncImage
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_plus
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -68,8 +69,10 @@ fun ProfileEditor(
    initialName: String = "",
    initialBio: String = "",
    initialPicture: Any? = null, // Accepts Uri (picked) or String (current URL)
+    isBusy: Boolean = false,
    onBack: () -> Unit,
-    onConfirm: suspend (name: String, bio: String, pictureBytes: ByteArray?, contentType: String?) -> Unit
+    onConfirm: (name: String, bio: String, pictureBytes: ByteArray?, contentType: String?) -> Unit,
+    ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
 ) {
    val context = LocalContext.current
    val snackbarHostState = LocalSnackbarHostState.current
@@ -79,7 +82,6 @@ fun ProfileEditor(
    var name by remember(initialName) { mutableStateOf(initialName) }
    var bio by remember(initialBio) { mutableStateOf(initialBio) }
    var picture by remember(initialPicture) { mutableStateOf(initialPicture) }
-    var isBusy by remember { mutableStateOf(false) }

    val hasPicture = remember(picture) {
        when (picture) {
@@ -267,9 +269,8 @@ fun ProfileEditor(
                            .size(ButtonDefaults.MediumContainerHeight),
                        onClick = {
                            scope.launch {
-                                isBusy = true
                                try {
-                                    val bytes = withContext(Dispatchers.IO) {
+                                    val bytes = withContext(ioDispatcher) {
                                        (picture as? Uri)?.let {
                                            context.contentResolver.openInputStream(it)?.readBytes()
                                        }
@@ -280,7 +281,6 @@ fun ProfileEditor(
                                } catch (e: Exception) {
                                    snackbarHostState.showSnackbar(e.message ?: "Error")
                                }
-                                isBusy = false
                            }
                        },
                        enabled = name.isNotBlank() && !isBusy
--- a/shared/src/commonMain/kotlin/su/reya/coop/Extensions.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/Extensions.kt
@@ -2,18 +2,11 @@ package su.reya.coop

 import rust.nostr.sdk.PublicKey

-fun PublicKey.short(): String {
-    val bech32 = toBech32()
-    return bech32.substring(0, 6) + "..." + bech32.substring(bech32.length - 4)
-}
-
 val URL_REGEX = Regex("(https?://\\S+)", RegexOption.IGNORE_CASE)
-private val imageExtensions = setOf("jpg", "jpeg", "png", "gif", "webp", "bmp")
+private val imageExtensions = setOf("jpg", "jpeg", "png", "gif", "webp", "bmp", "avif")

 fun String.removeImageUrls(): String {
-    return URL_REGEX.replace(this) { result ->
-        if (result.value.isImageUrl()) "" else result.value
-    }.trim()
+    return URL_REGEX.replace(this) { if (it.value.isImageUrl()) "" else it.value }.trim()
 }

 fun String.isImageUrl(): Boolean {
@@ -24,3 +17,8 @@ fun String.isImageUrl(): Boolean {
 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)
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/Room.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/Room.kt
@@ -1,9 +1,5 @@
 package su.reya.coop

-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.State
-import androidx.compose.runtime.remember
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.flowOf
@@ -15,7 +11,7 @@ import kotlinx.datetime.toLocalDateTime
 import rust.nostr.sdk.PublicKey
 import rust.nostr.sdk.Timestamp
 import rust.nostr.sdk.UnsignedEvent
-import su.reya.coop.viewmodel.NostrViewModel
+import su.reya.coop.viewmodel.ProfileCache
 import kotlin.time.Clock
 import kotlin.time.Instant

@@ -41,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()

@@ -67,22 +62,6 @@ data class Room(
        }
    }

-    fun setKind(kind: RoomKind): Room {
-        return this.copy(kind = kind)
-    }
-
-    fun setCreatedAt(createdAt: Timestamp): Room {
-        return this.copy(createdAt = createdAt)
-    }
-
-    fun setSubject(subject: String?): Room {
-        return this.copy(subject = subject)
-    }
-
-    fun setLastMessage(message: String?): Room {
-        return this.copy(lastMessage = message)
-    }
-
    fun isGroup(): Boolean = members.size > 1
 }

@@ -93,7 +72,7 @@ data class RoomUiState(
 )

 fun Room.uiStateFlow(
-    nostrViewModel: NostrViewModel,
+    profileCache: ProfileCache,
    currentUser: PublicKey? = null
 ): Flow<RoomUiState> {
    val displayMembers = if (isGroup()) members.take(2) else members.take(1)
@@ -102,7 +81,7 @@ fun Room.uiStateFlow(
        return flowOf(RoomUiState(name = subject.sanitizeName(), isGroup = isGroup()))
    }

-    return combine(displayMembers.map { nostrViewModel.getMetadata(it) }) { profiles ->
+    return combine(displayMembers.map { profileCache.getMetadata(it) }) { profiles ->
        val names = profiles.mapIndexed { i, profile ->
            profile?.name?.sanitizeName() ?: displayMembers[i].short()
        }
@@ -128,31 +107,13 @@ fun Room.uiStateFlow(
    }
 }

-@Composable
-fun Room.rememberUiState(
-    viewModel: NostrViewModel,
-    currentUser: PublicKey? = null
-): State<RoomUiState> {
-    return remember(this, currentUser) {
-        uiStateFlow(
-            viewModel,
-            currentUser
-        )
-    }.collectAsStateWithLifecycle(RoomUiState())
-}
-
 fun UnsignedEvent.roomId(): Long {
    // Collect the author's public key and all public keys from tags
    val pubkeys: MutableList<PublicKey> = mutableListOf()
    pubkeys.add(this.author())
    pubkeys.addAll(this.tags().publicKeys())
    
-    // Sort and hash the list of public keys
-    val sortedUniqueKeys = pubkeys
-        .distinctBy { it.toBech32() }
-        .sortedBy { it.toBech32() }
-
-    return sortedUniqueKeys.hashCode().toLong()
+    return pubkeys.map { it.toBech32() }.distinct().sorted().hashCode().toLong()
 }

 fun Timestamp.formatAsTime(): String {
@@ -184,7 +145,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
--- a/shared/src/commonMain/kotlin/su/reya/coop/nostr/Messaging.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/nostr/Messaging.kt
@@ -1,5 +1,6 @@
 package su.reya.coop.nostr

+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
@@ -38,12 +39,11 @@ class MessageManager(private val nostr: Nostr) {
    private val client: Client? get() = nostr.client
    private val signer: UniversalSigner get() = nostr.signer

-    val sentEvents: MutableMap<EventId, List<RelayUrl>> = mutableMapOf()
-    val rumorMap: MutableMap<EventId, EventId> = mutableMapOf()
-
    private val _messageSyncState = MutableStateFlow(MessageSyncState())
    val messageSyncState = _messageSyncState.asStateFlow()

+    val rumorMap: MutableMap<EventId, EventId> = mutableMapOf()
+
    fun updateSyncState(update: (MessageSyncState) -> MessageSyncState) {
        _messageSyncState.update(update)
    }
@@ -72,6 +72,8 @@ class MessageManager(private val nostr: Nostr) {
                target = ReqTarget.manual(target),
                id = "gift-wraps"
            )
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to fetch user messages: ${e.message}", e)
        }
@@ -119,7 +121,9 @@ class MessageManager(private val nostr: Nostr) {
            setCachedRumor(event.id(), unsignedEvent)

            return unsignedEvent
-        } catch (e: Throwable) {
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
            println("Failed to unwrap gift ${event.id().toHex()}: ${e.message}")
            return null
        }
@@ -131,7 +135,9 @@ class MessageManager(private val nostr: Nostr) {
            val event = client?.database()?.query(filter)?.first()

            return event?.content()?.let { UnsignedEvent.fromJson(it).ensureId() }
-        } catch (e: Throwable) {
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
            throw IllegalStateException("Failed to get cached rumor: ${e.message}", e)
        }
    }
@@ -155,7 +161,9 @@ class MessageManager(private val nostr: Nostr) {
                .finalizeAsync(Keys.generate())

            client?.database()?.saveEvent(event)
-        } catch (e: Throwable) {
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
            println("Failed to set cached rumor: ${e.message}")
        }
    }
@@ -170,36 +178,35 @@ class MessageManager(private val nostr: Nostr) {

            // Get all DM events
            val filter = Filter().kind(kind).customTags(kTag, listOf("14", "dm"))
-            val events = client?.database()?.query(filter)
+            val events = client?.database()?.query(filter)?.toVec() ?: return null

            // 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]
+                .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()

-                    // Check if the room already exists
-                    if (existingRoom == null || newRoom.createdAt.asSecs() > existingRoom.createdAt.asSecs()) {
-                        val rTag = SingleLetterTag.lowercase(Alphabet.R)
-                        val filter = Filter().kind(kind).pubkey(userPubkey)
-                            .customTag(rTag, newRoom.id.toString())
-
-                        // Determine if it's an ongoing room
-                        val isOngoing =
-                            client?.database()?.query(filter)?.toVec()?.isNotEmpty() ?: false
-
-                        // Append room to map
-                        roomsMap[newRoom.id] =
-                            if (isOngoing) newRoom.copy(kind = RoomKind.Ongoing) else newRoom
+                    // 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
@@ -219,6 +226,8 @@ class MessageManager(private val nostr: Nostr) {
                // Filter out events without public keys (receivers)
                ?.filter { it.tags().publicKeys().isNotEmpty() }
                ?.sortedByDescending { it.createdAt().asSecs() } ?: emptyList()
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to get chat room messages: ${e.message}", e)
        }
@@ -242,6 +251,8 @@ class MessageManager(private val nostr: Nostr) {
                    connectMsgRelays(event)
                }
            }
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to fetch relays: ${e.message}", e)
        }
@@ -321,9 +332,6 @@ class MessageManager(private val nostr: Nostr) {
                )

                if (output != null) {
-                    // Keep track of sent events
-                    sentEvents[output.id] = emptyList()
-
                    // Keep track of rumor IDs
                    val id = rumor.id() ?: throw IllegalStateException("Rumor ID is null")
                    rumorMap[id] = output.id
@@ -334,6 +342,8 @@ class MessageManager(private val nostr: Nostr) {
                    }
                }
            }
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to send message: ${e.message}", e)
        }
--- a/shared/src/commonMain/kotlin/su/reya/coop/nostr/Nostr.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/nostr/Nostr.kt
@@ -1,7 +1,9 @@
 package su.reya.coop.nostr

+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -9,6 +11,7 @@ import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.supervisorScope
+import kotlinx.coroutines.withTimeoutOrNull
 import rust.nostr.sdk.AsyncNostrSigner
 import rust.nostr.sdk.Client
 import rust.nostr.sdk.ClientBuilder
@@ -30,24 +33,15 @@ 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()
-
-    val BOOTSTRAP_RELAYS = listOf(
-        "wss://relay.primal.net",
-        "wss://relay.ditto.pub",
-        "wss://user.kindpag.es",
-    )
-
-    val INDEXER_RELAY = listOf(
-        "wss://indexer.coracle.social",
-    )
-
-    val ALL_RELAYS = BOOTSTRAP_RELAYS + INDEXER_RELAY
 }

-class Nostr {
+class Nostr(
+    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) {
    var client: Client? = null
        private set
    var signer: UniversalSigner = UniversalSigner(Keys.generate())
@@ -59,17 +53,18 @@ class Nostr {

    private val isInitialized = MutableStateFlow(false)

-    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
+    private val _newEvents = MutableSharedFlow<UnsignedEvent>(
+        replay = 0,
+        extraBufferCapacity = 100,
+        onBufferOverflow = BufferOverflow.SUSPEND
+    )
    val newEvents = _newEvents.asSharedFlow()

-    suspend fun emitNewEvent(event: UnsignedEvent) {
-        _newEvents.emit(event)
+    fun emitNewEvent(event: UnsignedEvent) {
+        _newEvents.tryEmit(event)
    }

-    suspend fun init(
-        dbPath: String,
-        logLevel: LogLevel = LogLevel.WARN
-    ) {
+    suspend fun init(dbPath: String, logLevel: LogLevel = LogLevel.WARN) {
        try {
            if (isInitialized.value) return

@@ -105,21 +100,14 @@ class Nostr {
    }

    suspend fun waitUntilInitialized() {
-        isInitialized.first { it }
+        withTimeoutOrNull(30.seconds) { isInitialized.first { it } }
+            ?: throw IllegalStateException("Nostr initialization timed out")
    }

    suspend fun connectBootstrapRelays() {
        relays.connectBootstrapRelays()
    }

-    suspend fun reconnect() {
-        relays.reconnect()
-    }
-
-    suspend fun disconnect() {
-        relays.disconnect()
-    }
-
    suspend fun prune() {
        try {
            client?.database()?.wipe()
@@ -159,7 +147,7 @@ class Nostr {
        var processedCount = 0
        var eoseReceived = false

-        launch(Dispatchers.Default) {
+        launch(defaultDispatcher) {
            for (event in giftWrapQueue) {
                val rumor = messages.extractRumor(event)
                processedCount++
@@ -186,8 +174,6 @@ class Nostr {

            when (notification) {
                is ClientNotification.Message -> {
-                    val relayUrl = notification.relayUrl
-
                    when (val message = notification.message.asEnum()) {
                        is RelayMessageEnum.EventMsg -> {
                            val event = message.event
@@ -241,14 +227,6 @@ class Nostr {
                            }
                        }

-                        is RelayMessageEnum.Ok -> {
-                            if (messages.sentEvents.containsKey(message.eventId)) {
-                                val currentRelays =
-                                    messages.sentEvents[message.eventId] ?: emptyList()
-                                messages.sentEvents[message.eventId] = currentRelays + relayUrl
-                            }
-                        }
-
                        else -> {
                            /* Ignore other message types */
                        }
--- a/shared/src/commonMain/kotlin/su/reya/coop/nostr/ProfileManager.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/nostr/ProfileManager.kt
@@ -4,6 +4,7 @@ import io.ktor.client.HttpClient
 import io.ktor.client.call.body
 import io.ktor.client.request.get
 import io.ktor.client.statement.HttpResponse
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import rust.nostr.sdk.AckPolicy
@@ -26,17 +27,28 @@ import rust.nostr.sdk.ReqTarget
 import rust.nostr.sdk.SendEventTarget
 import rust.nostr.sdk.SubscribeAutoCloseOptions
 import rust.nostr.sdk.Timestamp
+import kotlin.coroutines.cancellation.CancellationException
 import kotlin.time.Duration

 class ProfileManager(private val nostr: Nostr) {
    private val client: Client? get() = nostr.client
    private val signer: UniversalSigner get() = nostr.signer
+    private val httpClient by lazy { HttpClient() }

    private val _metadataUpdates =
-        MutableSharedFlow<Pair<PublicKey, Metadata>>(extraBufferCapacity = 100)
+        MutableSharedFlow<Pair<PublicKey, Metadata>>(
+            replay = 0,
+            extraBufferCapacity = 100,
+            onBufferOverflow = BufferOverflow.SUSPEND
+        )
    val metadataUpdates = _metadataUpdates.asSharedFlow()

-    private val _contactListUpdates = MutableSharedFlow<List<PublicKey>>(extraBufferCapacity = 100)
+    private val _contactListUpdates =
+        MutableSharedFlow<List<PublicKey>>(
+            replay = 0,
+            extraBufferCapacity = 100,
+            onBufferOverflow = BufferOverflow.SUSPEND
+        )
    val contactListUpdates = _contactListUpdates.asSharedFlow()

    suspend fun emitMetadataUpdate(pubkey: PublicKey, metadata: Metadata) {
@@ -69,6 +81,8 @@ class ProfileManager(private val nostr: Nostr) {
            val opts = SubscribeAutoCloseOptions().exitPolicy(ReqExitPolicy.ExitOnEose)

            client?.subscribe(target = target, id = "user-metadata", closeOn = opts)
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to fetch user metadata: ${e.message}", e)
        }
@@ -78,9 +92,11 @@ class ProfileManager(private val nostr: Nostr) {
        try {
            val kind = Kind.fromStd(KindStandard.CONTACT_LIST)
            val filter = Filter().kind(kind).authors(pubkeys).limit(pubkeys.size.toULong())
-            val relays = NostrManager.BOOTSTRAP_RELAYS.map { RelayUrl.parse(it) }
+            val relays = RelayManager.BOOTSTRAP_RELAYS.map { RelayUrl.parse(it) }

            client?.sync(filter, relays)
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            println("Failed to sync mutual contacts: ${e.message}")
        }
@@ -138,19 +154,24 @@ class ProfileManager(private val nostr: Nostr) {
        bio: String? = null,
        picture: String? = null
    ): Metadata {
+        try {
            val currentUser =
                signer.getPublicKeyAsync() ?: throw IllegalStateException("User not signed in")

-        try {
+            // Get the latest metadata event
            val record = getLatestMetadata(currentUser)?.asRecord() ?: MetadataRecord()
-            val newRecord = record.copy(
+
+            // 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
                )
-            val newMetadata = Metadata.fromRecord(newRecord)
-            val event = EventBuilder.metadata(newMetadata).finalizeAsync(signer)
+            )

+            // Send the new metadata event
+            val event = EventBuilder.metadata(newMetadata).finalizeAsync(signer)
            client?.sendEvent(
                event = event,
                target = SendEventTarget.broadcast(),
@@ -158,6 +179,8 @@ class ProfileManager(private val nostr: Nostr) {
            )

            return newMetadata
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to update identity: ${e.message}", e)
        }
@@ -170,6 +193,8 @@ class ProfileManager(private val nostr: Nostr) {
            val event = client?.database()?.query(filter)?.first() ?: return null

            Metadata.fromJson(event.content())
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            println("Failed to get latest metadata: ${e.message}")
            null
@@ -192,6 +217,8 @@ class ProfileManager(private val nostr: Nostr) {
            }

            return results
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            println("Failed to get all cache metadata: ${e.message}")
            return emptyMap()
@@ -211,11 +238,13 @@ class ProfileManager(private val nostr: Nostr) {

            // Construct request target
            val target = mutableMapOf<RelayUrl, List<Filter>>()
-            NostrManager.BOOTSTRAP_RELAYS.forEach { relay ->
+            RelayManager.BOOTSTRAP_RELAYS.forEach { relay ->
                target[RelayUrl.parse(relay)] = listOf(filter)
            }

            client?.subscribe(target = ReqTarget.manual(target), closeOn = opts)
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to fetch metadata batch: ${e.message}", e)
        }
@@ -231,6 +260,8 @@ class ProfileManager(private val nostr: Nostr) {
                target = SendEventTarget.broadcast(),
                ackPolicy = AckPolicy.none(),
            )
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to set contact list: ${e.message}", e)
        }
@@ -242,6 +273,8 @@ class ProfileManager(private val nostr: Nostr) {
            val bodyString: String = response.body()

            return Nip05Profile.fromJson(address, bodyString)
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to fetch profile from address: ${e.message}", e)
        }
@@ -250,9 +283,11 @@ class ProfileManager(private val nostr: Nostr) {
    suspend fun searchByAddress(query: String): PublicKey {
        try {
            val address = Nip05Address.parse(query)
-            val profile = profileFromAddress(HttpClient(), address)
+            val profile = profileFromAddress(httpClient, address)

            return profile.publicKey()
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to search address: ${e.message}", e)
        }
@@ -288,6 +323,8 @@ class ProfileManager(private val nostr: Nostr) {
            }

            return results
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to search nostr: ${e.message}", e)
        }
@@ -297,7 +334,7 @@ class ProfileManager(private val nostr: Nostr) {
        try {
            val filter = Filter().author(pubkey).limit(3u)
            val target = mutableMapOf<RelayUrl, List<Filter>>()
-            NostrManager.BOOTSTRAP_RELAYS.forEach { relay ->
+            RelayManager.BOOTSTRAP_RELAYS.forEach { relay ->
                target[RelayUrl.parse(relay)] = listOf(filter)
            }

@@ -307,6 +344,8 @@ class ProfileManager(private val nostr: Nostr) {
            )

            return events?.first()?.createdAt()
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to get latest activity: ${e.message}", e)
        }
@@ -324,6 +363,8 @@ class ProfileManager(private val nostr: Nostr) {
            val pubkeys = events?.first()?.tags()?.publicKeys() ?: listOf()

            return pubkeys.contains(pubkey)
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to get mutual contacts: ${e.message}", e)
        }
@@ -345,6 +386,8 @@ class ProfileManager(private val nostr: Nostr) {
            }

            return contacts.toSet()
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            throw IllegalStateException("Failed to get mutual contacts: ${e.message}", e)
        }
--- a/shared/src/commonMain/kotlin/su/reya/coop/nostr/RelayManager.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/nostr/RelayManager.kt
@@ -20,14 +20,28 @@ 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() {
-        NostrManager.BOOTSTRAP_RELAYS.forEach { url ->
+        BOOTSTRAP_RELAYS.forEach { url ->
            client?.addRelay(RelayUrl.parse(url))
        }
-        NostrManager.INDEXER_RELAY.forEach { url ->
+        INDEXER_RELAY.forEach { url ->
            client?.addRelay(
                url = RelayUrl.parse(url),
                capabilities = RelayCapabilities.gossip()
@@ -38,7 +52,7 @@ class RelayManager(private val nostr: Nostr) {
    }

    suspend fun reconnect() {
-        NostrManager.ALL_RELAYS.forEach { url ->
+        ALL_RELAYS.forEach { url ->
            try {
                client?.relay(RelayUrl.parse(url)).let { relay ->
                    if (relay != null) {
@@ -54,7 +68,7 @@ class RelayManager(private val nostr: Nostr) {
    }

    suspend fun disconnect() {
-        NostrManager.ALL_RELAYS.forEach { url ->
+        ALL_RELAYS.forEach { url ->
            try {
                client?.disconnectRelay(RelayUrl.parse(url))
            } catch (e: Exception) {
@@ -104,6 +118,32 @@ class RelayManager(private val nostr: Nostr) {
        return msgRelayList
    }

+    suspend fun getRelayList(publicKey: PublicKey): Map<RelayUrl, RelayMetadata?> {
+        try {
+            val kind = Kind.fromStd(KindStandard.RELAY_LIST)
+            val filter = Filter().kind(kind).author(publicKey).limit(1u)
+            val events = client?.database()?.query(filter)
+
+            return extractRelayList(events?.toVec()?.firstOrNull() ?: return emptyMap())
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to get relay list: ${e.message}", e)
+        }
+    }
+
+    suspend fun setRelayList(relays: Map<RelayUrl, RelayMetadata?>) {
+        try {
+            val event = EventBuilder.relayList(relays).finalizeAsync(signer)
+
+            client?.sendEvent(
+                event = event,
+                target = SendEventTarget.broadcast(),
+                ackPolicy = AckPolicy.none(),
+            )
+        } catch (e: Exception) {
+            throw IllegalStateException("Failed to set msg relays: ${e.message}", e)
+        }
+    }
+
    suspend fun setMsgRelays(urls: List<RelayUrl>) {
        try {
            val event = EventBuilder.nip17RelayList(urls).finalizeAsync(signer)
@@ -154,30 +194,4 @@ class RelayManager(private val nostr: Nostr) {
            throw IllegalStateException("Failed to fetch msg relays: ${e.message}", e)
        }
    }
-
-    suspend fun getRelayList(publicKey: PublicKey): Map<RelayUrl, RelayMetadata?> {
-        try {
-            val kind = Kind.fromStd(KindStandard.RELAY_LIST)
-            val filter = Filter().kind(kind).author(publicKey).limit(1u)
-            val events = client?.database()?.query(filter)
-
-            return extractRelayList(events?.toVec()?.firstOrNull() ?: return emptyMap())
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to get relay list: ${e.message}", e)
-        }
-    }
-
-    suspend fun setRelaylist(relays: Map<RelayUrl, RelayMetadata?>) {
-        try {
-            val event = EventBuilder.relayList(relays).finalizeAsync(signer)
-
-            client?.sendEvent(
-                event = event,
-                target = SendEventTarget.broadcast(),
-                ackPolicy = AckPolicy.none(),
-            )
-        } catch (e: Exception) {
-            throw IllegalStateException("Failed to set msg relays: ${e.message}", e)
-        }
-    }
 }
--- a/shared/src/commonMain/kotlin/su/reya/coop/nostr/Signer.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/nostr/Signer.kt
@@ -29,17 +29,15 @@ 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
        }
+    }

    override suspend fun getPublicKeyAsync(): PublicKey? {
        return get().getPublicKeyAsync()
--- a/shared/src/commonMain/kotlin/su/reya/coop/repository/AccountRepository.kt
+++ b/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}")
+            }
+        }
+    }
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/repository/ChatRepository.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/repository/ChatRepository.kt
@@ -0,0 +1,255 @@
+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 ->
+                    updateRoomState(event)
+                }
+            }
+        }
+    }
+
+    fun createChatRoom(to: List<PublicKey>): Long {
+        try {
+            if (to.isEmpty()) {
+                throw IllegalArgumentException("At least one recipient is required")
+            }
+
+            // Get current user
+            val currentUser = nostr.signer.publicKeyFlow.value
+                ?: throw IllegalStateException("User not signed in")
+
+            // Construct the rumor event
+            val rumor = EventBuilder(Kind.fromStd(KindStandard.PRIVATE_DIRECT_MESSAGE), "")
+                .tags(to.map { Tag.publicKey(it) })
+                .finalizeUnsigned(currentUser)
+
+            // Check if the room already exists
+            val id = rumor.roomId()
+            val existingRoom = _state.value.rooms[id]
+
+            // If the room already exists, return its ID
+            if (existingRoom != null) {
+                return existingRoom.id
+            }
+
+            // Create a room from the rumor event
+            val room = Room.new(rumor, currentUser)
+
+            // Update the chat rooms state
+            _state.update { it.copy(rooms = it.rooms + (room.id to room)) }
+
+            return room.id
+        } catch (e: Exception) {
+            throw IllegalArgumentException("Failed to create room: ${e.message}")
+        }
+    }
+
+    fun getChatRoom(id: Long): Room? {
+        return _state.value.rooms[id]
+    }
+
+    fun 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 = {
+                        scope.launch(defaultDispatcher) {
+                            updateRoomState(it, roomId)
+                        }
+                    },
+                )
+            } catch (e: Exception) {
+                showError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun sendFileMessage(
+        roomId: Long,
+        file: ByteArray?,
+        contentType: String? = "image/jpeg",
+        replies: List<EventId> = emptyList()
+    ) {
+        if (file == null) return
+
+        scope.launch {
+            try {
+                val uri = mediaRepository.blossomUpload(nostr.signer.get(), file, contentType)
+                if (uri != null) sendMessage(roomId, uri, replies)
+            } catch (e: Exception) {
+                showError("File upload failed: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun updateRoomState(event: UnsignedEvent, roomId: Long = event.roomId()) {
+        val currentUser = nostr.signer.getPublicKeyAsync() ?: return
+
+        _state.update { currentState ->
+            val rooms = currentState.rooms.toMutableMap()
+            val existingRoom = rooms[roomId]
+
+            if (existingRoom == null) {
+                // New room discovery
+                val newRoom = Room.new(event, currentUser, roomId)
+                rooms[newRoom.id] = newRoom
+            } else if (event.createdAt().asSecs() >= existingRoom.createdAt.asSecs()) {
+                // Only update preview if message is newer (handles sync/late arrivals)
+                rooms[roomId] = existingRoom.copy(
+                    lastMessage = event.content(),
+                    createdAt = event.createdAt()
+                )
+            } else {
+                // Don't update the room list state for older messages
+                return@update currentState
+            }
+            currentState.copy(rooms = rooms)
+        }
+
+        // Notify subscribers about the new event (for the active chat screen)
+        _newEvents.tryEmit(event)
+    }
+
+    fun resetInternalState() {
+        _state.update {
+            it.copy(
+                rooms = emptyMap(),
+                isPartialProcessedGiftWrap = false,
+            )
+        }
+    }
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/repository/ErrorRepository.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/repository/ErrorRepository.kt
@@ -1,13 +0,0 @@
-package su.reya.coop.repository
-
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.receiveAsFlow
-
-object ErrorRepository {
-    private val _errors = Channel<String>(Channel.BUFFERED)
-    val errors = _errors.receiveAsFlow()
-
-    fun showError(message: String) {
-        _errors.trySend(message)
-    }
-}
--- a/shared/src/commonMain/kotlin/su/reya/coop/repository/MediaRepository.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/repository/MediaRepository.kt
@@ -3,6 +3,7 @@ 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
@@ -31,6 +32,8 @@ class MediaRepository {
                signer = signer,
            )
            descriptor?.url
+        } catch (e: CancellationException) {
+            throw e
        } catch (e: Exception) {
            println("Upload failed: ${e.message}")
            null
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/AccountViewModel.kt
+++ b/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)
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/AuthViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/AuthViewModel.kt
@@ -1,225 +0,0 @@
-package su.reya.coop.viewmodel
-
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withTimeoutOrNull
-import rust.nostr.sdk.AsyncNostrSigner
-import rust.nostr.sdk.EncryptedSecretKey
-import rust.nostr.sdk.Keys
-import rust.nostr.sdk.NostrConnect
-import rust.nostr.sdk.NostrConnectUri
-import rust.nostr.sdk.PublicKey
-import su.reya.coop.AppStorage
-import su.reya.coop.nostr.ExternalSignerHandler
-import su.reya.coop.nostr.ExternalSignerProxy
-import su.reya.coop.nostr.Nostr
-import su.reya.coop.nostr.SignerPermissions
-import su.reya.coop.repository.MediaRepository
-import kotlin.time.Duration.Companion.seconds
-
-data class AuthState(
-    val signerRequired: Boolean? = null,
-    val isNotificationBannerDismissed: Boolean = false,
-)
-
-class AuthViewModel(
-    private val nostr: Nostr,
-    private val storage: AppStorage,
-    private val externalSignerHandler: ExternalSignerHandler? = null,
-) : BaseViewModel() {
-    private val mediaRepository = MediaRepository()
-
-    companion object {
-        private const val KEY_USER_SIGNER = "user_signer"
-        private const val KEY_APP_KEYS = "app_keys"
-        private const val KEY_BANNER_DISMISSED = "notification_banner_dismissed"
-    }
-
-    private val _state = MutableStateFlow(AuthState())
-    val state = _state.asStateFlow()
-
-    init {
-        // Check if the notification banner has been dismissed
-        checkNotificationBannerDismissedStatus()
-
-        // Check local stored secret (secret key or bunker)
-        login()
-    }
-
-    private fun checkNotificationBannerDismissedStatus() {
-        viewModelScope.launch {
-            val dismissed = storage.get(KEY_BANNER_DISMISSED) == "true"
-            _state.update { it.copy(isNotificationBannerDismissed = dismissed) }
-        }
-    }
-
-    private fun login() {
-        viewModelScope.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 = {}) {
-        viewModelScope.launch {
-            try {
-                // Reset the nostr signer and prune the database
-                nostr.signer.switch(Keys.generate())
-                nostr.prune()
-            } catch (e: Exception) {
-                showError("Logout encountered an error: ${e.message}")
-            } finally {
-                // Clear credentials from persistent storage
-                storage.clear(KEY_USER_SIGNER)
-                storage.clear(KEY_BANNER_DISMISSED)
-                // Call cleanup callback (e.g. to reset other ViewModels)
-                onLogout()
-                // Reset local states
-                _state.update { it.copy(signerRequired = true) }
-            }
-        }
-    }
-
-    fun dismissNotificationBanner() {
-        viewModelScope.launch {
-            storage.set(KEY_BANNER_DISMISSED, "true")
-            _state.update { it.copy(isNotificationBannerDismissed = true) }
-        }
-    }
-
-    private suspend fun getOrInitAppKeys(): Keys {
-        val secret = storage.getSecret(KEY_APP_KEYS)
-        // If app keys are already stored, use them
-        if (secret != null) return Keys.parse(secret)
-        // Generate new app keys and save to the secret storage
-        val keys = Keys.generate()
-        storage.setSecret(KEY_APP_KEYS, keys.secretKey().toBech32())
-        return keys
-    }
-
-    private suspend fun createSigner(
-        secret: String,
-        password: String? = null
-    ): Pair<AsyncNostrSigner, String?> {
-        return when {
-            secret.startsWith("nsec1") -> Keys.parse(secret) to null
-
-            secret.startsWith("ncryptsec1") -> {
-                if (password == null) throw IllegalArgumentException("Password is required")
-                val enc = EncryptedSecretKey.fromBech32(secret)
-                val secret = enc.decrypt(password)
-                val keys = Keys(secret)
-
-                keys to keys.secretKey().toBech32()
-            }
-
-            secret.startsWith("bunker://") -> {
-                val appKeys = getOrInitAppKeys()
-                val bunker = NostrConnectUri.parse(secret)
-                val timeout = 50.seconds
-                NostrConnect(uri = bunker, appKeys, timeout, null) to null
-            }
-
-            secret.startsWith("nip55://") -> {
-                val handler = externalSignerHandler
-                    ?: throw IllegalStateException("External signer not available on this platform")
-
-                // Format: nip55://packageName/hexPubkey
-                val parts = secret.removePrefix("nip55://").split("/", limit = 2)
-                val packageName = parts[0]
-                val pubkey = PublicKey.parse(parts[1])
-
-                handler.setPackageName(packageName)
-                ExternalSignerProxy(handler, pubkey) to null
-            }
-
-            else -> throw IllegalArgumentException("Invalid secret format")
-        }
-    }
-
-    suspend fun importIdentity(secret: String, password: String? = null) {
-        val (signer, decryptedSecret) = createSigner(secret, password)
-        // Update signer
-        nostr.setSigner(signer)
-        // Persist the secret in the secret storage
-        storage.setSecret(KEY_USER_SIGNER, decryptedSecret ?: secret)
-        // Update local states
-        _state.update { it.copy(signerRequired = false) }
-    }
-
-    suspend fun connectExternalSigner() {
-        val handler = externalSignerHandler ?: throw IllegalStateException("Signer not available")
-
-        val permissions = SignerPermissions.toJson(
-            listOf(
-                SignerPermissions.signEvent(0),
-                SignerPermissions.signEvent(3),
-                SignerPermissions.signEvent(10000),
-                SignerPermissions.signEvent(10050),
-                SignerPermissions.signEvent(10063),
-                SignerPermissions.signEvent(22242),
-                SignerPermissions.signEvent(30030),
-                SignerPermissions.signEvent(30315),
-                SignerPermissions.nip44Encrypt(),
-                SignerPermissions.nip44Decrypt(),
-            )
-        )
-
-        val result = handler.getPublicKey(permissions) ?: throw Exception("Rejected")
-        val signer = ExternalSignerProxy(handler, result.pubkey)
-
-        // Update signer
-        nostr.setSigner(signer)
-        // Store the signer in the secret storage
-        storage.setSecret(KEY_USER_SIGNER, "nip55://${result.packageName}/${result.pubkey.toHex()}")
-        // Update local states
-        _state.update { it.copy(signerRequired = false) }
-    }
-
-    fun isExternalSignerAvailable(): Boolean {
-        return externalSignerHandler?.isAvailable() == true
-    }
-
-    suspend fun createIdentity(
-        name: String,
-        bio: String?,
-        picture: ByteArray?,
-        contentType: String? = null
-    ) {
-        val keys = Keys.generate()
-        val secret = keys.secretKey().toBech32()
-        val avatarUrl = picture?.let {
-            mediaRepository.blossomUpload(keys, it, contentType ?: "image/jpeg")
-        }
-        // Create identity
-        nostr.profiles.createIdentity(keys = keys, name = name, bio = bio, picture = avatarUrl)
-        // Persist the secret in the secret storage
-        storage.setSecret(KEY_USER_SIGNER, secret)
-        // Update local states
-        _state.update { it.copy(signerRequired = false) }
-    }
-}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/BaseViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/BaseViewModel.kt
@@ -1,10 +0,0 @@
-package su.reya.coop.viewmodel
-
-import androidx.lifecycle.ViewModel
-import su.reya.coop.repository.ErrorRepository
-
-abstract class BaseViewModel : ViewModel() {
-    protected fun showError(message: String) {
-        ErrorRepository.showError(message)
-    }
-}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatScreenViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatScreenViewModel.kt
@@ -0,0 +1,74 @@
+package su.reya.coop.viewmodel
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import rust.nostr.sdk.EventId
+import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.Profile
+import su.reya.coop.Room
+import su.reya.coop.repository.AccountRepository
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.roomId
+
+class ChatScreenViewModel(
+    val id: Long,
+    screening: Boolean,
+    accountRepository: AccountRepository,
+    private val chatRepository: ChatRepository,
+) : ViewModel(), ErrorHost by chatRepository {
+    val currentUser: StateFlow<Profile?> = accountRepository.currentUserProfile
+    val chatRooms: StateFlow<List<Room>> = chatRepository.chatRooms
+
+    var loading by mutableStateOf(true)
+    var newOtherMessages by mutableIntStateOf(0)
+    var requireScreening by mutableStateOf(screening)
+    val messages = mutableStateListOf<UnsignedEvent>()
+
+    init {
+        loadMessages()
+        connect()
+        observeNewEvents()
+    }
+
+    private fun loadMessages() {
+        chatRepository.loadChatRoomMessages(id) { initialMessages ->
+            messages.clear()
+            messages.addAll(initialMessages.distinctBy { it.id() })
+            loading = false
+        }
+    }
+
+    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)
+    }
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ChatViewModel.kt
@@ -1,260 +1,21 @@
 package su.reya.coop.viewmodel

-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import rust.nostr.sdk.EventBuilder
-import rust.nostr.sdk.EventId
-import rust.nostr.sdk.Kind
-import rust.nostr.sdk.KindStandard
+import androidx.lifecycle.ViewModel
+import kotlinx.coroutines.flow.StateFlow
 import rust.nostr.sdk.PublicKey
-import rust.nostr.sdk.RelayUrl
-import rust.nostr.sdk.Tag
-import rust.nostr.sdk.UnsignedEvent
 import su.reya.coop.Room
-import su.reya.coop.nostr.Nostr
-import su.reya.coop.repository.MediaRepository
-import su.reya.coop.roomId
+import su.reya.coop.repository.ChatRepository
+import su.reya.coop.repository.ChatState

-data class ChatState(
-    val rooms: Set<Room> = emptySet(),
-    val isSyncing: Boolean = false,
-    val isPartialProcessedGiftWrap: Boolean = false,
-)
+class ChatViewModel(
+    private val repository: ChatRepository,
+) : ViewModel(), ErrorHost by repository {
+    val state: StateFlow<ChatState> = repository.state
+    val chatRooms: StateFlow<List<Room>> = repository.chatRooms
+    val isSyncing: StateFlow<Boolean> = repository.isSyncing
+    val isPartialProcessedGiftWrap: StateFlow<Boolean> = repository.isPartialProcessedGiftWrap

-class ChatViewModel(private val nostr: Nostr) : BaseViewModel() {
-    private val mediaRepository = MediaRepository()
-
-    private val _state = MutableStateFlow(ChatState())
-    val state = combine(
-        _state,
-        nostr.messages.messageSyncState
-    ) { local, state -> local.copy(isSyncing = state.isSyncing) }.stateIn(
-        viewModelScope,
-        SharingStarted.WhileSubscribed(5000),
-        ChatState()
-    )
-
-    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
-    val newEvents = _newEvents.asSharedFlow()
-
-    private val _sentReports = MutableSharedFlow<Map<EventId, List<RelayUrl>>>()
-    val sentReport = _sentReports.asSharedFlow()
-
-    val chatRooms = state.map { it.rooms }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptySet())
-
-    val isSyncing = state.map { it.isSyncing }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
-
-    val isPartialProcessedGiftWrap = state.map { it.isPartialProcessedGiftWrap }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
-
-    init {
-        viewModelScope.launch {
-            nostr.waitUntilInitialized()
-
-            // Observe message sync progress
-            launch {
-                nostr.messages.messageSyncState.collect { syncState ->
-                    // When at least some messages are processed, allow UI to show the list
-                    if (syncState.processedCount > 0 || !syncState.isSyncing) {
-                        _state.update { it.copy(isPartialProcessedGiftWrap = true) }
-                    }
-
-                    // Refresh UI every 10 messages OR when sync is fully done
-                    if (syncState.processedCount % 10 == 0 || !syncState.isSyncing) {
-                        refreshChatRooms()
-                    }
-                }
-            }
-
-            // Observe new messages
-            launch {
-                nostr.newEvents.collect { event ->
-                    val roomId = event.roomId()
-                    val existingRoom = _state.value.rooms.firstOrNull { it.id == roomId }
-
-                    if (existingRoom == null) {
-                        val currentUser = nostr.signer.getPublicKeyAsync() ?: return@collect
-                        val newRoom = Room.new(event, currentUser)
-                        _state.update {
-                            it.copy(
-                                rooms = (it.rooms + newRoom).sortedDescending().toSet()
-                            )
-                        }
-                    } else {
-                        updateRoomList(roomId, event)
-                    }
-
-                    _newEvents.emit(event)
-                }
-            }
-
-            // Initial load of rooms
-            refreshChatRooms()
-        }
-    }
-
-    fun createChatRoom(to: List<PublicKey>): Long {
-        try {
-            if (to.isEmpty()) {
-                throw IllegalArgumentException("At least one recipient is required")
-            }
-
-            // Get current user
-            val currentUser = nostr.signer.publicKeyFlow.value
-                ?: throw IllegalStateException("User not signed in")
-
-            // Construct the rumor event
-            val rumor = EventBuilder(Kind.fromStd(KindStandard.PRIVATE_DIRECT_MESSAGE), "")
-                .tags(to.map { Tag.publicKey(it) })
-                .finalizeUnsigned(currentUser)
-
-            // Check if the room already exists
-            val id = rumor.roomId()
-            val existingRoom = _state.value.rooms.firstOrNull { it.id == id }
-
-            // If the room already exists, return its ID
-            if (existingRoom != null) {
-                return existingRoom.id
-            }
-
-            // Create a room from the rumor event
-            val room = Room.new(rumor, currentUser)
-
-            // Update the chat rooms state
-            _state.update { it.copy(rooms = (it.rooms + room).sortedDescending().toSet()) }
-
-            return room.id
-        } catch (e: Exception) {
-            throw IllegalArgumentException("Failed to create room: ${e.message}")
-        }
-    }
-
-    fun getChatRoom(id: Long): Room? {
-        return _state.value.rooms.firstOrNull { it.id == id }
-    }
-
-    suspend fun refreshChatRooms() {
-        try {
-            val rooms = nostr.messages.getChatRooms() ?: emptySet()
-            _state.update { currentState ->
-                val merged = currentState.rooms.associateBy { it.id }.toMutableMap()
-                // Add or update rooms from the database
-                rooms.forEach { room ->
-                    merged[room.id] = room
-                }
-                // Return as a sorted set to maintain UI consistency
-                currentState.copy(rooms = merged.values.sortedDescending().toSet())
-            }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun getChatRoomMessages(roomId: Long): List<UnsignedEvent> {
-        try {
-            return nostr.messages.getChatRoomMessages(roomId)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-
-        return emptyList()
-    }
-
-    fun chatRoomConnect(roomId: Long) {
-        viewModelScope.launch {
-            try {
-                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
-                val members = room.members
-
-                nostr.messages.chatRoomConnect(members.toList())
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    fun sendMessage(roomId: Long, message: String, replies: List<EventId> = emptyList()) {
-        if (message.isEmpty()) {
-            showError("Message cannot be empty")
-        }
-        viewModelScope.launch {
-            try {
-                val room = getChatRoom(roomId) ?: throw IllegalArgumentException("Room not found")
-                nostr.messages.sendMessage(
-                    to = room.members,
-                    content = message,
-                    subject = room.subject,
-                    replies = replies,
-                    onRumorCreated = { event ->
-                        updateRoomList(roomId, event)
-                        viewModelScope.launch { _newEvents.emit(event) }
-                    },
-                )
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun sendFileMessage(
-        roomId: Long,
-        file: ByteArray?,
-        contentType: String? = "image/jpeg",
-        replies: List<EventId> = emptyList()
-    ) {
-        if (file == null) return
-
-        try {
-            val uri = mediaRepository.blossomUpload(nostr.signer.get(), file, contentType)
-            if (uri != null) sendMessage(roomId, uri, replies)
-        } catch (e: Exception) {
-            throw IllegalArgumentException("Error: ${e.message}")
-        }
-    }
-
-    fun isMessageSent(id: EventId): Boolean {
-        val giftWrapId = nostr.messages.rumorMap[id]
-
-        if (giftWrapId != null) {
-            val isSent = nostr.messages.sentEvents[giftWrapId]?.isNotEmpty() ?: false
-            return isSent
-        } else {
-            return false
-        }
-    }
-
-    private fun updateRoomList(roomId: Long, newMessage: UnsignedEvent) {
-        _state.update { currentState ->
-            val updatedRooms = currentState.rooms.map { room ->
-                if (room.id == roomId) {
-                    room.copy(
-                        lastMessage = newMessage.content(),
-                        createdAt = newMessage.createdAt()
-                    )
-                } else {
-                    room
-                }
-            }.sortedDescending().toSet()
-            currentState.copy(rooms = updatedRooms)
-        }
-    }
-
-    fun resetInternalState() {
-        _state.update {
-            it.copy(
-                rooms = emptySet(),
-                isPartialProcessedGiftWrap = false,
-            )
-        }
-    }
+    fun createChatRoom(to: List<PublicKey>): Long = repository.createChatRoom(to)
+    fun refreshChatRooms() = repository.refreshChatRooms()
+    fun resetInternalState() = repository.resetInternalState()
 }
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ErrorHost.kt
+++ b/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)
+    }
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/NostrViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/NostrViewModel.kt
@@ -1,444 +0,0 @@
-package su.reya.coop.viewmodel
-
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.awaitCancellation
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withTimeoutOrNull
-import rust.nostr.sdk.PublicKey
-import rust.nostr.sdk.RelayMetadata
-import rust.nostr.sdk.RelayUrl
-import rust.nostr.sdk.Timestamp
-import su.reya.coop.Profile
-import su.reya.coop.nostr.Nostr
-import su.reya.coop.repository.MediaRepository
-import kotlin.time.Clock
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.Duration.Companion.seconds
-
-data class NostrAppState(
-    val isBusy: Boolean = false,
-    val isRelayListEmpty: Boolean = false,
-)
-
-class NostrViewModel(private val nostr: Nostr) : BaseViewModel() {
-    private val mediaRepository = MediaRepository()
-
-    private val alwaysRunTasks = flow {
-        coroutineScope {
-            val observerJob = launch { runObserver() }
-            val batchingJob = launch { runMetadataBatching() }
-            try {
-                emit(Unit)
-                awaitCancellation()
-            } finally {
-                observerJob.cancel()
-                batchingJob.cancel()
-            }
-        }
-    }
-
-    private val _appState = MutableStateFlow(NostrAppState())
-    val appState: StateFlow<NostrAppState> =
-        combine(_appState, alwaysRunTasks) { state, _ -> state }.stateIn(
-            scope = viewModelScope,
-            started = SharingStarted.WhileSubscribed(5000),
-            initialValue = NostrAppState()
-        )
-
-    private val _contactList = MutableStateFlow<Set<PublicKey>>(emptySet())
-    val contactList = _contactList.asStateFlow()
-
-    private val profilesMutex = Mutex()
-    private val profiles = mutableMapOf<PublicKey, MutableStateFlow<Profile?>>()
-    private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
-    private val seenPublicKeys = mutableSetOf<PublicKey>()
-    
-    val isRelayListEmpty = appState.map { it.isRelayListEmpty }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), false)
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    val currentUserProfile = nostr.signer.publicKeyFlow
-        .flatMapLatest { pubkey ->
-            if (pubkey != null) getMetadata(pubkey) else flowOf(null)
-        }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
-
-    init {
-        // Automatically reconnect bootstrap relays
-        reconnect()
-
-        // Observe the signer state and verify the relay list
-        observeSignerAndCheckRelays()
-
-        // Get all local stored metadata
-        getCacheMetadata()
-    }
-
-    private fun reconnect() {
-        viewModelScope.launch {
-            nostr.waitUntilInitialized()
-            nostr.reconnect()
-        }
-    }
-
-    private suspend fun runObserver() = coroutineScope {
-        // Observe contact list updates
-        launch {
-            nostr.profiles.contactListUpdates.collect { contacts ->
-                _contactList.value = contacts.toSet()
-            }
-        }
-
-        // Observe metadata updates
-        launch {
-            nostr.profiles.metadataUpdates.collect { (pubkey, metadata) ->
-                updateMetadata(pubkey, Profile(pubkey, metadata))
-            }
-        }
-    }
-
-    private suspend fun runMetadataBatching() = coroutineScope {
-        // Wait until the client is ready
-        nostr.waitUntilInitialized()
-
-        val batch = mutableSetOf<PublicKey>()
-        val timeout = 500L // 500ms timeout for batching
-
-        while (true) {
-            // Get the first pubkey
-            val firstKey = metadataRequestChannel.receive()
-            batch.add(firstKey)
-
-            // Get current time
-            val lastFlushTime = Clock.System.now().toEpochMilliseconds()
-
-            while (batch.isNotEmpty()) {
-                // Get the next pubkey
-                val nextKey = withTimeoutOrNull(timeout.milliseconds) {
-                    metadataRequestChannel.receive()
-                }
-
-                // Only add the pubkey if it's not null
-                if (nextKey != null) batch.add(nextKey)
-
-                // Get current time
-                val now = Clock.System.now().toEpochMilliseconds()
-
-                // Check if the batch is full or timeout has passed
-                if (batch.size >= 10 || (now - lastFlushTime) >= timeout || nextKey == null) {
-                    val keysToRequest = batch.toList()
-                    batch.clear()
-
-                    nostr.profiles.fetchMetadataBatch(keysToRequest)
-                }
-            }
-        }
-    }
-
-    private fun getCacheMetadata() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            nostr.profiles.getAllCacheMetadata().forEach { (pubkey, metadata) ->
-                // Update the metadata state
-                updateMetadata(pubkey, Profile(pubkey, metadata))
-                // Update seenPublicKeys to avoid duplicate requests
-                seenPublicKeys.add(pubkey)
-            }
-        }
-    }
-
-    private fun observeSignerAndCheckRelays() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            // Wait until a signer is explicitly set (which updates publicKeyFlow)
-            val currentUser = nostr.signer.publicKeyFlow.filterNotNull().first()
-
-            // Get all metadata for the current user
-            nostr.profiles.getUserMetadata()
-
-            // Small delay to ensure all relays are connected
-            delay(2.seconds)
-
-            // Check if the relay list is empty
-            val relays = nostr.relays.getMsgRelays(currentUser)
-            if (relays.isEmpty()) _appState.update { it.copy(isRelayListEmpty = true) }
-        }
-    }
-
-    private fun requestMetadata(pubkey: PublicKey) {
-        if (seenPublicKeys.add(pubkey)) {
-            viewModelScope.launch {
-                metadataRequestChannel.send(pubkey)
-            }
-        }
-    }
-
-    private fun updateMetadata(pubkey: PublicKey, profile: Profile) {
-        viewModelScope.launch {
-            profilesMutex.withLock {
-                profiles.getOrPut(pubkey) { MutableStateFlow(null) }.value = profile
-            }
-        }
-    }
-
-    fun getMetadata(pubkey: PublicKey): StateFlow<Profile?> {
-        val flow = profiles.getOrPut(pubkey) { MutableStateFlow(null) }
-        if (flow.value == null) requestMetadata(pubkey)
-
-        return flow.asStateFlow()
-    }
-
-    fun resetInternalState() {
-        _contactList.value = emptySet()
-        _appState.update {
-            it.copy(
-                isRelayListEmpty = false,
-            )
-        }
-    }
-
-    fun dismissRelayWarning() {
-        _appState.update { it.copy(isRelayListEmpty = false) }
-    }
-
-    suspend fun updateProfile(
-        name: String? = null,
-        bio: String? = null,
-        picture: ByteArray? = null,
-        contentType: String? = null
-    ) {
-        _appState.update { it.copy(isBusy = true) }
-        try {
-            val avatarUrl =
-                picture?.let {
-                    mediaRepository.blossomUpload(
-                        nostr.signer.get(),
-                        it,
-                        contentType ?: "image/jpeg"
-                    )
-                }
-            val newMetadata = nostr.profiles.updateProfile(name, bio, avatarUrl)
-            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-
-            // Update the metadata state after successfully published
-            updateMetadata(currentUser, Profile(currentUser, newMetadata))
-
-            // Update local state
-            _appState.update { it.copy(isBusy = false) }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun refetchMsgRelays() {
-        val currentUser = nostr.signer.getPublicKeyAsync() ?: return
-        val relays = nostr.relays.fetchMsgRelays(currentUser)
-
-        if (relays.isNotEmpty()) dismissRelayWarning()
-    }
-
-    suspend fun useDefaultMsgRelayList() {
-        try {
-            val defaultRelays = nostr.relays.getDefaultMsgRelayList()
-            nostr.relays.setMsgRelays(defaultRelays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun currentUserRelayList(): Map<RelayUrl, RelayMetadata?> {
-        try {
-            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-            return nostr.relays.getRelayList(currentUser)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyMap()
-        }
-    }
-
-    suspend fun addInboxRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserRelayList().toMutableMap()
-            relays[relayUrl] = RelayMetadata.WRITE
-
-            nostr.relays.setRelaylist(relays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun addOutboxRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserRelayList().toMutableMap()
-            relays[relayUrl] = RelayMetadata.READ
-
-            nostr.relays.setRelaylist(relays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun removeRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserRelayList().toMutableMap()
-            relays.remove(relayUrl)
-
-            nostr.relays.setRelaylist(relays)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun currentUserMsgRelayList(): List<RelayUrl> {
-        try {
-            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-            return nostr.relays.getMsgRelays(currentUser)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            return emptyList()
-        }
-    }
-
-    suspend fun addMsgRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserMsgRelayList().toMutableSet()
-            relays.add(relayUrl)
-
-            nostr.relays.setMsgRelays(relays.toList())
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun removeMsgRelay(relay: String) {
-        try {
-            val relayUrl = RelayUrl.parse(relay)
-            val relays = currentUserMsgRelayList().toMutableSet()
-            relays.remove(relayUrl)
-
-            nostr.relays.setMsgRelays(relays.toList())
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    private suspend fun newContact(publicKey: PublicKey) {
-        if (publicKey in contactList.value) return
-
-        try {
-            val updated = contactList.value + publicKey
-            // Publish new event
-            nostr.profiles.setContactList(updated.toList())
-            // Optimistic local update
-            _contactList.update { it + publicKey }
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-    }
-
-    suspend fun addContact(address: String): Boolean {
-        val pubkey = try {
-            if (address.contains("@")) {
-                nostr.profiles.searchByAddress(address)
-            } else {
-                PublicKey.parse(address)
-            }
-        } catch (e: Exception) {
-            showError("Invalid contact address: ${e.message}")
-            return false
-        }
-
-        return run {
-            newContact(pubkey)
-            true
-        }
-    }
-
-    fun removeContact(publicKey: PublicKey) {
-        viewModelScope.launch {
-            if (publicKey !in contactList.value) return@launch
-
-            try {
-                val updated = contactList.value - publicKey
-                // Publish new event
-                nostr.profiles.setContactList(updated.toList())
-                // Optimistic local update
-                _contactList.update { it - publicKey }
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    suspend fun searchByAddress(query: String): PublicKey? {
-        try {
-            return nostr.profiles.searchByAddress(query)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-        return null
-    }
-
-    suspend fun searchByNostr(query: String): List<PublicKey> {
-        try {
-            return nostr.profiles.searchByNostr(query)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-        }
-        return emptyList()
-    }
-
-    suspend fun verifyActivity(pubkey: PublicKey): Timestamp? {
-        return try {
-            nostr.profiles.verifyActivity(pubkey)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            null
-        }
-    }
-
-    suspend fun verifyContact(pubkey: PublicKey): Boolean {
-        return try {
-            nostr.profiles.verifyContact(pubkey)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            false
-        }
-    }
-
-    suspend fun mutualContacts(pubkey: PublicKey): Set<PublicKey> {
-        return try {
-            nostr.profiles.mutualContacts(pubkey)
-        } catch (e: Exception) {
-            showError("Error: ${e.message}")
-            setOf()
-        }
-    }
-}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ProfileCache.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/ProfileCache.kt
@@ -0,0 +1,138 @@
+package su.reya.coop.viewmodel
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import rust.nostr.sdk.PublicKey
+import su.reya.coop.Profile
+import su.reya.coop.nostr.Nostr
+import kotlin.time.Duration.Companion.milliseconds
+
+class ProfileCache(
+    private val nostr: Nostr,
+    defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : ErrorHost by createErrorHost() {
+    private val scope = CoroutineScope(SupervisorJob() + defaultDispatcher)
+    private val profiles = MutableStateFlow<Map<PublicKey, MutableStateFlow<Profile?>>>(emptyMap())
+    private val seenPublicKeys = MutableStateFlow<Set<PublicKey>>(emptySet())
+    private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
+
+    init {
+        scope.launch {
+            try {
+                runObserver()
+            } catch (e: Exception) {
+                showError("Metadata observer failed: ${e.message}")
+            }
+        }
+        scope.launch {
+            try {
+                runMetadataBatching()
+            } catch (e: Exception) {
+                showError("Metadata batching failed: ${e.message}")
+            }
+        }
+        scope.launch {
+            try {
+                nostr.waitUntilInitialized()
+                getCachedMetadata()
+            } catch (e: Exception) {
+                showError("Failed to load initial cache: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun runObserver() {
+        nostr.profiles.metadataUpdates.collect { (pubkey, metadata) ->
+            updateMetadata(pubkey, Profile(pubkey, metadata))
+        }
+    }
+
+    private suspend fun runMetadataBatching() {
+        nostr.waitUntilInitialized()
+
+        while (true) {
+            val firstKey = metadataRequestChannel.receive()
+            val batch = mutableSetOf(firstKey)
+
+            while (batch.size < 10) {
+                val nextKey =
+                    withTimeoutOrNull(500.milliseconds) { metadataRequestChannel.receive() }
+                        ?: break
+                batch.add(nextKey)
+            }
+
+            try {
+                nostr.profiles.fetchMetadataBatch(batch.toList())
+            } catch (e: Exception) {
+                // Allow these keys to be requested again since the fetch failed
+                seenPublicKeys.update { it - batch }
+                println("Failed to fetch metadata batch: ${e.message}")
+            }
+        }
+    }
+
+    private suspend fun getCachedMetadata() {
+        val cache = nostr.profiles.getAllCacheMetadata()
+        cache.forEach { (pubkey, metadata) ->
+            updateMetadata(pubkey, Profile(pubkey, metadata))
+        }
+    }
+
+    private fun requestMetadata(pubkey: PublicKey) {
+        var added = false
+        seenPublicKeys.update { current ->
+            if (current.contains(pubkey)) {
+                added = false
+                current
+            } else {
+                added = true
+                current + pubkey
+            }
+        }
+        if (added) metadataRequestChannel.trySend(pubkey)
+    }
+
+    private fun updateMetadata(pubkey: PublicKey, profile: Profile) {
+        profiles.update { current ->
+            val flow = current[pubkey] ?: MutableStateFlow<Profile?>(null)
+            flow.value = profile
+            if (current.containsKey(pubkey)) current else current + (pubkey to flow)
+        }
+        seenPublicKeys.update { it + pubkey }
+    }
+
+    fun getMetadata(pubkey: PublicKey): StateFlow<Profile?> {
+        val currentMap = profiles.value
+        val existingFlow = currentMap[pubkey]
+
+        if (existingFlow != null) {
+            if (existingFlow.value == null) requestMetadata(pubkey)
+            return existingFlow.asStateFlow()
+        }
+
+        val newFlow = MutableStateFlow<Profile?>(null)
+        var resultFlow = newFlow
+
+        profiles.update { prev ->
+            if (prev.containsKey(pubkey)) {
+                resultFlow = prev[pubkey]!!
+                prev
+            } else {
+                prev + (pubkey to newFlow)
+            }
+        }
+
+        if (resultFlow.value == null) requestMetadata(pubkey)
+
+        return resultFlow.asStateFlow()
+    }
+}
Author	SHA1	Message	Date
Ren Amamiya	47196dbea4	chore: bump version	2026-07-15 19:44:52 +07:00
Ren Amamiya	30191170f1	chore: fix some crash and performance issues (#45 ) Reviewed-on: #45	2026-07-15 12:44:28 +00:00
Ren Amamiya	1485a767ed	feat: add support for reply message (#44 ) Reviewed-on: #44	2026-07-14 10:22:27 +00:00
Ren Amamiya	0e789b5d91	feat: add context menu for chat message (#43 ) Reviewed-on: #43	2026-07-13 10:56:23 +00:00
Ren Amamiya	410615bd89	chore: clean up codebase (#42 ) Reviewed-on: #42	2026-07-13 01:04:15 +00:00
Ren Amamiya	a5951e03cf	chore: improve performance (#41 ) Reviewed-on: #41	2026-07-11 12:45:53 +00:00