chore: bump version

Reviewed-on: #13

composeApp/build.gradle.kts

@@ -19,15 +19,15 @@ kotlin {
         androidMain.dependencies {
             implementation(libs.compose.uiToolingPreview)
             implementation(libs.androidx.activity.compose)
-            implementation("androidx.navigation:navigation-compose:2.8.8")
+            implementation(libs.androidx.lifecycle.process)
-            implementation("androidx.datastore:datastore-preferences:1.2.1")
+            implementation(libs.androidx.lifecycle.runtimeCompose)
-            implementation("androidx.datastore:datastore-preferences-core:1.2.1")
+            implementation(libs.jetbrains.navigation3.ui)
-            implementation("org.jetbrains.compose.material3:material3:1.11.0-alpha07")
+            implementation(libs.jetbrains.lifecycle.viewmodelNavigation3)
+            implementation(libs.androidx.core.splashscreen)
+            implementation("su.reya:nostr-sdk-kmp:0.2.3")
             implementation("io.coil-kt.coil3:coil-compose:3.4.0")
             implementation("io.coil-kt.coil3:coil-network-okhttp:3.4.0")
-            implementation("su.reya:nostr-sdk-kmp:0.2.3")
             implementation("io.github.kalinjul.easyqrscan:scanner:0.7.0")
-            implementation("androidx.lifecycle:lifecycle-process:2.8.0")
             implementation("io.github.alexzhirkevich:qrose:1.1.2")
         }
         commonMain.dependencies {
@@ -39,6 +39,8 @@ kotlin {
             implementation(libs.compose.uiToolingPreview)
             implementation(libs.androidx.lifecycle.viewmodelCompose)
             implementation(libs.androidx.lifecycle.runtimeCompose)
+            implementation(libs.androidx.datastore.preferences)
+            implementation(libs.androidx.datastore)
             implementation(projects.shared)
         }
         commonTest.dependencies {
@@ -67,7 +69,7 @@ android {
         minSdk = libs.versions.android.minSdk.get().toInt()
         targetSdk = libs.versions.android.targetSdk.get().toInt()
         versionCode = 1
-        versionName = "0.1.1"
+        versionName = "0.1.6"
     }
     packaging {
         resources {

composeApp/src/androidMain/AndroidManifest.xml

@@ -18,14 +18,35 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@android:style/Theme.Material.Light.NoActionBar">
+
+        <activity
+            android:name=".CrashActivity"
+            android:exported="false"
+            android:process=":crash_handler"
+            android:theme="@android:style/Theme.Material.Light.NoActionBar" />
+
         <activity
             android:name=".MainActivity"
-            android:exported="true">
+            android:exported="true"
+            android:theme="@style/Theme.App.Starting">
+
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="chat"
+                    android:scheme="coop" />
+            </intent-filter>
         </activity>
+
         <service
             android:name=".NostrForegroundService"
             android:enabled="true"

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

@@ -1,18 +1,3 @@
-<!--
-  ~ Copyright (C) 2026 The Android Open Source Project
-  ~
-  ~ Licensed under the Apache License, Version 2.0 (the "License");
-  ~ you may not use this file except in compliance with the License.
-  ~ You may obtain a copy of the License at
-  ~
-  ~      http://www.apache.org/licenses/LICENSE-2.0
-  ~
-  ~ Unless required by applicable law or agreed to in writing, software
-  ~ distributed under the License is distributed on an "AS IS" BASIS,
-  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  ~ See the License for the specific language governing permissions and
-  ~ limitations under the License.
-  -->
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
     android:width="750dp"
     android:height="750dp"

composeApp/src/androidMain/composeResources/drawable/ic_badge.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="M160,880Q127,880 103.5,856.5Q80,833 80,800L80,360Q80,327 103.5,303.5Q127,280 160,280L360,280L360,160Q360,127 383.5,103.5Q407,80 440,80L520,80Q553,80 576.5,103.5Q600,127 600,160L600,280L800,280Q833,280 856.5,303.5Q880,327 880,360L880,800Q880,833 856.5,856.5Q833,880 800,880L160,880ZM160,800L800,800Q800,800 800,800Q800,800 800,800L800,360Q800,360 800,360Q800,360 800,360L600,360L600,360Q600,393 576.5,416.5Q553,440 520,440L440,440Q407,440 383.5,416.5Q360,393 360,360L360,360L160,360Q160,360 160,360Q160,360 160,360L160,800Q160,800 160,800Q160,800 160,800ZM240,720L480,720L480,702Q480,685 470.5,670.5Q461,656 444,648Q424,639 403.5,634.5Q383,630 360,630Q337,630 316.5,634.5Q296,639 276,648Q259,656 249.5,670.5Q240,685 240,702L240,720ZM560,660L720,660L720,600L560,600L560,660ZM402.5,582.5Q420,565 420,540Q420,515 402.5,497.5Q385,480 360,480Q335,480 317.5,497.5Q300,515 300,540Q300,565 317.5,582.5Q335,600 360,600Q385,600 402.5,582.5ZM560,540L720,540L720,480L560,480L560,540ZM440,360L520,360L520,160L440,160L440,360ZM480,580Q480,580 480,580Q480,580 480,580L480,580Q480,580 480,580Q480,580 480,580L480,580L480,580Q480,580 480,580Q480,580 480,580L480,580Q480,580 480,580Q480,580 480,580L480,580L480,580Q480,580 480,580Q480,580 480,580L480,580Q480,580 480,580Q480,580 480,580Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_bitcoin.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,840L360,760L240,760L240,680L320,680L320,280L240,280L240,200L360,200L360,120L440,120L440,200L520,200L520,120L600,120L600,205L600,205Q652,219 686,261.5Q720,304 720,360Q720,389 710,415.5Q700,442 682,463Q717,484 738.5,520Q760,556 760,600Q760,666 713,713Q666,760 600,760L600,760L600,840L520,840L520,760L440,760L440,840L360,840ZM400,440L560,440Q593,440 616.5,416.5Q640,393 640,360Q640,327 616.5,303.5Q593,280 560,280L400,280L400,440ZM400,680L600,680Q633,680 656.5,656.5Q680,633 680,600Q680,567 656.5,543.5Q633,520 600,520L400,520L400,680Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_chat.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="M80,880L80,160Q80,127 103.5,103.5Q127,80 160,80L800,80Q833,80 856.5,103.5Q880,127 880,160L880,640Q880,673 856.5,696.5Q833,720 800,720L240,720L80,880ZM206,640L800,640Q800,640 800,640Q800,640 800,640L800,160Q800,160 800,160Q800,160 800,160L160,160Q160,160 160,160Q160,160 160,160L160,685L206,640ZM160,640L160,640L160,160Q160,160 160,160Q160,160 160,160L160,160Q160,160 160,160Q160,160 160,160L160,640Q160,640 160,640Q160,640 160,640Z" />
+</vector>

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

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M480,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,473 799.5,465.5Q799,458 799,453Q794,482 772,501Q750,520 720,520L640,520Q607,520 583.5,496.5Q560,473 560,440L560,400L400,400L400,320Q400,287 423.5,263.5Q447,240 480,240L520,240L520,240Q520,217 532.5,199.5Q545,182 563,171Q543,166 522.5,163Q502,160 480,160Q346,160 253,253Q160,346 160,480Q160,480 160,480Q160,480 160,480L360,480Q426,480 473,527Q520,574 520,640L520,680L400,680L400,790Q420,795 439.5,797.5Q459,800 480,800Z" />
+</vector>

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

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#000000"
+        android:pathData="M480,471L480,471Q480,471 480,471Q480,471 480,471Q480,471 480,471Q480,471 480,471Q480,471 480,471Q480,471 480,471L480,471ZM480,880Q447,880 423.5,856.5Q400,833 400,800L560,800Q560,833 536.5,856.5Q513,880 480,880ZM160,760L160,680L240,680L240,400Q240,316 290.5,251Q341,186 422,167Q412,189 406.5,213Q401,237 399,262Q364,283 342,319Q320,355 320,400L320,680L640,680L640,558Q660,561 680,561Q700,561 720,558L720,680L800,680L800,760L160,760ZM640,480L628,420Q616,415 605.5,409.5Q595,404 584,396L526,414L486,346L532,306Q530,293 530,280Q530,267 532,254L486,214L526,146L584,164Q595,156 605.5,150.5Q616,145 628,140L640,80L720,80L732,140Q744,145 754.5,150.5Q765,156 776,164L834,146L874,214L828,254Q830,267 830,280Q830,293 828,306L874,346L834,414L776,396Q765,404 754.5,409.5Q744,415 732,420L720,480L640,480ZM736.5,336.5Q760,313 760,280Q760,247 736.5,223.5Q713,200 680,200Q647,200 623.5,223.5Q600,247 600,280Q600,313 623.5,336.5Q647,360 680,360Q713,360 736.5,336.5Z" />
+</vector>

composeApp/src/androidMain/composeResources/drawable/ic_share.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="M680,880Q630,880 595,845Q560,810 560,760Q560,754 563,732L282,568Q266,583 245,591.5Q224,600 200,600Q150,600 115,565Q80,530 80,480Q80,430 115,395Q150,360 200,360Q224,360 245,368.5Q266,377 282,392L563,228Q561,221 560.5,214.5Q560,208 560,200Q560,150 595,115Q630,80 680,80Q730,80 765,115Q800,150 800,200Q800,250 765,285Q730,320 680,320Q656,320 635,311.5Q614,303 598,288L317,452Q319,459 319.5,465.5Q320,472 320,480Q320,488 319.5,494.5Q319,501 317,508L598,672Q614,657 635,648.5Q656,640 680,640Q730,640 765,675Q800,710 800,760Q800,810 765,845Q730,880 680,880ZM680,800Q697,800 708.5,788.5Q720,777 720,760Q720,743 708.5,731.5Q697,720 680,720Q663,720 651.5,731.5Q640,743 640,760Q640,777 651.5,788.5Q663,800 680,800ZM200,520Q217,520 228.5,508.5Q240,497 240,480Q240,463 228.5,451.5Q217,440 200,440Q183,440 171.5,451.5Q160,463 160,480Q160,497 171.5,508.5Q183,520 200,520ZM708.5,228.5Q720,217 720,200Q720,183 708.5,171.5Q697,160 680,160Q663,160 651.5,171.5Q640,183 640,200Q640,217 651.5,228.5Q663,240 680,240Q697,240 708.5,228.5ZM680,760Q680,760 680,760Q680,760 680,760Q680,760 680,760Q680,760 680,760Q680,760 680,760Q680,760 680,760Q680,760 680,760Q680,760 680,760ZM200,480Q200,480 200,480Q200,480 200,480Q200,480 200,480Q200,480 200,480Q200,480 200,480Q200,480 200,480Q200,480 200,480Q200,480 200,480ZM680,200Q680,200 680,200Q680,200 680,200Q680,200 680,200Q680,200 680,200Q680,200 680,200Q680,200 680,200Q680,200 680,200Q680,200 680,200Z" />
+</vector>

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

@@ -1,5 +1,9 @@
 package su.reya.coop
 
+import android.app.Activity
+import android.content.Intent
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
@@ -15,8 +19,10 @@ import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.MaterialExpressiveTheme
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.MotionScheme
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
+import androidx.compose.material3.Typography
 import androidx.compose.material3.darkColorScheme
 import androidx.compose.material3.dynamicDarkColorScheme
 import androidx.compose.material3.dynamicLightColorScheme
@@ -27,8 +33,10 @@ import androidx.compose.runtime.CompositionLocalProvider
 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.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -37,14 +45,15 @@ import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.core.util.Consumer
-import androidx.navigation.NavController
+import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
-import androidx.navigation.compose.NavHost
+import androidx.navigation3.runtime.NavBackStack
-import androidx.navigation.compose.composable
+import androidx.navigation3.runtime.NavKey
-import androidx.navigation.compose.rememberNavController
+import androidx.navigation3.runtime.entryProvider
-import androidx.navigation.toRoute
+import androidx.navigation3.runtime.rememberNavBackStack
+import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.ui.NavDisplay
 import kotlinx.coroutines.launch
-import su.reya.coop.coop.storage.SecretStore
 import su.reya.coop.screens.ChatScreen
 import su.reya.coop.screens.HomeScreen
 import su.reya.coop.screens.ImportScreen
@@ -52,6 +61,7 @@ import su.reya.coop.screens.MyQrScreen
 import su.reya.coop.screens.NewChatScreen
 import su.reya.coop.screens.NewIdentityScreen
 import su.reya.coop.screens.OnboardingScreen
+import su.reya.coop.screens.ProfileScreen
 import su.reya.coop.screens.RelayScreen
 import su.reya.coop.screens.ScanScreen
 
@@ -63,33 +73,50 @@ val LocalSnackbarHostState = staticCompositionLocalOf<SnackbarHostState> {
     error("No SnackbarHostState provided")
 }
 
-val LocalNavController = staticCompositionLocalOf<NavController> {
+val LocalNavigator = staticCompositionLocalOf<Navigator> {
-    error("No NavController provided")
+    error("No Navigator provided")
+}
+
+val LocalScanResult = staticCompositionLocalOf<QrScanResult> {
+    error("No QrScanResult provided")
 }
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
 @Composable
-fun App() {
+fun App(viewModel: NostrViewModel) {
     val context = LocalContext.current
-    val navController = rememberNavController()
+    val activity = context as? ComponentActivity
     val scope = rememberCoroutineScope()
-    val darkMode = isSystemInDarkTheme()
+    val sheetState = rememberModalBottomSheetState()
+    val backStack = rememberNavBackStack(Screen.Home)
+    val navigator = remember(backStack) { Navigator(backStack) }
+    val qrScanResult = remember { QrScanResult() }
+
+    val signerRequired by viewModel.signerRequired.collectAsState(initial = null)
+    val isRelayListEmpty by viewModel.isRelayListEmpty.collectAsState()
 
     // Snackbar
     val snackbarHostState = remember { SnackbarHostState() }
 
-    // Initialize Nostr View Model and Secret Store
+    // Check if dark theme enabled
-    val secretStore = remember { SecretStore(context) }
+    val darkMode = isSystemInDarkTheme()
-    val viewModel: NostrViewModel = viewModel { NostrViewModel(NostrManager.instance, secretStore) }
 
     // Enabled the dynamic color scheme
     val colorScheme = when {
+        // Enable the dynamic color scheme for Android 12+
         android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S -> {
-            if (darkMode) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
+            if (isSystemInDarkTheme()) dynamicDarkColorScheme(context) else dynamicLightColorScheme(
+                context
+            )
+        }
+        // When dark mode is enabled, use the dark color scheme
+        darkMode -> darkColorScheme()
+        // Fallback to the light color scheme
+        else -> expressiveLightColorScheme()
     }
 
-        darkMode -> darkColorScheme()
+    BackHandler(enabled = backStack.size > 1) {
-        else -> expressiveLightColorScheme()
+        navigator.goBack()
     }
 
     LaunchedEffect(Unit) {
@@ -98,29 +125,95 @@ fun App() {
         }
     }
 
+    LaunchedEffect(activity) {
+        activity?.let {
+            fun handleIntent(intent: Intent) {
+                val screen = Screen.fromIntent(intent)
+                // Prevent pushing the same screen
+                if (screen != null && backStack.lastOrNull() != screen) {
+                    navigator.navigate(screen)
+                }
+            }
+
+            // Handle the intent that started the Activity
+            handleIntent(it.intent)
+
+            // Handle new intents while the Activity is running
+            val listener = Consumer<Intent> { intent -> handleIntent(intent) }
+            it.addOnNewIntentListener(listener)
+        }
+    }
+
+    LaunchedEffect(backStack.size) {
+        if (backStack.isEmpty()) {
+            (context as? Activity)?.finish()
+        }
+    }
+
+    LaunchedEffect(signerRequired) {
+        if (signerRequired == true && backStack.last() != Screen.Onboarding) {
+            backStack.clear()
+            backStack.add(Screen.Onboarding)
+        }
+    }
+
     MaterialExpressiveTheme(
         colorScheme = colorScheme,
+        typography = Typography(),
+        motionScheme = MotionScheme.expressive(),
     ) {
         CompositionLocalProvider(
             LocalNostrViewModel provides viewModel,
             LocalSnackbarHostState provides snackbarHostState,
-            LocalNavController provides navController,
+            LocalNavigator provides navigator,
+            LocalScanResult provides qrScanResult,
         ) {
-            val emptySecret by viewModel.emptySecret.collectAsState(initial = null)
+            NavDisplay(
-            val isRelayListEmpty by viewModel.isRelayListEmpty.collectAsState()
+                backStack = backStack,
-            val sheetState = rememberModalBottomSheetState()
+                onBack = {
-
+                    if (backStack.size > 1) {
-            LaunchedEffect(emptySecret) {
+                        backStack.removeLastOrNull()
-                // Navigate to the home screen if the secret is already set
+                    } else {
-                if (emptySecret == false) {
+                        (context as? Activity)?.finish()
-                    navController.navigate(Screen.Home) {
+                    }
-                        popUpTo(Screen.Onboarding) { inclusive = true }
+                },
+                entryDecorators = listOf(
+                    rememberSaveableStateHolderNavEntryDecorator(),
+                    rememberViewModelStoreNavEntryDecorator()
+                ),
+                entryProvider = entryProvider {
+                    entry<Screen.Home> {
+                        HomeScreen()
+                    }
+                    entry<Screen.Onboarding> {
+                        OnboardingScreen()
+                    }
+                    entry<Screen.Import> {
+                        ImportScreen()
+                    }
+                    entry<Screen.NewIdentity> {
+                        NewIdentityScreen()
+                    }
+                    entry<Screen.Chat> { key ->
+                        ChatScreen(id = key.id)
+                    }
+                    entry<Screen.NewChat> {
+                        NewChatScreen()
+                    }
+                    entry<Screen.Profile> { key ->
+                        ProfileScreen(pubkey = key.pubkey)
+                    }
+                    entry<Screen.Scan> {
+                        ScanScreen()
+                    }
+                    entry<Screen.MyQr> {
+                        MyQrScreen()
+                    }
+                    entry<Screen.Relay> {
+                        RelayScreen()
                     }
                 }
-            }
+            )
-
-            // Show loading screen while initializing
-            if (emptySecret == null) return@CompositionLocalProvider
 
             // Show the relay setup dialog if the msg relay list is empty
             if (isRelayListEmpty) {
@@ -176,79 +269,26 @@ fun App() {
                     }
                 }
             }
-
-            NavHost(
-                navController = navController,
-                startDestination = if (emptySecret == false) Screen.Home else Screen.Onboarding
-            ) {
-                composable<Screen.Onboarding> { backStackEntry ->
-                    OnboardingScreen(
-                        onOpenImport = { navController.navigate(Screen.Import) },
-                        onOpenNew = { navController.navigate(Screen.NewIdentity) }
-                    )
-                }
-                composable<Screen.Import> { backStackEntry ->
-                    val isCreating by viewModel.isCreating.collectAsState()
-
-                    ImportScreen(
-                        isLoading = isCreating,
-                        onBack = { navController.popBackStack() },
-                        onSave = { secret ->
-                            viewModel.importIdentity(secret)
-                        }
-                    )
-                }
-                composable<Screen.NewIdentity> { backStackEntry ->
-                    val isCreating by viewModel.isCreating.collectAsState()
-
-                    NewIdentityScreen(
-                        isLoading = isCreating,
-                        onBack = { navController.popBackStack() },
-                        onSave = { name, bio, uri ->
-                            val contentType = uri?.let { context.contentResolver.getType(it) }
-                            val picture = uri?.let {
-                                context.contentResolver.openInputStream(it)?.use { input ->
-                                    input.readBytes()
-                                }
-                            }
-                            viewModel.createIdentity(name, bio, picture, contentType)
-                        }
-                    )
-                }
-                composable<Screen.Home> { backStackEntry ->
-                    HomeScreen(
-                        onOpenChat = { id -> navController.navigate(Screen.Chat(id)) },
-                        onNewChat = { navController.navigate(Screen.NewChat) }
-                    )
-                }
-                composable<Screen.Chat> { backStackEntry ->
-                    val chat: Screen.Chat = backStackEntry.toRoute()
-                    ChatScreen(
-                        id = chat.id,
-                        onBack = { navController.popBackStack() },
-                    )
-                }
-                composable<Screen.NewChat> { backStackEntry ->
-                    NewChatScreen(
-                        onBack = { navController.popBackStack() },
-                    )
-                }
-                composable<Screen.Scan> { backStackEntry ->
-                    ScanScreen(
-                        onBack = { navController.popBackStack() },
-                    )
-                }
-                composable<Screen.MyQr> { backStackEntry ->
-                    MyQrScreen(
-                        onBack = { navController.popBackStack() },
-                    )
-                }
-                composable<Screen.Relay> { backStackEntry ->
-                    RelayScreen(
-                        onBack = { navController.popBackStack() },
-                    )
-                }
-            }
         }
     }
 }
+
+class Navigator(private val backStack: NavBackStack<NavKey>) {
+    fun navigate(route: NavKey) {
+        backStack.add(route)
+    }
+
+    fun goBack() {
+        if (backStack.size > 1) {
+            backStack.removeAt(backStack.lastIndex)
+        }
+    }
+}
+
+class QrScanResult {
+    var content by mutableStateOf<String?>(null)
+
+    fun clear() {
+        content = null
+    }
+}

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

@@ -0,0 +1,108 @@
+package su.reya.coop
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialExpressiveTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlin.system.exitProcess
+
+class CrashActivity : ComponentActivity() {
+    @OptIn(ExperimentalMaterial3ExpressiveApi::class)
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val errorText = intent.getStringExtra("error") ?: "Unknown error"
+
+        setContent {
+            MaterialExpressiveTheme {
+                Scaffold(
+                    content = { innerPadding ->
+                        Surface(
+                            modifier = Modifier
+                                .fillMaxSize()
+                                .padding(innerPadding),
+                            color = MaterialTheme.colorScheme.background
+                        ) {
+                            Column(
+                                modifier = Modifier
+                                    .fillMaxSize()
+                                    .padding(16.dp),
+                                verticalArrangement = Arrangement.spacedBy(16.dp)
+                            ) {
+                                Column {
+                                    Text(
+                                        "App Crashed",
+                                        style = MaterialTheme.typography.titleMediumEmphasized,
+                                        color = MaterialTheme.colorScheme.error
+                                    )
+                                    Text(
+                                        "Please copy the log below and send it to the developer.",
+                                        style = MaterialTheme.typography.bodySmall
+                                    )
+                                }
+                                Box(
+                                    modifier = Modifier
+                                        .weight(1f)
+                                        .fillMaxWidth()
+                                        .verticalScroll(rememberScrollState())
+                                ) {
+                                    Text(
+                                        text = errorText,
+                                        fontFamily = FontFamily.Monospace,
+                                        fontSize = 12.sp
+                                    )
+                                }
+                                Row(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                                ) {
+                                    FilledTonalButton(
+                                        onClick = {
+                                            finish();
+                                            exitProcess(0)
+                                        },
+                                        modifier = Modifier.weight(1f)
+                                    ) {
+                                        Text("Exit")
+                                    }
+                                    Button(
+                                        onClick = {
+                                            val clipboard =
+                                                getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
+                                            val data = ClipData.newPlainText("Crash Log", errorText)
+                                            clipboard.setPrimaryClip(data)
+                                        },
+                                        modifier = Modifier.weight(1f)
+                                    ) {
+                                        Text("Copy")
+                                    }
+                                }
+                            }
+                        }
+                    }
+                )
+            }
+        }
+    }
+}

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

@@ -6,22 +6,69 @@ import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.activity.viewModels
+import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import su.reya.coop.coop.storage.SecretStore
+import kotlin.system.exitProcess
 
 class MainActivity : ComponentActivity() {
+    private val viewModel: NostrViewModel by viewModels {
+        object : ViewModelProvider.Factory {
+            override fun <T : ViewModel> create(modelClass: Class<T>): T {
+                val secretStore = SecretStore(this@MainActivity)
+                return NostrViewModel(NostrManager.instance, secretStore) as T
+            }
+        }
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            throwable.printStackTrace()
+            android.util.Log.e(
+                "CoopCrash",
+                "Uncaught exception in thread ${thread.name}",
+                throwable
+            )
+
+            // Start the Crash Activity
+            val intent = Intent(this, CrashActivity::class.java).apply {
+                putExtra("error", throwable.stackTraceToString())
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+            }
+            startActivity(intent)
+
+            // Exit
+            android.os.Process.killProcess(android.os.Process.myPid())
+            exitProcess(1)
+        }
+
+        val splashScreen = installSplashScreen()
         enableEdgeToEdge()
+
         super.onCreate(savedInstanceState)
 
-        val intent = Intent(this, NostrForegroundService::class.java)
+        val serviceIntent = Intent(this, NostrForegroundService::class.java)
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            startForegroundService(intent)
+            startForegroundService(serviceIntent)
         } else {
-            startService(intent)
+            startService(serviceIntent)
+        }
+
+        // Keep the splash screen visible until the signer check is complete
+        splashScreen.setKeepOnScreenCondition {
+            viewModel.signerRequired.value == null
         }
 
         setContent {
-            App()
+            App(viewModel = viewModel)
         }
     }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+    }
 }

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

@@ -1,14 +1,34 @@
 package su.reya.coop
 
+import android.content.Intent
+import androidx.navigation3.runtime.NavKey
 import kotlinx.serialization.Serializable
 
-sealed interface Screen {
+sealed interface Screen : NavKey {
+    companion object {
+        fun fromIntent(intent: Intent): Screen? {
+            val data = intent.data ?: return null
+            if (data.scheme != "coop") return null
+
+            return when (data.host) {
+                // Matches coop://chat/{id}
+                "chat" -> data.pathSegments.firstOrNull()?.toLongOrNull()?.let { Chat(it) }
+                // Matches coop://profile/{pubkey}
+                "profile" -> data.pathSegments.firstOrNull()?.let { Profile(it) }
+                else -> null
+            }
+        }
+    }
+
     @Serializable
     data object Home : Screen
 
     @Serializable
     data class Chat(val id: Long) : Screen
 
+    @Serializable
+    data class Profile(val pubkey: String) : Screen
+
     @Serializable
     data object NewChat : Screen
 

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

@@ -3,12 +3,16 @@ package su.reya.coop
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
+import android.app.PendingIntent
 import android.app.Service
 import android.content.Intent
+import android.content.pm.ServiceInfo
 import android.os.Build
 import android.os.IBinder
+import android.util.Log
 import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
+import androidx.core.net.toUri
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.ProcessLifecycleOwner
 import kotlinx.coroutines.CoroutineScope
@@ -20,7 +24,7 @@ import java.io.File
 
 class NostrForegroundService : Service() {
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
-    private val nostr = NostrManager.instance
+    private val nostr by lazy { NostrManager.instance }
 
     override fun onBind(intent: Intent?): IBinder? = null
 
@@ -28,60 +32,123 @@ class NostrForegroundService : Service() {
         return ProcessLifecycleOwner.get().lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
     }
 
-    @RequiresApi(Build.VERSION_CODES.O)
+    override fun onCreate() {
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        super.onCreate()
-        createNotificationChannel()
-        val notification = createNotification("Connecting to Nostr...")
-        startForeground(1, notification)
 
+        createNotificationChannel()
+        val notification = createNotification()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            startForeground(1, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
+        } else {
+            startForeground(1, notification)
+        }
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         serviceScope.launch {
             try {
+                Log.d("Coop", "Starting Nostr in background")
+
+                // Create a database directory
                 val dbDir = File(filesDir, "nostr")
                 dbDir.mkdirs()
+
                 // Initialize Nostr client
                 nostr.init(dbDir.absolutePath)
                 // Connect to bootstrap relays
                 nostr.connectBootstrapRelays()
                 // Handle notifications
-                nostr.handleLiteNotifications { event ->
+                nostr.handleNotifications(
+                    onMetadataUpdate = { pubkey, metadata ->
+                        serviceScope.launch { nostr.emitMetadataUpdate(pubkey, metadata) }
+                    },
+                    onContactListUpdate = { contacts ->
+                        serviceScope.launch { nostr.emitContactListUpdate(contacts) }
+                    },
+                    onSubscriptionClose = {
+                        serviceScope.launch { nostr.emitSubscriptionClosed() }
+                    },
+                    onNewMessage = { event ->
+                        serviceScope.launch {
                             if (!isUserInApp()) {
-                        showNewMessageNotification(event.content())
+                                showNewMessageNotification(event.roomId(), event.content())
+                            }
+                            nostr.emitNewEvent(event)
                         }
                     }
+                )
             } catch (e: Exception) {
-                println("Failed to start Nostr in background: ${e.message}")
+                Log.e("Coop", "Failed to start Nostr", e)
             }
         }
-
         return START_STICKY
     }
 
     @RequiresApi(Build.VERSION_CODES.O)
     private fun createNotificationChannel() {
-        val channel = NotificationChannel(
+        val manager = getSystemService(NotificationManager::class.java)
+
+        val serviceChannel = NotificationChannel(
             "nostr_service",
-            "Nostr Background Service",
+            "Nostr Background Status",
+            NotificationManager.IMPORTANCE_MIN
+        ).apply {
+            setShowBadge(false)
+        }
+        manager?.createNotificationChannel(serviceChannel)
+
+        val messageChannel = NotificationChannel(
+            "nostr_messages",
+            "New Messages",
             NotificationManager.IMPORTANCE_HIGH
         )
-        val manager = getSystemService(NotificationManager::class.java)
+        manager?.createNotificationChannel(messageChannel)
-        manager?.createNotificationChannel(channel)
     }
 
-    private fun createNotification(content: String): Notification {
+    private fun createNotification(content: String? = null): Notification {
-        return NotificationCompat.Builder(this, "nostr_service")
+        val builder = NotificationCompat.Builder(this, "nostr_service")
-            .setContentTitle("Coop")
+            .setSmallIcon(R.drawable.ic_notification)
-            .setContentText(content)
-            .setSmallIcon(android.R.drawable.ic_menu_send)
             .setOngoing(true)
-            .build()
+            .setPriority(NotificationCompat.PRIORITY_MIN)
+            .setCategory(Notification.CATEGORY_SERVICE)
+
+        if (content != null) {
+            builder.setContentTitle("Coop")
+            builder.setContentText(content)
+        } else {
+            builder.setContentTitle("Coop is active")
         }
 
-    private fun showNewMessageNotification(message: String) {
+        return builder.build()
-        val notification = NotificationCompat.Builder(this, "nostr_service")
+    }
-            .setContentTitle("New Message")
+
+    private fun showNewMessageNotification(roomId: Long, message: String) {
+        val deepLinkUri = "coop://chat/$roomId".toUri()
+
+        val intent = Intent(
+            Intent.ACTION_VIEW,
+            deepLinkUri,
+            this,
+            MainActivity::class.java
+        )
+
+        val pendingIntent = PendingIntent.getActivity(
+            this,
+            roomId.toInt(),
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val notification = NotificationCompat.Builder(this, "nostr_messages")
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle("You received a new message")
             .setContentText(message)
             .setAutoCancel(true)
+            .setContentIntent(pendingIntent)
+            .setCategory(Notification.CATEGORY_MESSAGE)
             .build()
+
         val manager = getSystemService(NotificationManager::class.java)
         manager?.notify(System.currentTimeMillis().toInt(), notification)
     }

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

@@ -1,6 +1,7 @@
 package su.reya.coop.screens
 
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.IntrinsicSize
@@ -19,6 +20,8 @@ import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Badge
+import androidx.compose.material3.BadgedBox
 import androidx.compose.material3.FilledTonalIconButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -37,6 +40,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -44,6 +48,7 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
@@ -51,8 +56,10 @@ import coop.composeapp.generated.resources.ic_send
 import kotlinx.coroutines.flow.first
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.UnsignedEvent
+import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.Screen
 import su.reya.coop.formatAsGroupHeader
 import su.reya.coop.roomId
 import su.reya.coop.shared.Avatar
@@ -61,34 +68,40 @@ import su.reya.coop.shared.pictureFlow
 import su.reya.coop.short
 
 @Composable
-fun ChatScreen(
+fun ChatScreen(id: Long) {
-    id: Long,
-    onBack: () -> Unit,
-) {
     val snackbarHostState = LocalSnackbarHostState.current
+    val navigator = LocalNavigator.current
     val viewModel = LocalNostrViewModel.current
 
-    val room = viewModel.getChatRoom(id)
     val listState = rememberLazyListState()
+    val chatRooms by viewModel.chatRooms.collectAsState()
+    val room = remember(chatRooms, id) { chatRooms.firstOrNull { it.id == id } }
+
+    if (room == null) {
+        Box(
+            modifier = Modifier.fillMaxSize(),
+            contentAlignment = Alignment.Center
+        ) {
+            LoadingIndicator()
+        }
+        return
+    }
 
     val displayName by remember(room) { room.displayNameFlow(viewModel) }.collectAsState("Loading...")
     val picture by remember(room) { room.pictureFlow(viewModel) }.collectAsState(null)
 
     var text by remember { mutableStateOf("") }
     var loading by remember { mutableStateOf(true) }
+    var newOtherMessages by remember { mutableIntStateOf(0) }
 
     val messages = remember { mutableStateListOf<UnsignedEvent>() }
     val groupedMessages = remember(messages.toList()) {
         messages.groupBy { it.createdAt().formatAsGroupHeader() }
     }
 
-    fun setLoading(value: Boolean) {
-        loading = value
-    }
-
     LaunchedEffect(id) {
         // Start loading spinner
-        setLoading(true)
+        loading = true
 
         // Get messages
         val initialMessages = viewModel.getChatRoomMessages(id)
@@ -108,7 +121,7 @@ fun ChatScreen(
         }
 
         // Stop loading spinner
-        setLoading(false)
+        loading = false
 
         // Handle new messages
         viewModel.newEvents.collect { event ->
@@ -116,6 +129,9 @@ fun ChatScreen(
                 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++
             }
         }
     }
@@ -132,7 +148,14 @@ fun ChatScreen(
         topBar = {
             TopAppBar(
                 title = {
-                    Row(verticalAlignment = Alignment.CenterVertically) {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier.clickable {
+                            room.members.firstOrNull()?.let { pubkey ->
+                                navigator.navigate(Screen.Profile(pubkey.toBech32()))
+                            }
+                        }
+                    ) {
                         if (loading) {
                             LoadingIndicator(
                                 modifier = Modifier.size(32.dp),
@@ -152,12 +175,22 @@ fun ChatScreen(
                     }
                 },
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    BadgedBox(
+                        badge = {
+                            if (newOtherMessages > 0) {
+                                Badge {
+                                    Text(newOtherMessages.toString())
+                                }
+                            }
+                        }
+                    ) {
+                        IconButton(onClick = { navigator.goBack() }) {
                             Icon(
                                 painter = painterResource(Res.drawable.ic_arrow_back),
                                 contentDescription = "Back"
                             )
                         }
+                    }
                 },
                 colors = TopAppBarDefaults.topAppBarColors(
                     containerColor = MaterialTheme.colorScheme.surfaceContainer,
@@ -204,10 +237,15 @@ fun ChatScreen(
                                 .fillMaxWidth(),
                             contentAlignment = Alignment.Center
                         ) {
-                            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                            Column(
+                                horizontalAlignment = Alignment.CenterHorizontally,
+                                verticalArrangement = Arrangement.spacedBy(4.dp),
+                            ) {
                                 Text(
                                     text = "No messages yet",
-                                    style = MaterialTheme.typography.titleLargeEmphasized,
+                                    style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                                        fontWeight = FontWeight.SemiBold
+                                    ),
                                     color = MaterialTheme.colorScheme.onSurface
                                 )
                                 Text(

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

@@ -1,5 +1,12 @@
 package su.reya.coop.screens
 
+import android.Manifest
+import android.content.ClipData
+import android.content.Intent
+import android.os.Build
+import android.provider.Settings
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -8,12 +15,15 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
@@ -35,6 +45,7 @@ import androidx.compose.material3.SegmentedListItem
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
 import androidx.compose.material3.TooltipAnchorPosition
 import androidx.compose.material3.TooltipBox
 import androidx.compose.material3.TooltipDefaults
@@ -58,9 +69,13 @@ 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.platform.ClipEntry
 import androidx.compose.ui.platform.LocalClipboard
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
+import androidx.core.app.NotificationManagerCompat
+import androidx.lifecycle.compose.LifecycleResumeEffect
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_new_chat
 import coop.composeapp.generated.resources.ic_qr
@@ -68,8 +83,9 @@ 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.LocalNavController
+import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Room
 import su.reya.coop.Screen
@@ -81,13 +97,12 @@ import su.reya.coop.short
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class, ExperimentalMaterial3Api::class)
 @Composable
-fun HomeScreen(
+fun HomeScreen() {
-    onOpenChat: (Long) -> Unit,
+    val context = LocalContext.current
-    onNewChat: () -> Unit,
+    val navigator = LocalNavigator.current
-) {
+    val qrScanResult = LocalScanResult.current
-    val clipboard = LocalClipboard.current
-    val navController = LocalNavController.current
     val snackbarHostState = LocalSnackbarHostState.current
+    val clipboardManager = LocalClipboard.current
     val viewModel = LocalNostrViewModel.current
 
     val currentUser = viewModel.currentUser() ?: return
@@ -96,36 +111,50 @@ fun HomeScreen(
     val userProfile by currentUserProfile.collectAsState(initial = null)
     val chatRooms by viewModel.chatRooms.collectAsState(initial = emptyList())
     val isPartialProcessedGiftWrap by viewModel.isPartialProcessedGiftWrap.collectAsState(initial = false)
+    val isBannerDismissed by viewModel.isNotificationBannerDismissed.collectAsState()
 
     val scope = rememberCoroutineScope()
     val sheetState = rememberModalBottomSheetState()
     val listState = rememberLazyListState()
     val pullToRefreshState = rememberPullToRefreshState()
+
     val expandedFab by remember { derivedStateOf { listState.firstVisibleItemIndex == 0 } }
     var showBottomSheet by remember { mutableStateOf(false) }
     var isRefreshing by remember { mutableStateOf(false) }
 
-    val savedStateHandle = navController.currentBackStackEntry?.savedStateHandle
+    var isNotificationEnabled by remember {
-    val qrResult by savedStateHandle
+        mutableStateOf(NotificationManagerCompat.from(context).areNotificationsEnabled())
-        ?.getStateFlow<String?>("qr_result", null)
+    }
-        ?.collectAsState()
+
-        ?: remember { mutableStateOf(null) }
+    val permissionLauncher = rememberLauncherForActivityResult(
+        ActivityResultContracts.RequestPermission()
+    ) { _ ->
+        // State will be updated by LifecycleResumeEffect
+    }
+
+    LifecycleResumeEffect(context) {
+        isNotificationEnabled = NotificationManagerCompat.from(context).areNotificationsEnabled()
+        onPauseOrDispose { }
+    }
 
     LaunchedEffect(Unit) {
         viewModel.getChatRooms()
     }
 
-    LaunchedEffect(qrResult) {
+    LaunchedEffect(qrScanResult.content) {
-        qrResult?.let { result ->
+        qrScanResult.content?.let { result ->
             runCatching { PublicKey.parse(result) }
                 .onSuccess { pubkey ->
+                    try {
                         val roomId = viewModel.createChatRoom(listOf(pubkey))
-                    navController.navigate(Screen.Chat(roomId))
+                        navigator.navigate(Screen.Chat(roomId))
+                    } catch (e: Exception) {
+                        e.message?.let { snackbarHostState.showSnackbar(it) }
+                    }
                 }
                 .onFailure { e -> println("Failed to parse QR: ${e.message}") }
-
             // Clear the nav state
-            navController.currentBackStackEntry?.savedStateHandle?.remove<String>("qr_result")
+            qrScanResult.clear()
         }
     }
 
@@ -145,7 +174,7 @@ fun HomeScreen(
                 },
                 actions = {
                     // QR Scanner
-                    IconButton(onClick = { navController.navigate(Screen.Scan) }) {
+                    IconButton(onClick = { navigator.navigate(Screen.Scan) }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_scanner),
                             contentDescription = "Scanner"
@@ -176,7 +205,7 @@ fun HomeScreen(
                 state = rememberTooltipState(),
             ) {
                 ExtendedFloatingActionButton(
-                    onClick = onNewChat,
+                    onClick = { navigator.navigate(Screen.NewChat) },
                     expanded = expandedFab,
                     icon = {
                         Icon(
@@ -189,10 +218,73 @@ fun HomeScreen(
             }
         },
         content = { innerPadding ->
+            Column(
+                modifier = Modifier.padding(top = innerPadding.calculateTopPadding()),
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                if (!isNotificationEnabled && !isBannerDismissed) {
                     Surface(
                         modifier = Modifier
-                    .fillMaxSize()
+                            .fillMaxWidth()
-                    .padding(top = innerPadding.calculateTopPadding()),
+                            .padding(horizontal = 16.dp),
+                        shape = RoundedCornerShape(24.dp),
+                        color = MaterialTheme.colorScheme.secondaryContainer,
+                    ) {
+                        Column(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(16.dp),
+                            verticalArrangement = Arrangement.spacedBy(16.dp),
+                        ) {
+                            Column(
+                                modifier = Modifier.fillMaxWidth(),
+                            ) {
+                                Text(
+                                    text = "Get message notifications",
+                                    style = MaterialTheme.typography.titleMediumEmphasized,
+                                    color = MaterialTheme.colorScheme.onSecondaryFixed,
+                                )
+                                Text(
+                                    text = "Make sure you know when you have new messages.",
+                                    style = MaterialTheme.typography.bodyMedium,
+                                    color = MaterialTheme.colorScheme.onSecondaryContainer,
+                                )
+                            }
+                            Row(
+                                horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            ) {
+                                TextButton(
+                                    onClick = { viewModel.dismissNotificationBanner() },
+                                    modifier = Modifier.weight(1f),
+                                ) {
+                                    Text(text = "Maybe later")
+                                }
+                                Button(
+                                    onClick = {
+                                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                                            permissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+                                        } else {
+                                            // For older versions, navigate the user directly to App Notification Settings
+                                            val intent =
+                                                Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
+                                                    putExtra(
+                                                        Settings.EXTRA_APP_PACKAGE,
+                                                        context.packageName
+                                                    )
+                                                }
+                                            context.startActivity(intent)
+                                        }
+                                    },
+                                    modifier = Modifier.weight(1f),
+                                ) {
+                                    Text(text = "Turn on")
+                                }
+                            }
+                        }
+                    }
+                }
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
                     color = MaterialTheme.colorScheme.surface,
                     shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
                 ) {
@@ -253,7 +345,7 @@ fun HomeScreen(
                                 items(chatRooms.toList(), key = { it.id }) { room ->
                                     ChatRoom(
                                         room = room,
-                                    onClick = { onOpenChat(room.id) }
+                                        onClick = { navigator.navigate(Screen.Chat(room.id)) }
                                     )
                                 }
                             }
@@ -264,6 +356,9 @@ fun HomeScreen(
                         ModalBottomSheet(
                             onDismissRequest = { showBottomSheet = false },
                             sheetState = sheetState,
+                            modifier = Modifier
+                                .imePadding()
+                                .navigationBarsPadding(),
                         ) {
                             val pubkey = viewModel.currentUser()
                             val shortPubkey = pubkey?.short() ?: "Not available"
@@ -318,18 +413,21 @@ fun HomeScreen(
                                     ) {
                                         OutlinedButton(
                                             onClick = {
-                                            dismissAndRun { navController.navigate(Screen.MyQr) }
+                                                scope.launch {
+                                                    pubkey?.let {
+                                                        val bech32 = it.toBech32()
+                                                        val data =
+                                                            ClipData.newPlainText(bech32, bech32)
+                                                        clipboardManager.setClipEntry(ClipEntry(data))
+                                                    }
+                                                }
                                             },
                                         ) {
                                             Text(text = shortPubkey)
                                         }
                                         FilledIconButton(
                                             onClick = {
-                                            scope.launch {
+                                                dismissAndRun { navigator.navigate(Screen.MyQr) }
-                                                sheetState.hide()
-                                                showBottomSheet = false
-                                                navController.navigate(Screen.MyQr)
-                                            }
                                             },
                                             shape = MaterialShapes.Square.toShape()
                                         ) {
@@ -346,6 +444,7 @@ fun HomeScreen(
                         }
                     }
                 }
+            }
         },
     )
 }
@@ -398,11 +497,11 @@ fun ChatRoom(room: Room, onClick: () -> Unit) {
 fun BottomMenuList(
     onDismiss: (suspend () -> Unit) -> Unit
 ) {
-    val navController = LocalNavController.current
+    val navigator = LocalNavigator.current
     val viewModel = LocalNostrViewModel.current
 
     val defaultMenuList = listOf(
-        "Relay Management" to { navController.navigate(Screen.Relay) },
+        "Relay Management" to { navigator.navigate(Screen.Relay) },
         "Spams & Blocks" to { },
         "Contacts" to { },
         "Settings" to { }

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

@@ -7,11 +7,14 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
@@ -30,7 +33,6 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.toShape
 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
@@ -40,61 +42,57 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import coop.composeapp.generated.resources.ic_scanner
-import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.launch
 import org.jetbrains.compose.resources.painterResource
 import rust.nostr.sdk.Keys
 import rust.nostr.sdk.NostrConnectUri
 import rust.nostr.sdk.PublicKey
-import su.reya.coop.LocalNavController
+import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
+import su.reya.coop.shared.getExpressiveFontFamily
 import su.reya.coop.short
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun ImportScreen(
+fun ImportScreen() {
-    isLoading: Boolean,
-    onBack: () -> Unit,
-    onSave: (secret: String) -> Unit
-) {
     val snackbarHostState = LocalSnackbarHostState.current
-    val navController = LocalNavController.current
+    val navigator = LocalNavigator.current
+    val qrScanResult = LocalScanResult.current
+    val focusManager = LocalFocusManager.current
     val viewModel = LocalNostrViewModel.current
+
     val scope = rememberCoroutineScope()
 
+    val isLoggedIn by viewModel.isLoggedIn.collectAsStateWithLifecycle(false)
     var secret by remember { mutableStateOf("") }
     var pubkey by remember { mutableStateOf<PublicKey?>(null) }
-    val metadata by remember(pubkey) {
-        if (pubkey != null) {
-            viewModel.getMetadata(pubkey!!)
-        } else {
-            MutableStateFlow(null)
-        }
-    }.collectAsState(null)
 
+    // Get metadata when pubkey changes
+    val metadata by remember(pubkey) {
+        pubkey?.let(viewModel::getMetadata) ?: flowOf(null)
+    }.collectAsStateWithLifecycle(null)
 
     val profile = metadata?.asRecord()
     val displayName = profile?.displayName ?: profile?.name ?: pubkey?.short() ?: "Unknown"
     val picture = profile?.picture
     
-    val savedStateHandle = navController.currentBackStackEntry?.savedStateHandle
+    LaunchedEffect(qrScanResult.content) {
-    val qrResult by savedStateHandle
+        qrScanResult.content?.let { result ->
-        ?.getStateFlow<String?>("qr_result", null)
-        ?.collectAsState()
-        ?: remember { mutableStateOf(null) }
-
-    LaunchedEffect(qrResult) {
-        qrResult?.let { result ->
             runCatching {
                 if (result.startsWith("nsec")) {
                     Keys.parse(result)
@@ -106,8 +104,9 @@ fun ImportScreen(
             }
                 .onSuccess { it -> secret = result }
                 .onFailure { e -> println("Failed to parse QR: ${e.message}") }
+
             // Clear the nav state
-            navController.currentBackStackEntry?.savedStateHandle?.remove<String>("qr_result")
+            qrScanResult.clear()
         }
     }
 
@@ -126,7 +125,7 @@ fun ImportScreen(
                     containerColor = MaterialTheme.colorScheme.surfaceContainer,
                 ),
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    IconButton(onClick = { navigator.goBack() }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_arrow_back),
                             contentDescription = "Back"
@@ -134,7 +133,7 @@ fun ImportScreen(
                     }
                 },
                 actions = {
-                    IconButton(onClick = { navController.navigate(Screen.Scan) }) {
+                    IconButton(onClick = { navigator.navigate(Screen.Scan) }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_scanner),
                             contentDescription = "Scanner"
@@ -145,40 +144,44 @@ fun ImportScreen(
         },
         content = { innerPadding ->
             Column(
-                modifier = Modifier.fillMaxSize(),
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(top = innerPadding.calculateTopPadding())
+                    .imePadding(),
             ) {
                 Column(
                     modifier = Modifier
-                        .weight(1f)
                         .fillMaxWidth()
-                        .padding(top = innerPadding.calculateTopPadding()),
+                        .weight(1f),
                     verticalArrangement = Arrangement.Center,
                     horizontalAlignment = Alignment.CenterHorizontally
                 ) {
                     Box(
                         modifier = Modifier
                             .size(120.dp)
-                            .clip(MaterialShapes.Pentagon.toShape()),
+                            .clip(MaterialShapes.Cookie9Sided.toShape()),
                         contentAlignment = Alignment.Center
                     ) {
                         Avatar(
                             picture = picture,
                             description = "Profile picture",
                             modifier = Modifier.fillMaxSize(),
-                            shape = MaterialShapes.Pentagon.toShape(),
+                            shape = MaterialShapes.Cookie9Sided.toShape(),
                         )
                     }
                     Spacer(modifier = Modifier.size(8.dp))
                     Text(
                         text = displayName,
                         textAlign = TextAlign.Center,
-                        style = MaterialTheme.typography.titleLargeEmphasized,
+                        style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                            fontFamily = getExpressiveFontFamily()
+                        ),
                     )
                 }
                 Surface(
                     modifier = Modifier
-                        .weight(1f)
+                        .fillMaxWidth()
-                        .fillMaxWidth(),
+                        .weight(1f, fill = false),
                     color = MaterialTheme.colorScheme.surface,
                     shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
                 ) {
@@ -186,6 +189,10 @@ fun ImportScreen(
                         modifier = Modifier
                             .fillMaxSize()
                             .padding(24.dp)
+                    ) {
+                        Column(
+                            modifier = Modifier
+                                .weight(1f)
                                 .verticalScroll(rememberScrollState()),
                             verticalArrangement = Arrangement.spacedBy(16.dp)
                         ) {
@@ -198,14 +205,23 @@ fun ImportScreen(
                             BasicTextField(
                                 value = secret,
                                 onValueChange = { secret = it },
+                                enabled = !isLoggedIn,
                                 modifier = Modifier.fillMaxWidth(),
                                 maxLines = 4,
+                                keyboardOptions = KeyboardOptions(
+                                    imeAction = ImeAction.Done,
+                                ),
+                                keyboardActions = KeyboardActions(
+                                    onDone = {
+                                        focusManager.clearFocus()
+                                    }
+                                ),
                                 visualTransformation = PasswordVisualTransformation('*'),
                                 textStyle = MaterialTheme.typography.bodyMediumEmphasized.copy(
-                                color = MaterialTheme.colorScheme.primaryFixed,
+                                    color = MaterialTheme.colorScheme.tertiaryFixedDim,
                                     fontWeight = FontWeight.SemiBold,
                                 ),
-                            cursorBrush = SolidColor(MaterialTheme.colorScheme.secondary),
+                                cursorBrush = SolidColor(MaterialTheme.colorScheme.tertiaryContainer),
                                 decorationBox = { innerTextField ->
                                     Box(contentAlignment = Alignment.CenterStart) {
                                         if (secret.isEmpty()) {
@@ -223,27 +239,32 @@ fun ImportScreen(
                                     }
                                 }
                             )
-                        Spacer(modifier = Modifier.weight(1f))
+                        }
+                        Spacer(modifier = Modifier.size(16.dp))
                         Button(
                             onClick = {
-                                if (pubkey == null) {
                                 scope.launch {
+                                    if (pubkey == null) {
                                         viewModel.verifyIdentity(secret).let { pubkey = it }
-                                    }
                                     } else {
-                                    onSave(secret)
+                                        // Import the identity
+                                        viewModel.importIdentity(secret)
+                                        // Navigate to the home screen
+                                        navigator.navigate(Screen.Home)
                                     }
+                                }
+
                             },
                             modifier = Modifier
                                 .fillMaxWidth()
                                 .height(ButtonDefaults.MediumContainerHeight),
-                            enabled = secret.isNotBlank() && !isLoading,
+                            enabled = secret.isNotBlank() && !isLoggedIn,
                         ) {
-                            if (isLoading) {
+                            if (isLoggedIn) {
                                 LoadingIndicator()
                             } else {
                                 Text(
-                                    text = if (pubkey == null) "Verify" else "Continue",
+                                    text = if (pubkey == null) "Verify" else "Click again to Continue",
                                     style = MaterialTheme.typography.titleMediumEmphasized,
                                 )
                             }

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

@@ -19,13 +19,13 @@ import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.ic_arrow_back
 import io.github.alexzhirkevich.qrose.rememberQrCodePainter
 import org.jetbrains.compose.resources.painterResource
+import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
 
 @Composable
-fun MyQrScreen(
+fun MyQrScreen() {
-    onBack: () -> Unit
+    val navigator = LocalNavigator.current
-) {
     val snackbarHostState = LocalSnackbarHostState.current
     val viewModel = LocalNostrViewModel.current
     val currentUser = viewModel.currentUser() ?: return
@@ -41,7 +41,7 @@ fun MyQrScreen(
                     )
                 },
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    IconButton(onClick = { navigator.goBack() }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_arrow_back),
                             contentDescription = "Back"

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

@@ -54,8 +54,9 @@ 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.LocalNavController
+import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalNostrViewModel
+import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 import su.reya.coop.Screen
 import su.reya.coop.shared.Avatar
@@ -63,11 +64,10 @@ import su.reya.coop.short
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun NewChatScreen(
+fun NewChatScreen() {
-    onBack: () -> Unit,
-) {
     val snackbarHostState = LocalSnackbarHostState.current
-    val navController = LocalNavController.current
+    val navigator = LocalNavigator.current
+    val qrScanResult = LocalScanResult.current
     val viewModel = LocalNostrViewModel.current
 
     val contactList by viewModel.contactList.collectAsState(initial = emptySet())
@@ -76,12 +76,6 @@ fun NewChatScreen(
     val selectedReceivers = remember { mutableStateListOf<PublicKey>() }
     var query by remember { mutableStateOf("") }
 
-    val savedStateHandle = navController.currentBackStackEntry?.savedStateHandle
-    val qrResult by savedStateHandle
-        ?.getStateFlow<String?>("qr_result", null)
-        ?.collectAsState()
-        ?: remember { mutableStateOf(null) }
-
     LaunchedEffect(query) {
         if (query.length >= 3) {
             delay(500) // 500ms debounce
@@ -111,13 +105,19 @@ fun NewChatScreen(
         }
     }
 
-    LaunchedEffect(qrResult) {
+    LaunchedEffect(qrScanResult.content) {
-        qrResult?.let { result ->
+        qrScanResult.content?.let { result ->
+            // Verify the content
             runCatching { PublicKey.parse(result) }
-                .onSuccess { pubkey -> selectedReceivers.add(pubkey) }
+                .onSuccess { pubkey ->
-                .onFailure { e -> println("Failed to parse QR: ${e.message}") }
+                    selectedReceivers.add(pubkey)
+                }
+                .onFailure { e ->
+                    println("Failed to parse QR: ${e.message}")
+                }
+
             // Clear the nav state
-            navController.currentBackStackEntry?.savedStateHandle?.remove<String>("qr_result")
+            qrScanResult.clear()
         }
     }
 
@@ -136,7 +136,7 @@ fun NewChatScreen(
                     containerColor = MaterialTheme.colorScheme.surfaceContainer,
                 ),
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    IconButton(onClick = { navigator.goBack() }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_arrow_back),
                             contentDescription = "Back"
@@ -144,7 +144,7 @@ fun NewChatScreen(
                     }
                 },
                 actions = {
-                    IconButton(onClick = { navController.navigate(Screen.Scan) }) {
+                    IconButton(onClick = { navigator.navigate(Screen.Scan) }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_scanner),
                             contentDescription = "Scanner"
@@ -168,7 +168,7 @@ fun NewChatScreen(
                     ExtendedFloatingActionButton(
                         onClick = {
                             val roomId = viewModel.createChatRoom(selectedReceivers.toList())
-                            navController.navigate(Screen.Chat(roomId))
+                            navigator.navigate(Screen.Chat(roomId))
                         },
                         expanded = false,
                         icon = {
@@ -259,7 +259,7 @@ fun NewChatScreen(
                             selectedReceivers = selectedReceivers,
                             onContactClick = { pubkey ->
                                 val roomId = viewModel.createChatRoom(listOf(pubkey))
-                                navController.navigate(Screen.Chat(roomId))
+                                navigator.navigate(Screen.Chat(roomId))
                             },
                         )
                         Spacer(modifier = Modifier.size(16.dp))
@@ -270,7 +270,7 @@ fun NewChatScreen(
                             selectedReceivers = selectedReceivers,
                             onContactClick = { pubkey ->
                                 val roomId = viewModel.createChatRoom(listOf(pubkey))
-                                navController.navigate(Screen.Chat(roomId))
+                                navigator.navigate(Screen.Chat(roomId))
                             }
                         )
                         Spacer(modifier = Modifier.size(16.dp))

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

@@ -11,11 +11,14 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
@@ -36,33 +39,48 @@ 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
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 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.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.jetbrains.compose.resources.painterResource
+import su.reya.coop.LocalNavigator
+import su.reya.coop.LocalNostrViewModel
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.Screen
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun NewIdentityScreen(
+fun NewIdentityScreen() {
-    isLoading: Boolean,
+    val context = LocalContext.current
-    onBack: () -> Unit,
-    onSave: (name: String, bio: String?, picture: Uri?) -> Unit
-) {
     val snackbarHostState = LocalSnackbarHostState.current
+    val focusManager = LocalFocusManager.current
+    val navigator = LocalNavigator.current
+    val viewModel = LocalNostrViewModel.current
+
+    val isLoggedIn by viewModel.isLoggedIn.collectAsStateWithLifecycle(false)
     var name by remember { mutableStateOf("") }
     var bio by remember { mutableStateOf("") }
     var picture by remember { mutableStateOf<Uri?>(null) }
 
+    val scope = rememberCoroutineScope()
+
     val launcher = rememberLauncherForActivityResult(
         contract = ActivityResultContracts.GetContent()
     ) { uri: Uri? ->
@@ -81,7 +99,7 @@ fun NewIdentityScreen(
                     )
                 },
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    IconButton(onClick = { navigator.goBack() }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_arrow_back),
                             contentDescription = "Back"
@@ -94,16 +112,17 @@ fun NewIdentityScreen(
             )
         },
         content = { innerPadding ->
-            Column(
-                modifier = Modifier.fillMaxSize(),
-            ) {
             Column(
                 modifier = Modifier
-                        .weight(1f)
+                    .fillMaxSize()
+                    .padding(top = innerPadding.calculateTopPadding())
+                    .imePadding(),
+            ) {
+                Box(
+                    modifier = Modifier
                         .fillMaxWidth()
-                        .padding(top = innerPadding.calculateTopPadding()),
+                        .weight(1f),
-                    verticalArrangement = Arrangement.Center,
+                    contentAlignment = Alignment.Center
-                    horizontalAlignment = Alignment.CenterHorizontally
                 ) {
                     Box(
                         modifier = Modifier
@@ -139,8 +158,8 @@ fun NewIdentityScreen(
                 }
                 Surface(
                     modifier = Modifier
-                        .weight(1f)
+                        .fillMaxWidth()
-                        .fillMaxWidth(),
+                        .weight(1f, fill = true),
                     color = MaterialTheme.colorScheme.surface,
                     shape = RoundedCornerShape(topStart = 24.dp, topEnd = 24.dp),
                 ) {
@@ -148,6 +167,10 @@ fun NewIdentityScreen(
                         modifier = Modifier
                             .fillMaxSize()
                             .padding(24.dp)
+                    ) {
+                        Column(
+                            modifier = Modifier
+                                .weight(1f)
                                 .verticalScroll(rememberScrollState()),
                             verticalArrangement = Arrangement.spacedBy(16.dp)
                         ) {
@@ -160,13 +183,22 @@ fun NewIdentityScreen(
                             BasicTextField(
                                 value = name,
                                 onValueChange = { name = it },
+                                enabled = !isLoggedIn,
                                 modifier = Modifier.fillMaxWidth(),
-                            maxLines = 1,
+                                singleLine = true,
+                                keyboardOptions = KeyboardOptions(
+                                    imeAction = ImeAction.Done,
+                                ),
+                                keyboardActions = KeyboardActions(
+                                    onDone = {
+                                        focusManager.clearFocus()
+                                    }
+                                ),
                                 textStyle = MaterialTheme.typography.headlineLargeEmphasized.copy(
-                                color = MaterialTheme.colorScheme.primaryFixed,
+                                    color = MaterialTheme.colorScheme.tertiaryFixedDim,
                                     fontWeight = FontWeight.SemiBold,
                                 ),
-                            cursorBrush = SolidColor(MaterialTheme.colorScheme.secondary),
+                                cursorBrush = SolidColor(MaterialTheme.colorScheme.tertiaryContainer),
                                 decorationBox = { innerTextField ->
                                     Box(contentAlignment = Alignment.CenterStart) {
                                         if (name.isEmpty()) {
@@ -194,8 +226,17 @@ fun NewIdentityScreen(
                             BasicTextField(
                                 value = bio,
                                 onValueChange = { bio = it },
+                                enabled = !isLoggedIn,
                                 modifier = Modifier.fillMaxWidth(),
                                 maxLines = 3,
+                                keyboardOptions = KeyboardOptions(
+                                    imeAction = ImeAction.Done,
+                                ),
+                                keyboardActions = KeyboardActions(
+                                    onDone = {
+                                        focusManager.clearFocus()
+                                    }
+                                ),
                                 textStyle = MaterialTheme.typography.bodyLarge.copy(
                                     color = MaterialTheme.colorScheme.primaryFixed,
                                     fontWeight = FontWeight.SemiBold,
@@ -218,17 +259,39 @@ fun NewIdentityScreen(
                                     }
                                 }
                             )
-                        Spacer(modifier = Modifier.weight(1f))
+                        }
+                        Spacer(modifier = Modifier.size(16.dp))
                         Button(
                             onClick = {
-                                onSave(name, bio, picture)
+                                scope.launch {
+                                    try {
+                                        val imageBytes = withContext(Dispatchers.IO) {
+                                            picture?.let { uri ->
+                                                context.contentResolver.openInputStream(
+                                                    uri
+                                                )?.use { input -> input.readBytes() }
+                                            }
+                                        }
+
+                                        val contentType =
+                                            picture?.let { context.contentResolver.getType(it) }
+
+                                        // Create the identity
+                                        viewModel.createIdentity(name, bio, imageBytes, contentType)
+
+                                        // Navigate to the home screen if successful
+                                        navigator.navigate(Screen.Home)
+                                    } catch (e: Exception) {
+                                        // Error is handled by viewModel.showError inside createIdentity
+                                    }
+                                }
                             },
                             modifier = Modifier
                                 .fillMaxWidth()
                                 .height(ButtonDefaults.MediumContainerHeight),
-                            enabled = name.isNotBlank() && !isLoading,
+                            enabled = name.isNotBlank() && !isLoggedIn,
                         ) {
-                            if (isLoading) {
+                            if (isLoggedIn) {
                                 LoadingIndicator()
                             } else {
                                 Text(

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

@@ -9,16 +9,17 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
-import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Size
@@ -26,27 +27,69 @@ import androidx.compose.ui.graphics.ColorFilter
 import androidx.compose.ui.graphics.drawscope.rotate
 import androidx.compose.ui.graphics.drawscope.translate
 import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.text.LinkAnnotation
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.TextLinkStyles
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import coop.composeapp.generated.resources.Res
 import coop.composeapp.generated.resources.coop
 import org.jetbrains.compose.resources.painterResource
+import su.reya.coop.LocalNavigator
 import su.reya.coop.LocalSnackbarHostState
+import su.reya.coop.Screen
+import su.reya.coop.shared.getExpressiveFontFamily
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun OnboardingScreen(onOpenImport: () -> Unit, onOpenNew: () -> Unit) {
+fun OnboardingScreen() {
     val snackbarHostState = LocalSnackbarHostState.current
+    val navigator = LocalNavigator.current
+
     val logoPainter = painterResource(Res.drawable.coop)
+    val expressiveFont = getExpressiveFontFamily()
+    val annotatedText = buildAnnotatedString {
+        append("By using Coop, you agree to accept\nour ")
+        // Push "Terms of Use" link
+        pushLink(
+            LinkAnnotation.Url(
+                url = "https://coop.free/terms",
+                styles = TextLinkStyles(
+                    style = SpanStyle(
+                        color = MaterialTheme.colorScheme.onSecondaryContainer,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                )
+            )
+        )
+        append("Terms of Use")
+        pop()
+        append(" and ")
+        // Push "Privacy Policy" link
+        pushLink(
+            LinkAnnotation.Url(
+                url = "https://coop.free/privacy",
+                styles = TextLinkStyles(
+                    style = SpanStyle(
+                        color = MaterialTheme.colorScheme.onSecondaryContainer,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                )
+            )
+        )
+        append("Privacy Policy")
+        pop()
+        append(".")
+    }
+
 
     Scaffold(
-        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        containerColor = MaterialTheme.colorScheme.secondaryContainer,
         snackbarHost = { SnackbarHost(snackbarHostState) },
         content = { innerPadding ->
-            Box(
+            Box(modifier = Modifier.fillMaxSize()) {
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(bottom = innerPadding.calculateBottomPadding())
-            ) {
                 LogoRepeatingBackground(
                     painter = logoPainter,
                     logosPerRow = 6,
@@ -54,55 +97,71 @@ fun OnboardingScreen(onOpenImport: () -> Unit, onOpenNew: () -> Unit) {
                     horizontalOffset = 0.5f
                 )
                 Column(
-                    modifier = Modifier.fillMaxSize(),
-                ) {
-                    Box(
                     modifier = Modifier
-                            .weight(2f)
+                        .fillMaxSize()
-                            .fillMaxWidth(),
+                        .padding(bottom = innerPadding.calculateBottomPadding() + 16.dp),
-                        contentAlignment = Alignment.Center,
                 ) {
-                        // TODO: Add headline
+                    Spacer(modifier = Modifier.weight(2f))
-                    }
+                    Surface(
-                    Box(
                         modifier = Modifier
-                            .weight(1f)
                             .fillMaxWidth()
-                            .padding(bottom = innerPadding.calculateBottomPadding()),
+                            .padding(24.dp),
-                        contentAlignment = Alignment.BottomEnd,
+                        shape = RoundedCornerShape(16.dp),
+                        color = MaterialTheme.colorScheme.surface,
+                        contentColor = MaterialTheme.colorScheme.onSurface,
+                        shadowElevation = 4.dp,
                     ) {
                         Column(
-                            modifier = Modifier.padding(horizontal = innerPadding.calculateBottomPadding()),
-                        ) {
-                            Button(
-                                onClick = onOpenNew,
                             modifier = Modifier
                                 .fillMaxWidth()
-                                    .size(ButtonDefaults.LargeContainerHeight),
+                                .padding(24.dp),
                         ) {
                             Text(
-                                    text = "Start messaging",
+                                text = "Get Started",
-                                    style = MaterialTheme.typography.titleLargeEmphasized,
+                                style = MaterialTheme.typography.headlineSmallEmphasized.copy(
-                                )
+                                    fontFamily = expressiveFont,
-                            }
-                            Spacer(modifier = Modifier.size(16.dp))
-                            FilledTonalButton(
-                                onClick = onOpenImport,
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .height(ButtonDefaults.LargeContainerHeight),
-                                colors = ButtonDefaults.filledTonalButtonColors(
-                                    containerColor = MaterialTheme.colorScheme.tertiaryContainer,
-                                    contentColor = MaterialTheme.colorScheme.onTertiaryContainer
                                 ),
+                                fontWeight = FontWeight.SemiBold,
+                            )
+                            Spacer(modifier = Modifier.size(8.dp))
+                            Text(
+                                text = "Coop is a secure and easy to use messaging app. All your communications are encrypted and private by default.",
+                                style = MaterialTheme.typography.bodyMedium,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            )
+                            Spacer(modifier = Modifier.size(24.dp))
+                            Button(
+                                onClick = { navigator.navigate(Screen.NewIdentity) },
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .size(ButtonDefaults.MediumContainerHeight),
                             ) {
                                 Text(
-                                    text = "Import identity",
+                                    text = "Start Messaging",
-                                    style = MaterialTheme.typography.titleLargeEmphasized,
+                                    style = MaterialTheme.typography.titleMediumEmphasized,
+                                )
+                            }
+                            Spacer(modifier = Modifier.size(8.dp))
+                            OutlinedButton(
+                                onClick = { navigator.navigate(Screen.Import) },
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .height(ButtonDefaults.MediumContainerHeight),
+                            ) {
+                                Text(
+                                    text = "Add an Existing Identity",
+                                    style = MaterialTheme.typography.titleMedium,
                                 )
                             }
                         }
                     }
+                    Text(
+                        text = annotatedText,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSecondaryContainer,
+                        textAlign = TextAlign.Center,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
                 }
             }
         }
@@ -116,7 +175,7 @@ fun LogoRepeatingBackground(
     rotationDegrees: Float = 0f,
     horizontalOffset: Float = 0.5f
 ) {
-    val tintColor = MaterialTheme.colorScheme.primary
+    val tintColor = MaterialTheme.colorScheme.onSecondaryContainer
 
     Canvas(modifier = Modifier.fillMaxSize()) {
         val canvasWidth = size.width

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

@@ -0,0 +1,240 @@
+package su.reya.coop.screens
+
+import android.content.Intent
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.FilledTonalIconButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItemDefaults
+import androidx.compose.material3.MaterialShapes
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SegmentedListItem
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.toShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import coop.composeapp.generated.resources.Res
+import coop.composeapp.generated.resources.ic_arrow_back
+import coop.composeapp.generated.resources.ic_chat
+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.LocalNavigator
+import su.reya.coop.LocalNostrViewModel
+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
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun ProfileScreen(pubkey: String) {
+    val pubkey = runCatching { PublicKey.parse(pubkey) }.getOrNull() ?: return
+
+    val context = LocalContext.current
+    val snackbarHostState = LocalSnackbarHostState.current
+    val navigator = LocalNavigator.current
+    val viewModel = LocalNostrViewModel.current
+
+    val scope = rememberCoroutineScope()
+    val metadataFlow = remember(pubkey) { viewModel.getMetadata(pubkey) }
+    val metadata by metadataFlow.collectAsState(initial = null)
+
+    val profile = metadata?.asRecord()
+    val displayName = profile?.displayName ?: profile?.name ?: "No name"
+    val nip05 = profile?.nip05 ?: pubkey.short()
+    val picture = profile?.picture
+    val details = remember(profile) {
+        listOf(
+            "Username:" to (profile?.name ?: "None"),
+            "Website:" to (profile?.website ?: "None"),
+            "Lightning Address:" to (profile?.lud16 ?: "None"),
+        )
+    }
+
+    Scaffold(
+        containerColor = MaterialTheme.colorScheme.surfaceContainer,
+        snackbarHost = { SnackbarHost(snackbarHostState) },
+        topBar = {
+            TopAppBar(
+                title = { },
+                navigationIcon = {
+                    IconButton(onClick = { navigator.goBack() }) {
+                        Icon(
+                            painter = painterResource(Res.drawable.ic_arrow_back),
+                            contentDescription = "Back"
+                        )
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = MaterialTheme.colorScheme.surfaceContainer,
+                )
+            )
+        },
+        content = { innerPadding ->
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(innerPadding),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+            ) {
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp)
+                        .weight(1f),
+                    verticalArrangement = Arrangement.Center,
+                    horizontalAlignment = Alignment.CenterHorizontally
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .size(120.dp)
+                            .clip(MaterialShapes.Cookie9Sided.toShape()),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Avatar(
+                            picture = picture,
+                            description = "Profile picture",
+                            modifier = Modifier.fillMaxSize(),
+                            shape = MaterialShapes.Cookie9Sided.toShape(),
+                        )
+                    }
+                    Spacer(modifier = Modifier.size(8.dp))
+                    Column(
+                        horizontalAlignment = Alignment.CenterHorizontally,
+                        verticalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        Text(
+                            text = displayName,
+                            textAlign = TextAlign.Center,
+                            style = MaterialTheme.typography.titleLargeEmphasized.copy(
+                                fontFamily = getExpressiveFontFamily()
+                            ),
+                        )
+                        Text(
+                            text = nip05,
+                            textAlign = TextAlign.Center,
+                            style = MaterialTheme.typography.titleSmall
+                        )
+                    }
+                    Spacer(modifier = Modifier.size(24.dp))
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        Column(
+                            modifier = Modifier.weight(1f),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            verticalArrangement = Arrangement.spacedBy(4.dp),
+                        ) {
+                            FilledTonalIconButton(
+                                onClick = {
+                                    scope.launch {
+                                        try {
+                                            val roomId = viewModel.createChatRoom(listOf(pubkey))
+                                            navigator.navigate(Screen.Chat(roomId))
+                                        } catch (e: Exception) {
+                                            e.message?.let { snackbarHostState.showSnackbar(it) }
+                                        }
+                                    }
+                                },
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .height(ButtonDefaults.MediumContainerHeight),
+                            ) {
+                                Icon(
+                                    painter = painterResource(Res.drawable.ic_chat),
+                                    contentDescription = "New Chat"
+                                )
+                            }
+                            Text(
+                                text = "Message",
+                                style = MaterialTheme.typography.labelSmall
+                            )
+                        }
+                        Column(
+                            modifier = Modifier.weight(1f),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            verticalArrangement = Arrangement.spacedBy(4.dp),
+                        ) {
+                            FilledTonalIconButton(
+                                onClick = {
+                                    val sendIntent = Intent().apply {
+                                        action = Intent.ACTION_SEND
+                                        putExtra(Intent.EXTRA_TEXT, pubkey.toBech32())
+                                        type = "text/plain"
+                                    }
+                                    val shareIntent = Intent.createChooser(sendIntent, null)
+                                    context.startActivity(shareIntent)
+                                },
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .height(ButtonDefaults.MediumContainerHeight),
+                            ) {
+                                Icon(
+                                    painter = painterResource(Res.drawable.ic_share),
+                                    contentDescription = "Share"
+                                )
+                            }
+                            Text(
+                                text = "Share",
+                                style = MaterialTheme.typography.labelMedium
+                            )
+                        }
+                    }
+                }
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp)
+                        .weight(1.5f),
+                    verticalArrangement = Arrangement.spacedBy(16.dp),
+                ) {
+                    Column(
+                        modifier = Modifier.fillMaxWidth(),
+                        verticalArrangement = Arrangement.spacedBy(ListItemDefaults.SegmentedGap),
+                    ) {
+                        details.forEachIndexed { index, (label, value) ->
+                            SegmentedListItem(
+                                onClick = { },
+                                shapes = ListItemDefaults.segmentedShapes(
+                                    index = index,
+                                    count = details.size
+                                ),
+                                content = { Text(label) },
+                                supportingContent = { Text(value) },
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    )
+}

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

@@ -34,14 +34,14 @@ import coop.composeapp.generated.resources.ic_arrow_back
 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
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
-fun RelayScreen(
+fun RelayScreen() {
-    onBack: () -> Unit
+    val navigator = LocalNavigator.current
-) {
     val snackbarHostState = LocalSnackbarHostState.current
     val viewModel = LocalNostrViewModel.current
 
@@ -80,7 +80,7 @@ fun RelayScreen(
                     )
                 },
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    IconButton(onClick = { navigator.goBack() }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_arrow_back),
                             contentDescription = "Back"

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

@@ -30,21 +30,16 @@ import org.jetbrains.compose.resources.painterResource
 import org.publicvalue.multiplatform.qrcode.CameraPosition
 import org.publicvalue.multiplatform.qrcode.CodeType
 import org.publicvalue.multiplatform.qrcode.ScannerWithPermissions
-import su.reya.coop.LocalNavController
+import su.reya.coop.LocalNavigator
+import su.reya.coop.LocalScanResult
 import su.reya.coop.LocalSnackbarHostState
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
 @Composable
-fun ScanScreen(
+fun ScanScreen() {
-    onBack: () -> Unit
+    val navigator = LocalNavigator.current
-) {
-    val navController = LocalNavController.current
     val snackbarHostState = LocalSnackbarHostState.current
-
+    val qrScanResult = LocalScanResult.current
-    val onResult: (String) -> Unit = { result ->
-        navController.previousBackStackEntry?.savedStateHandle?.set("qr_result", result)
-        navController.popBackStack()
-    }
 
     Scaffold(
         snackbarHost = { SnackbarHost(snackbarHostState) },
@@ -57,7 +52,7 @@ fun ScanScreen(
                     )
                 },
                 navigationIcon = {
-                    IconButton(onClick = onBack) {
+                    IconButton(onClick = { navigator.goBack() }) {
                         Icon(
                             painter = painterResource(Res.drawable.ic_arrow_back),
                             contentDescription = "Back"
@@ -76,8 +71,8 @@ fun ScanScreen(
             ScannerWithPermissions(
                 modifier = Modifier.fillMaxSize(),
                 onScanned = {
-                    println("Scanned: $it");
+                    qrScanResult.content = it
-                    onResult(it)
+                    navigator.goBack()
                     true
                 },
                 types = listOf(CodeType.QR),

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

@@ -0,0 +1,13 @@
+package su.reya.coop.shared
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import coop.composeapp.generated.resources.PaytoneOne_Regular
+import coop.composeapp.generated.resources.Res
+import org.jetbrains.compose.resources.Font
+
+@Composable
+fun getExpressiveFontFamily() = FontFamily(
+    Font(Res.font.PaytoneOne_Regular, FontWeight.Normal)
+)

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

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

composeApp/src/androidMain/res/drawable/coop.xml

@@ -0,0 +1,22 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="200dp"
+    android:height="200dp"
+    android:viewportWidth="120"
+    android:viewportHeight="120">
+
+  <group
+      android:translateX="20"
+      android:translateY="20">
+    <path
+        android:pathData="M37.54,74C52.75,74 65.08,61.581 65.08,46.262C65.08,44.87 63.959,43.74 62.576,43.74H12.504C11.12,43.74 10,44.87 10,46.262C10,61.581 22.33,74 37.54,74Z"
+        android:fillColor="#000000"
+        android:fillType="evenOdd"/>
+    <path
+        android:pathData="M49.707,14.321L49.493,14.263L49.279,14.207L49.062,14.153L48.843,14.099L48.627,14.049L48.411,14L48.194,13.952L47.976,13.907L47.748,13.861L47.518,13.817L47.287,13.775L47.055,13.735L46.94,13.715L46.828,13.697L46.604,13.662L46.381,13.629L46.157,13.598L45.927,13.568L45.696,13.54L45.467,13.514L45.236,13.49L45.005,13.467L44.774,13.447L44.543,13.428L44.31,13.412L44.08,13.398L43.851,13.385L43.623,13.375L43.392,13.366L43.159,13.359L42.926,13.354L42.694,13.351L42.46,13.35H42.184L41.903,13.356L41.623,13.363L41.343,13.373L41.063,13.385L40.784,13.401L40.504,13.419L40.224,13.44L39.932,13.466L39.64,13.494L39.357,13.524L39.074,13.558L38.781,13.596L38.489,13.637L38.209,13.679L37.929,13.724L37.649,13.772L37.369,13.823L37.103,13.875L36.836,13.929L36.57,13.986L36.418,14.02L36.306,14.045L36.026,14.111L35.746,14.18L35.466,14.252L35.187,14.328L34.917,14.403L34.648,14.482L34.512,14.523L34.376,14.564L34.109,14.649L33.847,14.734L33.587,14.821C33.587,14.821 32.45,13.249 32.536,12.136C32.644,10.731 33.588,9.592 34.837,9.163C34.764,8.837 34.687,8.51 34.713,8.16C34.859,6.274 36.501,4.864 38.377,5.01C39.485,5.096 40.376,5.734 40.932,6.605C41.616,5.83 42.598,5.339 43.705,5.425C45.449,5.561 46.733,7.01 46.794,8.726C47.033,8.691 47.264,8.617 47.516,8.637C49.394,8.783 50.796,10.429 50.65,12.315C50.58,13.232 49.707,14.321 49.707,14.321Z"
+        android:fillColor="#000000"/>
+    <path
+        android:pathData="M14.92,41.088C14.92,25.769 27.25,13.35 42.46,13.35C57.669,13.35 70,25.769 70,41.088C70,42.481 68.879,43.61 67.496,43.61H17.424C16.04,43.61 14.92,42.481 14.92,41.088ZM54.627,26.453C54.476,26.411 54.325,26.389 54.172,26.389C54.018,26.389 53.867,26.411 53.717,26.453C53.566,26.496 53.42,26.561 53.279,26.645C53.138,26.73 53.003,26.833 52.876,26.956C52.748,27.079 52.63,27.218 52.522,27.375C52.413,27.531 52.316,27.701 52.232,27.885C52.147,28.068 52.075,28.262 52.016,28.467C51.957,28.671 51.913,28.882 51.883,29.098C51.854,29.315 51.839,29.533 51.839,29.755C51.839,29.976 51.854,30.195 51.883,30.411C51.913,30.628 51.957,30.838 52.016,31.043C52.075,31.247 52.147,31.441 52.232,31.625C52.316,31.808 52.413,31.979 52.522,32.135C52.63,32.291 52.748,32.43 52.876,32.553C53.003,32.676 53.138,32.78 53.279,32.864C53.42,32.949 53.566,33.013 53.717,33.056C53.867,33.1 54.018,33.121 54.172,33.121C54.325,33.121 54.476,33.1 54.627,33.056C54.777,33.013 54.923,32.949 55.064,32.864C55.206,32.78 55.341,32.676 55.468,32.553C55.595,32.43 55.714,32.291 55.822,32.135C55.93,31.979 56.027,31.808 56.112,31.625C56.197,31.441 56.268,31.247 56.327,31.043C56.386,30.838 56.431,30.628 56.46,30.411C56.49,30.195 56.505,29.976 56.505,29.755C56.505,29.533 56.49,29.315 56.46,29.098C56.431,28.882 56.386,28.671 56.327,28.467C56.268,28.262 56.197,28.068 56.112,27.885C56.027,27.701 55.93,27.531 55.822,27.375C55.714,27.218 55.595,27.079 55.468,26.956C55.341,26.833 55.206,26.73 55.064,26.645C54.923,26.561 54.777,26.496 54.627,26.453Z"
+        android:fillColor="#000000"
+        android:fillType="evenOdd"/>
+  </group>
+</vector>

composeApp/src/androidMain/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="secondaryContainer">#F8FF37</color>
+</resources>

composeApp/src/androidMain/res/values/themes.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <style name="Theme.App.Starting" parent="Theme.SplashScreen">
+        <item name="windowSplashScreenBackground">@color/secondaryContainer</item>
+        <item name="windowSplashScreenAnimatedIcon">@drawable/coop</item>
+        <item name="postSplashScreenTheme">@android:style/Theme.Material.Light.NoActionBar</item>
+    </style>
+</resources>

gradle/libs.versions.toml

@@ -1,23 +1,27 @@
 [versions]
 agp = "9.2.1"
-android-compileSdk = "36"
+android-compileSdk = "37"
-android-minSdk = "24"
+android-minSdk = "26"
-android-targetSdk = "36"
+android-targetSdk = "37"
 androidx-activity = "1.13.0"
 androidx-appcompat = "1.7.1"
 androidx-core = "1.18.0"
 androidx-espresso = "3.7.0"
 androidx-lifecycle = "2.10.0"
-androidx-navigation = "2.8.8"
 androidx-testExt = "1.3.0"
-composeMultiplatform = "1.10.3"
+androidx-splashscreen = "1.2.0"
+composeMultiplatform = "1.11.0"
+datastorePreferences = "1.2.1"
 junit = "4.13.2"
-kotlin = "2.3.20"
+kotlin = "2.3.21"
-kotlinx-serialization = "1.8.0"
+kotlinx-serialization = "1.11.0"
-material3 = "1.10.0-alpha05"
+material3 = "1.11.0-alpha07"
-ktor = "3.4.3"
+multiplatform-nav3-ui = "1.1.1"
+ktor = "3.5.0"
 
 [libraries]
+androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastorePreferences" }
+androidx-datastore = { module = "androidx.datastore:datastore", version.ref = "datastorePreferences" }
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 kotlin-testJunit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
 junit = { module = "junit:junit", version.ref = "junit" }
@@ -25,12 +29,13 @@ androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "androidx
 androidx-testExt-junit = { module = "androidx.test.ext:junit", version.ref = "androidx-testExt" }
 androidx-espresso-core = { module = "androidx.test.espresso:espresso-core", version.ref = "androidx-espresso" }
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "androidx-appcompat" }
+androidx-core-splashscreen = { module = "androidx.core:core-splashscreen", version.ref = "androidx-splashscreen" }
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activity" }
-androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidx-navigation" }
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
 compose-uiTooling = { module = "org.jetbrains.compose.ui:ui-tooling", version.ref = "composeMultiplatform" }
 androidx-lifecycle-viewmodelCompose = { module = "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "androidx-lifecycle" }
 androidx-lifecycle-runtimeCompose = { module = "org.jetbrains.androidx.lifecycle:lifecycle-runtime-compose", version.ref = "androidx-lifecycle" }
+androidx-lifecycle-process = { group = "androidx.lifecycle", name = "lifecycle-process", version.ref = "androidx-lifecycle" }
 compose-runtime = { module = "org.jetbrains.compose.runtime:runtime", version.ref = "composeMultiplatform" }
 compose-foundation = { module = "org.jetbrains.compose.foundation:foundation", version.ref = "composeMultiplatform" }
 compose-material3 = { module = "org.jetbrains.compose.material3:material3", version.ref = "material3" }
@@ -43,6 +48,8 @@ ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "kto
 ktor-client-websockets = { module = "io.ktor:ktor-client-websockets", version.ref = "ktor" }
 ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
+jetbrains-navigation3-ui = { module = "org.jetbrains.androidx.navigation3:navigation3-ui", version.ref = "multiplatform-nav3-ui" }
+jetbrains-lifecycle-viewmodelNavigation3 = { module = "org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-navigation3", version.ref = "androidx-lifecycle" }
 
 [plugins]
 androidApplication = { id = "com.android.application", version.ref = "agp" }

shared/build.gradle.kts

@@ -25,15 +25,15 @@ kotlin {
 
     sourceSets {
         commonMain.dependencies {
-            implementation("org.jetbrains.androidx.lifecycle:lifecycle-viewmodel-compose:2.10.0")
-            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
-            implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.8.0")
-            implementation("su.reya:nostr-sdk-kmp:0.2.3")
-            implementation("com.squareup.okio:okio:3.16.2")
             implementation(libs.ktor.client.core)
             implementation(libs.ktor.client.websockets)
             implementation(libs.ktor.client.content.negotiation)
             implementation(libs.ktor.serialization.kotlinx.json)
+            implementation(libs.androidx.lifecycle.viewmodelCompose)
+            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
+            implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.8.0")
+            implementation("su.reya:nostr-sdk-kmp:0.2.3")
+            implementation("com.squareup.okio:okio:3.16.2")
         }
         androidMain.dependencies {
             implementation(libs.ktor.client.okhttp)

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

@@ -1,75 +0,0 @@
-package su.reya.coop
-
-import io.ktor.client.HttpClient
-import io.ktor.client.plugins.websocket.DefaultClientWebSocketSession
-import io.ktor.client.plugins.websocket.webSocketSession
-import io.ktor.client.request.url
-import io.ktor.websocket.Frame
-import io.ktor.websocket.close
-import io.ktor.websocket.readBytes
-import io.ktor.websocket.readText
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.channels.ClosedReceiveChannelException
-import rust.nostr.sdk.ConnectionMode
-import rust.nostr.sdk.CustomWebSocketTransport
-import rust.nostr.sdk.WebSocketAdapter
-import rust.nostr.sdk.WebSocketAdapterWrapper
-import rust.nostr.sdk.WebSocketMessage
-
-class KtorWebSocketAdapter(
-    private val client: HttpClient,
-    private val session: DefaultClientWebSocketSession
-) : WebSocketAdapter {
-
-    override suspend fun send(msg: WebSocketMessage) {
-        try {
-            when (msg) {
-                is WebSocketMessage.Text -> session.send(Frame.Text(msg.text))
-                is WebSocketMessage.Binary -> session.send(Frame.Binary(true, msg.bytes))
-                is WebSocketMessage.Ping -> session.send(Frame.Ping(msg.bytes))
-                is WebSocketMessage.Pong -> session.send(Frame.Pong(msg.bytes))
-                else -> {}
-            }
-        } catch (e: Exception) {
-            println("Attempted to send on a closed WebSocket: ${e.message}")
-            throw e
-        }
-    }
-
-    override suspend fun recv(): WebSocketMessage? {
-        return try {
-            when (val frame = session.incoming.receive()) {
-                is Frame.Text -> WebSocketMessage.Text(frame.readText())
-                is Frame.Binary -> WebSocketMessage.Binary(frame.readBytes())
-                is Frame.Ping -> WebSocketMessage.Ping(frame.readBytes())
-                is Frame.Pong -> WebSocketMessage.Pong(frame.readBytes())
-                else -> null
-            }
-        } catch (e: ClosedReceiveChannelException) {
-            null
-        } catch (e: Exception) {
-            throw e
-        }
-    }
-
-    override suspend fun closeConnection() {
-        session.cancel()
-        session.close()
-    }
-}
-
-class CoopWebSocketClient(private val httpClient: HttpClient) : CustomWebSocketTransport {
-    override fun supportPing(): Boolean = false
-
-    override suspend fun connect(url: String, mode: ConnectionMode): WebSocketAdapterWrapper {
-        try {
-            val session = httpClient.webSocketSession {
-                url(url)
-            }
-            val adapter = KtorWebSocketAdapter(httpClient, session)
-            return WebSocketAdapterWrapper(adapter)
-        } catch (e: Exception) {
-            throw e
-        }
-    }
-}

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

@@ -2,17 +2,16 @@ package su.reya.coop
 
 import io.ktor.client.HttpClient
 import io.ktor.client.call.body
-import io.ktor.client.plugins.websocket.WebSockets
 import io.ktor.client.request.get
 import io.ktor.client.statement.HttpResponse
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.supervisorScope
 import rust.nostr.sdk.AckPolicy
 import rust.nostr.sdk.Alphabet
 import rust.nostr.sdk.AsyncNostrSigner
@@ -56,15 +55,13 @@ import rust.nostr.sdk.giftWrapAsync
 import rust.nostr.sdk.initLogger
 import rust.nostr.sdk.nip17ExtractRelayList
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
 
 object NostrManager {
     val instance = Nostr()
 }
 
 class Nostr {
-    private val _isInitialized = MutableStateFlow(false)
-    val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()
-
     var client: Client? = null
         private set
     var signer: UniversalSigner = UniversalSigner(Keys.generate())
@@ -76,24 +73,49 @@ class Nostr {
     var rumorMap: MutableMap<EventId, EventId> = mutableMapOf()
         private set
 
+    private val isInitialized = MutableStateFlow(false)
+
+    // Add these to the Nostr class
+    private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
+    val newEvents = _newEvents.asSharedFlow()
+
+    private val _metadataUpdates =
+        MutableSharedFlow<Pair<PublicKey, Metadata>>(extraBufferCapacity = 100)
+    val metadataUpdates = _metadataUpdates.asSharedFlow()
+
+    private val _contactListUpdates = MutableSharedFlow<List<PublicKey>>(extraBufferCapacity = 100)
+    val contactListUpdates = _contactListUpdates.asSharedFlow()
+
+    private val _subscriptionClosed = MutableSharedFlow<Unit>(extraBufferCapacity = 10)
+    val subscriptionClosed = _subscriptionClosed.asSharedFlow()
+
+    suspend fun emitNewEvent(event: UnsignedEvent) = _newEvents.emit(event)
+
+    suspend fun emitSubscriptionClosed() = _subscriptionClosed.emit(Unit)
+
+    suspend fun emitMetadataUpdate(pubkey: PublicKey, metadata: Metadata) =
+        _metadataUpdates.emit(pubkey to metadata)
+
+    suspend fun emitContactListUpdate(contacts: List<PublicKey>) =
+        _contactListUpdates.emit(contacts)
+
     suspend fun init(dbPath: String) {
         try {
-            if (_isInitialized.value) return
+            if (isInitialized.value) return
 
             // Initialize the logger for nostr client
             initLogger(LogLevel.DEBUG)
 
+            // Initialize the database and gossip instance
             val lmdb = NostrDatabase.lmdb(dbPath)
             val gossip = NostrGossip.inMemory()
+
+            // Set the idle timeout for relays
             val idleTimeout = Duration.parse("5m")
-            val httpClient = HttpClient {
-                install(WebSockets)
-            }
 
             client =
                 ClientBuilder()
                     .signer(signer)
-                    .websocketTransport(CoopWebSocketClient(httpClient))
                     .database(lmdb)
                     .gossip(gossip)
                     .gossipConfig(
@@ -108,14 +130,14 @@ class Nostr {
                     .sleepWhenIdle(SleepWhenIdle.Enabled(idleTimeout))
                     .build()
 
-            _isInitialized.value = true
+            isInitialized.value = true
         } catch (e: Exception) {
             throw IllegalStateException("Failed to initialize Nostr client: ${e.message}", e)
         }
     }
 
     suspend fun waitUntilInitialized() {
-        _isInitialized.first { it }
+        isInitialized.first { it }
     }
 
     suspend fun connectBootstrapRelays() {
@@ -147,8 +169,6 @@ class Nostr {
     suspend fun setSigner(new: AsyncNostrSigner) {
         try {
             signer.switch(new)
-            // Fetch metadata for current user
-            getUserMetadata()
         } catch (e: Exception) {
             throw IllegalStateException("Failed to set signer: ${e.message}", e)
         }
@@ -209,77 +229,22 @@ class Nostr {
 
             client?.subscribe(
                 target = ReqTarget.manual(target),
-                id = "all-gift-wraps"
+                id = "gift-wraps"
             )
         } catch (e: Exception) {
             throw IllegalStateException("Failed to fetch user messages: ${e.message}", e)
         }
     }
 
-    suspend fun handleLiteNotifications(
-        onNewMessage: (UnsignedEvent) -> Unit,
-    ) {
-        val now = Timestamp.now()
-        val processedEvent = mutableSetOf<EventId>()
-        val notifications = client?.notifications() ?: return
-
-        while (true) {
-            val notification = notifications.next() ?: continue
-
-            when (notification) {
-                is ClientNotification.Message -> {
-                    val relayUrl = notification.relayUrl
-
-                    when (val message = notification.message.asEnum()) {
-                        is RelayMessageEnum.EventMsg -> {
-                            val event = message.event
-                            val subscriptionId = message.subscriptionId
-
-                            // Ignore events not from the newest gift wraps subscription
-                            if (subscriptionId != "newest-gift-wraps") continue
-
-                            // Prevent processing duplicate events
-                            if (processedEvent.contains(event.id())) continue
-                            processedEvent.add(event.id())
-
-                            if (event.kind().asStd()?.equals(KindStandard.GIFT_WRAP) == true) {
-                                try {
-                                    val rumor = extractRumor(event)
-
-                                    // Handle new message
-                                    rumor?.createdAt()?.asSecs()?.let {
-                                        if (it >= now.asSecs()) {
-                                            onNewMessage(rumor)
-                                        }
-                                    }
-                                } catch (e: Exception) {
-                                    println("Failed to extract rumor: $e")
-                                }
-                            }
-                        }
-
-                        else -> {
-                            /* Ignore other event kinds */
-                        }
-                    }
-                }
-
-                else -> {
-                    /* Ignore other message types */
-                }
-            }
-        }
-    }
-
     suspend fun handleNotifications(
         onMetadataUpdate: (PublicKey, Metadata) -> Unit,
         onContactListUpdate: (List<PublicKey>) -> Unit,
         onNewMessage: (UnsignedEvent) -> Unit,
         onSubscriptionClose: () -> Unit,
-    ) = coroutineScope {
+    ) = supervisorScope {
         val now = Timestamp.now()
         val processedEvent = mutableSetOf<EventId>()
-        val notifications = client?.notifications() ?: return@coroutineScope
+        val notifications = client?.notifications() ?: return@supervisorScope
 
         var eoseTrackerJob: Job? = null
 
@@ -293,7 +258,6 @@ class Nostr {
                     when (val message = notification.message.asEnum()) {
                         is RelayMessageEnum.EventMsg -> {
                             val event = message.event
-                            val id = message.subscriptionId
 
                             // Prevent processing duplicate events
                             if (processedEvent.contains(event.id())) continue
@@ -330,7 +294,7 @@ class Nostr {
                                     eoseTrackerJob?.cancel()
                                     // Start a new tracker
                                     eoseTrackerJob = launch {
-                                        delay(10000) // Wait for 10 seconds
+                                        delay(10000.milliseconds) // Wait for 10 seconds
                                         onSubscriptionClose()
                                     }
 
@@ -349,7 +313,7 @@ class Nostr {
                         is RelayMessageEnum.EndOfStoredEvents -> {
                             val subscriptionId = message.subscriptionId
 
-                            if (subscriptionId == "all-gift-wraps" || subscriptionId == "newest-gift-wraps") {
+                            if (subscriptionId == "gift-wraps") {
                                 onSubscriptionClose()
                             }
                         }
@@ -403,7 +367,7 @@ class Nostr {
                 Tag.identifier(giftId.toHex()),
                 Tag.event(rumor.id()!!),
                 Tag.reference(roomId.toString()),
-                Tag.custom(TagKind.Unknown("k"), listOf("dm"))
+                Tag.custom(TagKind.Unknown("k"), listOf("14"))
             )
 
             // Set event kind
@@ -432,7 +396,6 @@ class Nostr {
         // Try to unwrap the gift with each signer
         for (signer in signers) {
             try {
-                // TODO: custom unwrapping logic
                 val gift = UnwrappedGift.fromGiftWrapAsync(signer = signer, giftWrap = event)
                 val rumor = gift.rumor()
                 // Save the rumor to the database
@@ -537,18 +500,23 @@ class Nostr {
 
     suspend fun getAllCacheMetadata(): Map<PublicKey, Metadata> {
         try {
-            val filter = Filter().kind(Kind.fromStd(KindStandard.METADATA)).limit(200u)
+            val filter = Filter().kind(Kind.fromStd(KindStandard.METADATA)).limit(100u)
             val events = client?.database()?.query(filter)
             val results = mutableMapOf<PublicKey, Metadata>()
 
             events?.toVec()?.forEach { event ->
+                try {
                     val metadata = Metadata.fromJson(event.content())
                     results[event.author()] = metadata
+                } catch (e: Exception) {
+                    println("Failed to parse metadata: $e")
+                }
             }
 
             return results
         } catch (e: Exception) {
-            throw IllegalStateException("Failed to get cache metadata: ${e.message}", e)
+            println("Failed to get all cache metadata: ${e.message}")
+            return emptyMap()
         }
     }
 
@@ -631,7 +599,7 @@ class Nostr {
             val kTag = SingleLetterTag.lowercase(Alphabet.K)
 
             // Get all events sent by the user
-            val filter = Filter().kind(kind).author(userPubkey).customTag(kTag, "dm")
+            val filter = Filter().kind(kind).author(userPubkey).customTags(kTag, listOf("14", "dm"))
             val events = client?.database()?.query(filter)
 
             // Collect rooms
@@ -676,6 +644,8 @@ class Nostr {
             return events
                 ?.toVec()
                 ?.map { UnsignedEvent.fromJson(it.content()) }
+                // Filter out events without public keys (receivers)
+                ?.filter { it.tags().publicKeys().isNotEmpty() }
                 ?.sortedByDescending { it.createdAt().asSecs() } ?: emptyList()
         } catch (e: Exception) {
             throw IllegalStateException("Failed to get chat room messages: ${e.message}", e)
@@ -729,7 +699,7 @@ class Nostr {
     }
 
     suspend fun sendMessage(
-        to: List<PublicKey>,
+        to: Set<PublicKey>,
         content: String,
         subject: String? = null,
         replies: List<EventId> = emptyList(),
@@ -755,17 +725,16 @@ class Nostr {
 
             // Add public key tags for each recipient
             to.forEach { pubkey ->
-                if (pubkey != currentUser) {
                 tags.add(Tag.publicKey(pubkey))
             }
-            }
 
-            for (receiver in listOf(currentUser) + to) {
+            for (receiver in setOf(currentUser) + to) {
                 // Construct the rumor event
                 // NEVER SIGN this event with the current user signer
                 val rumor = EventBuilder
                     .privateMsgRumor(receiver = receiver, message = content)
                     .tags(tags)
+                    .allowSelfTagging()
                     .build(currentUser)
                     // Ensure the event ID is set
                     .ensureId()

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

@@ -14,10 +14,12 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeoutOrNull
 import kotlinx.serialization.json.Json
+import rust.nostr.sdk.AsyncNostrSigner
 import rust.nostr.sdk.EventBuilder
 import rust.nostr.sdk.EventId
 import rust.nostr.sdk.Keys
@@ -32,17 +34,21 @@ import rust.nostr.sdk.UnsignedEvent
 import su.reya.coop.blossom.BlossomClient
 import su.reya.coop.storage.SecretStorage
 import kotlin.time.Clock
-import kotlin.time.Duration
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
 
 class NostrViewModel(
     private val nostr: Nostr,
     private val secretStore: SecretStorage
 ) : ViewModel() {
-    private val _emptySecret = MutableStateFlow<Boolean?>(null)
+    private val _isNotificationBannerDismissed = MutableStateFlow(false)
-    val emptySecret = _emptySecret.asStateFlow()
+    val isNotificationBannerDismissed = _isNotificationBannerDismissed.asStateFlow()
 
-    private val _isCreating = MutableStateFlow(false)
+    private val _signerRequired = MutableStateFlow<Boolean?>(null)
-    val isCreating = _isCreating.asStateFlow()
+    val signerRequired = _signerRequired.asStateFlow()
+
+    private val _isLoggedIn = MutableStateFlow(false)
+    val isLoggedIn = _isLoggedIn.asStateFlow()
 
     private val _chatRooms = MutableStateFlow<Set<Room>>(emptySet())
     val chatRooms = _chatRooms.asStateFlow()
@@ -59,7 +65,7 @@ class NostrViewModel(
     private val _newEvents = MutableSharedFlow<UnsignedEvent>(extraBufferCapacity = 100)
     val newEvents = _newEvents.asSharedFlow()
 
-    private val _sentReports = MutableStateFlow<Map<EventId, List<RelayUrl>>>(emptyMap())
+    private val _sentReports = MutableSharedFlow<Map<EventId, List<RelayUrl>>>()
     val sentReport = _sentReports.asSharedFlow()
 
     private val _errorEvents = Channel<String>(Channel.BUFFERED)
@@ -70,11 +76,23 @@ class NostrViewModel(
     private val seenPublicKeys = mutableSetOf<PublicKey>()
 
     init {
-        startNotificationHandler()
+        // Check if the notification banner has been dismissed
-        startMetadataBatchHandler()
+        checkNotificationBannerDismissedStatus()
-        getCacheMetadata()
+
+        // Check local stored secret (secret key or bunker)
         login()
+
+        // Observe the signer state and verify the relay list
         observeSignerAndCheckRelays()
+
+        // Get all local stored metadata
+        getCacheMetadata()
+
+        // Observe new events from the Nostr client
+        runObserver()
+
+        // Wait and merge metadata requests into a single batch
+        runMetadataBatching()
     }
 
     override fun onCleared() {
@@ -90,39 +108,63 @@ class NostrViewModel(
     private fun showError(message: String) {
         viewModelScope.launch {
             _errorEvents.send(message)
-            if (isCreating.value) _isCreating.value = false
         }
     }
 
-    private fun startNotificationHandler() {
+    private fun checkNotificationBannerDismissedStatus() {
         viewModelScope.launch {
-            // Wait until the client is ready
+            _isNotificationBannerDismissed.value =
-            nostr.waitUntilInitialized()
+                secretStore.get("notification_banner_dismissed") == "true"
-
-            nostr.handleNotifications(
-                onMetadataUpdate = { pubkey, metadata ->
-                    updateMetadata(pubkey, metadata)
-                },
-                onContactListUpdate = { contactList ->
-                    _contactList.value = contactList.toSet()
-                },
-                onSubscriptionClose = {
-                    getChatRooms()
-
-                    if (!_isPartialProcessedGiftWrap.value) {
-                        _isPartialProcessedGiftWrap.value = true
         }
-                },
+    }
-                onNewMessage = { event ->
+
+    private fun runObserver() {
         viewModelScope.launch {
+            // Observe new messages
+            launch {
+                nostr.newEvents.collect { event ->
+                    val roomId = event.roomId()
+                    val existingRoom = _chatRooms.value.firstOrNull { it.id == roomId }
+
+                    if (existingRoom == null) {
+                        val currentUser = nostr.signer.currentUser
+                        if (currentUser != null) {
+                            val newRoom = Room.new(event, currentUser)
+                            _chatRooms.update { (it + newRoom).sortedDescending().toSet() }
+                        }
+                    } else {
+                        updateRoomList(roomId, event)
+                    }
+
                     _newEvents.emit(event)
                 }
-                },
+            }
-            )
+
+            // Observe metadata updates
+            launch {
+                nostr.metadataUpdates.collect { (pubkey, metadata) ->
+                    updateMetadata(pubkey, metadata)
                 }
             }
 
-    private fun startMetadataBatchHandler() {
+            // Observe contact list updates
+            launch {
+                nostr.contactListUpdates.collect { contacts ->
+                    _contactList.value = contacts.toSet()
+                }
+            }
+
+            // Observes subscription close
+            launch {
+                nostr.subscriptionClosed.collect {
+                    getChatRooms()
+                    _isPartialProcessedGiftWrap.value = true
+                }
+            }
+        }
+    }
+
+    private fun runMetadataBatching() {
         viewModelScope.launch {
             // Wait until the client is ready
             nostr.waitUntilInitialized()
@@ -136,7 +178,7 @@ class NostrViewModel(
                 val lastFlushTime = Clock.System.now().toEpochMilliseconds()
 
                 while (batch.isNotEmpty()) {
-                    val nextKey = withTimeoutOrNull(timeout) {
+                    val nextKey = withTimeoutOrNull(timeout.milliseconds) {
                         metadataRequestChannel.receive()
                     }
 
@@ -163,7 +205,9 @@ class NostrViewModel(
 
             val results = nostr.getAllCacheMetadata()
             results.forEach { (pubkey, metadata) ->
+                // Update the metadata state
                 updateMetadata(pubkey, metadata)
+                // Update seenPublicKeys to avoid duplicate requests
                 seenPublicKeys.add(pubkey)
             }
         }
@@ -171,39 +215,26 @@ class NostrViewModel(
 
     private fun login() {
         viewModelScope.launch {
-            // Wait until the client is ready
+            try {
-            nostr.waitUntilInitialized()
-
-            // Get user's signer secret
                 val secret = secretStore.get("user_signer")
 
-            // If no secret is found, show onboarding screen
+                if (secret == null) {
-            when (secret) {
+                    _signerRequired.value = true
-                null -> {
-                    _emptySecret.value = true
                     return@launch
                 }
 
-                else -> _emptySecret.value = false
+                runCatching {
+                    val signer = createSigner(secret)
+                    nostr.setSigner(signer)
+                }.onSuccess {
+                    _signerRequired.value = false
+                }.onFailure { e ->
+                    showError("Login failed: ${e.message}")
+                    _signerRequired.value = true
                 }
-
-            // Handle different signer types
-            if (secret.startsWith("nsec1")) {
-                val keys = Keys.parse(secret)
-                nostr.setSigner(keys)
-            } else if (secret.startsWith("bunker://")) {
-                try {
-                    val appKeys = getOrInitAppKeys()
-                    val bunker = NostrConnectUri.parse(secret)
-                    val timeout = Duration.parse("50s") // 50 seconds timeout
-                    val remote =
-                        NostrConnect(uri = bunker, appKeys = appKeys, timeout = timeout, null)
-                    nostr.setSigner(remote)
             } catch (e: Exception) {
-                    showError("Error: ${e.message}")
+                showError("Login failed: ${e.message}")
-                }
+                _signerRequired.value = true
-            } else {
-                throw IllegalArgumentException("Invalid secret format: $secret")
             }
         }
     }
@@ -214,15 +245,29 @@ class NostrViewModel(
                 val pubkey = nostr.signer.currentUser
 
                 if (pubkey != null) {
-                    delay(3000)
+                    // Get chat rooms
+                    val rooms = nostr.getChatRooms() ?: emptySet()
+                    if (rooms.isNotEmpty()) {
+                        mergeChatRooms(rooms)
+                        _isPartialProcessedGiftWrap.value = true
+                    }
+
+                    // Get all metadata for the current user
+                    nostr.getUserMetadata()
+
+                    // Small delay to ensure all relays are connected
+                    delay(3000.milliseconds)
+
+                    // Check if the relay list is empty
                     val relays = nostr.getMsgRelays(pubkey)
                     if (relays.isEmpty()) {
                         _isRelayListEmpty.value = true
                     }
+
                     break
                 }
 
-                delay(1000)
+                delay(500.milliseconds)
             }
         }
     }
@@ -255,7 +300,14 @@ class NostrViewModel(
         viewModelScope.launch {
             secretStore.clear("user_signer")
             nostr.signer.switch(Keys.generate())
-            _emptySecret.value = true
+            _signerRequired.value = true
+        }
+    }
+
+    fun dismissNotificationBanner() {
+        viewModelScope.launch {
+            secretStore.set("notification_banner_dismissed", "true")
+            _isNotificationBannerDismissed.value = true
         }
     }
 
@@ -278,21 +330,32 @@ class NostrViewModel(
         return keys
     }
 
-    fun createIdentity(
+    private suspend fun createSigner(secret: String): AsyncNostrSigner {
+        return when {
+            secret.startsWith("nsec1") -> Keys.parse(secret)
+            secret.startsWith("bunker://") -> {
+                val appKeys = getOrInitAppKeys()
+                val bunker = NostrConnectUri.parse(secret)
+                val timeout = 50.seconds // or Duration.parse("50s")
+                NostrConnect(uri = bunker, appKeys, timeout, null)
+            }
+
+            else -> throw IllegalArgumentException("Invalid secret format")
+        }
+    }
+
+    suspend fun createIdentity(
         name: String,
         bio: String?,
         picture: ByteArray?,
         contentType: String? = null
     ) {
-        viewModelScope.launch {
+        _isLoggedIn.value = true
         try {
             val keys = Keys.generate()
             val secret = keys.secretKey().toBech32()
             var avatarUrl = ""
 
-                // Set loading state
-                _isCreating.value = true
-
             // Upload picture to Blossom
             if (picture != null) {
                 val blossom = BlossomClient(
@@ -324,57 +387,38 @@ class NostrViewModel(
             secretStore.set("user_signer", secret)
 
             // Set an empty secret state
-                _emptySecret.value = false
+            _signerRequired.value = false
         } catch (e: Exception) {
             showError("Error: ${e.message}")
-            }
+        } finally {
+            _isLoggedIn.value = true
         }
     }
 
     suspend fun verifyIdentity(secret: String): PublicKey? {
-        if (secret.startsWith("nsec1")) {
-            val keys = Keys.parse(secret)
-            return keys.publicKey()
-        } else if (secret.startsWith("bunker://")) {
-            val appKeys = getOrInitAppKeys()
-            val bunker = NostrConnectUri.parse(secret)
-            val timeout = Duration.parse("50s") // 50 seconds timeout
-            val remote = NostrConnect(uri = bunker, appKeys, timeout, null)
-
-            // Show toast to ask user to approve the connection
-            showError("Please approve the connection.")
-
-            return remote.getPublicKeyAsync()
-        } else {
-            throw IllegalArgumentException("Invalid secret: $secret")
-        }
-    }
-
-    fun importIdentity(secret: String) {
-        viewModelScope.launch {
-            if (secret.startsWith("nsec1")) {
-                val keys = Keys.parse(secret)
-                nostr.setSigner(keys)
-                secretStore.set("user_signer", secret)
-                // Set an empty secret state
-                _emptySecret.value = false
-            } else if (secret.startsWith("bunker://")) {
         try {
-                    val appKeys = getOrInitAppKeys()
+            val signer = createSigner(secret)
-                    val bunker = NostrConnectUri.parse(secret)
+            if (secret.startsWith("bunker://")) {
-                    val timeout = Duration.parse("50s") // 50 seconds timeout
+                showError("Please approve the connection.")
-                    val remote =
+            }
-                        NostrConnect(uri = bunker, appKeys = appKeys, timeout = timeout, null)
+            return signer.getPublicKeyAsync()
-                    nostr.setSigner(remote)
-                    secretStore.set("user_signer", secret)
-                    // Set an empty secret state
-                    _emptySecret.value = false
         } catch (e: Exception) {
             showError("Error: ${e.message}")
+            return null
         }
-            } else {
-                showError("Please enter a valid Secret or Bunker URI.")
     }
+
+    suspend fun importIdentity(secret: String) {
+        _isLoggedIn.value = true
+        try {
+            val signer = createSigner(secret)
+            nostr.setSigner(signer)
+            secretStore.set("user_signer", secret)
+        } catch (e: Exception) {
+            showError("Error: ${e.message}")
+        } finally {
+            _signerRequired.value = false
+            _isLoggedIn.value = false
         }
     }
 
@@ -406,20 +450,39 @@ class NostrViewModel(
     }
 
     fun createChatRoom(to: List<PublicKey>): Long {
+        try {
             if (nostr.signer.currentUser == null) throw IllegalStateException("User not signed in")
             if (to.isEmpty()) throw IllegalArgumentException("At least one recipient is required")
 
+            val currentUser = nostr.signer.currentUser!!
+
             // Construct the rumor event
             val rumor = EventBuilder
                 .privateMsgRumor(to.first(), "")
                 .tags(to.map { Tag.publicKey(it) })
-            .build(nostr.signer.currentUser!!)
+                .build(currentUser)
+
+            // Check if the room already exists
+            val id = rumor.roomId()
+            val existingRoom = _chatRooms.value.firstOrNull { it.id == id }
+
+            // If the room already exists, return its ID
+            if (existingRoom != null) {
+                return existingRoom.id
+            }
 
             // Create a room from the rumor event
-        val room = Room.new(rumor, nostr.signer.currentUser!!)
+            val room = Room.new(rumor, currentUser)
-        _chatRooms.value += room
+
+            // Update the chat rooms state
+            _chatRooms.update { currentRooms ->
+                (currentRooms + room).sortedDescending().toSet()
+            }
 
             return room.id
+        } catch (e: Exception) {
+            throw IllegalArgumentException("Failed to create room: ${e.message}")
+        }
     }
 
     fun getChatRoom(id: Long): Room {
@@ -427,19 +490,29 @@ class NostrViewModel(
             ?: throw IllegalArgumentException("Room not found")
     }
 
+    private fun mergeChatRooms(rooms: Set<Room>) {
+        _chatRooms.update { currentRooms ->
+            val merged = currentRooms.associateBy { it.id }.toMutableMap()
+            // Add or update rooms from the database
+            rooms.forEach { room ->
+                merged[room.id] = room
+            }
+            // Return as a sorted set to maintain UI consistency
+            merged.values.sortedDescending().toSet()
+        }
+    }
+
     fun getChatRooms() {
         viewModelScope.launch {
-            try {
+            val rooms = nostr.getChatRooms() ?: emptySet()
-                _chatRooms.value = nostr.getChatRooms() ?: emptySet()
+            mergeChatRooms(rooms)
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
         }
     }
 
     suspend fun refreshChatRooms() {
         try {
-            _chatRooms.value = nostr.getChatRooms() ?: emptySet()
+            val rooms = nostr.getChatRooms() ?: emptySet()
+            mergeChatRooms(rooms)
         } catch (e: Exception) {
             showError("Error: ${e.message}")
         }
@@ -468,11 +541,14 @@ class NostrViewModel(
     }
 
     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)
                 nostr.sendMessage(
-                    to = room.members.toList(),
+                    to = room.members,
                     content = message,
                     subject = room.subject,
                     replies = replies,
@@ -499,13 +575,18 @@ class NostrViewModel(
     }
 
     private fun updateRoomList(roomId: Long, newMessage: UnsignedEvent) {
-        _chatRooms.value = _chatRooms.value.map { room ->
+        _chatRooms.update { currentRooms ->
+            currentRooms.map { room ->
                 if (room.id == roomId) {
-                room.copy(lastMessage = newMessage.content(), createdAt = newMessage.createdAt())
+                    room.copy(
+                        lastMessage = newMessage.content(),
+                        createdAt = newMessage.createdAt()
+                    )
                 } else {
                     room
                 }
-        }.toSet()
+            }.sortedDescending().toSet()
+        }
     }
 
     suspend fun searchByAddress(query: String): PublicKey? {

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

@@ -40,11 +40,14 @@ data class Room(
             val subject = rumor.tags().find(TagKind.Subject)?.content()
 
             // Collect the author's public key and all public keys from tags
-            // Also remove the user's public key from the list, current user is always a member
             val pubkeys: MutableSet<PublicKey> = mutableSetOf()
             pubkeys.add(rumor.author())
             pubkeys.addAll(rumor.tags().publicKeys())
+
+            // Also remove the user's public key from the list, current user is always a member
+            if (pubkeys.size > 1 && pubkeys.contains(userPubkey)) {
                 pubkeys.remove(userPubkey)
+            }
 
             // Create a new Room instance
             return Room(