refactor

2026-07-11 16:41:39 +07:00
parent c5b76e9b2f
commit f2c1587efa
19 changed files with 528 additions and 381 deletions
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/NostrViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/NostrViewModel.kt
@@ -1,57 +1,27 @@
 package su.reya.coop.viewmodel

 import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOf
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withTimeoutOrNull
 import rust.nostr.sdk.PublicKey
-import rust.nostr.sdk.Timestamp
 import su.reya.coop.Profile
 import su.reya.coop.nostr.Nostr
-import su.reya.coop.repository.MediaRepository
 import kotlin.time.Clock
 import kotlin.time.Duration.Companion.milliseconds

-data class NostrAppState(
-    val isBusy: Boolean = false,
-)
-
-class NostrViewModel(
-    private val nostr: Nostr,
-    private val mediaRepository: MediaRepository,
-) : BaseViewModel() {
-    private val _appState = MutableStateFlow(NostrAppState())
-    val appState: StateFlow<NostrAppState> = _appState.asStateFlow()
-
-    private val _contactList = MutableStateFlow<Set<PublicKey>>(emptySet())
-    val contactList = _contactList.asStateFlow()
-
+class NostrViewModel(private val nostr: Nostr) : BaseViewModel() {
    private val profilesMutex = Mutex()
    private val profiles = mutableMapOf<PublicKey, MutableStateFlow<Profile?>>()
    private val metadataRequestChannel = Channel<PublicKey>(Channel.UNLIMITED)
    private val seenPublicKeys = mutableSetOf<PublicKey>()

-    @OptIn(ExperimentalCoroutinesApi::class)
-    val currentUserProfile = nostr.signer.publicKeyFlow
-        .flatMapLatest { pubkey ->
-            if (pubkey != null) getMetadata(pubkey) else flowOf(null)
-        }
-        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
-
    init {
        // Launch continuous background observers
        viewModelScope.launch { runObserver() }
@@ -60,9 +30,6 @@ class NostrViewModel(
        // Automatically reconnect bootstrap relays
        reconnect()

-        // Fetch metadata for the current user
-        fetchUserMetadata()
-
        // Get all local stored metadata
        getCacheMetadata()
    }
@@ -75,13 +42,6 @@ class NostrViewModel(
    }

    private suspend fun runObserver() = coroutineScope {
-        // Observe contact list updates
-        launch {
-            nostr.profiles.contactListUpdates.collect { contacts ->
-                _contactList.value = contacts.toSet()
-            }
-        }
-
        // Observe metadata updates
        launch {
            nostr.profiles.metadataUpdates.collect { (pubkey, metadata) ->
@@ -143,20 +103,7 @@ class NostrViewModel(
            }
        }
    }
-
-    private fun fetchUserMetadata() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            // Wait until a signer is explicitly set (which updates publicKeyFlow)
-            val currentUser = nostr.signer.publicKeyFlow.filterNotNull().first()
-
-            // Get all metadata for the current user
-            nostr.profiles.getUserMetadata()
-        }
-    }
-
+    
    private fun requestMetadata(pubkey: PublicKey) {
        if (seenPublicKeys.add(pubkey)) {
            metadataRequestChannel.trySend(pubkey)
@@ -176,144 +123,4 @@ class NostrViewModel(
        return flow.asStateFlow()
    }

-    fun resetInternalState() {
-        _contactList.value = emptySet()
-    }
-
-    fun updateProfile(
-        name: String? = null,
-        bio: String? = null,
-        picture: ByteArray? = null,
-        contentType: String? = null
-    ) {
-        viewModelScope.launch {
-            _appState.update { it.copy(isBusy = true) }
-            try {
-                val avatarUrl =
-                    picture?.let {
-                        mediaRepository.blossomUpload(
-                            nostr.signer.get(),
-                            it,
-                            contentType ?: "image/jpeg"
-                        )
-                    }
-                val newMetadata = nostr.profiles.updateProfile(name, bio, avatarUrl)
-                val currentUser =
-                    nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
-
-                // Update the metadata state after successfully published
-                updateMetadata(currentUser, Profile(currentUser, newMetadata))
-
-                // Update local state
-                _appState.update { it.copy(isBusy = false) }
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-                _appState.update { it.copy(isBusy = false) }
-            }
-        }
-    }
-
-    private fun newContact(publicKey: PublicKey) {
-        if (publicKey in contactList.value) return
-
-        viewModelScope.launch {
-            try {
-                val updated = contactList.value + publicKey
-                // Publish new event
-                nostr.profiles.setContactList(updated.toList())
-                // Optimistic local update
-                _contactList.update { it + publicKey }
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    fun addContact(address: String) {
-        viewModelScope.launch {
-            val pubkey = try {
-                if (address.contains("@")) {
-                    nostr.profiles.searchByAddress(address)
-                } else {
-                    PublicKey.parse(address)
-                }
-            } catch (e: Exception) {
-                showError("Invalid contact address: ${e.message}")
-                return@launch
-            }
-
-            newContact(pubkey)
-        }
-    }
-
-    fun removeContact(publicKey: PublicKey) {
-        viewModelScope.launch {
-            if (publicKey !in contactList.value) return@launch
-
-            try {
-                val updated = contactList.value - publicKey
-                // Publish new event
-                nostr.profiles.setContactList(updated.toList())
-                // Optimistic local update
-                _contactList.update { it - publicKey }
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-            }
-        }
-    }
-
-    fun searchByAddress(query: String, onResult: (PublicKey?) -> Unit) {
-        viewModelScope.launch {
-            try {
-                onResult(nostr.profiles.searchByAddress(query))
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-                onResult(null)
-            }
-        }
-    }
-
-    fun searchByNostr(query: String, onResult: (List<PublicKey>) -> Unit) {
-        viewModelScope.launch {
-            try {
-                onResult(nostr.profiles.searchByNostr(query))
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-                onResult(emptyList())
-            }
-        }
-    }
-
-    fun verifyActivity(pubkey: PublicKey, onResult: (Timestamp?) -> Unit) {
-        viewModelScope.launch {
-            try {
-                onResult(nostr.profiles.verifyActivity(pubkey))
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-                onResult(null)
-            }
-        }
-    }
-
-    fun verifyContact(pubkey: PublicKey, onResult: (Boolean) -> Unit) {
-        viewModelScope.launch {
-            try {
-                onResult(nostr.profiles.verifyContact(pubkey))
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-                onResult(false)
-            }
-        }
-    }
-
-    fun mutualContacts(pubkey: PublicKey, onResult: (Set<PublicKey>) -> Unit) {
-        viewModelScope.launch {
-            try {
-                onResult(nostr.profiles.mutualContacts(pubkey))
-            } catch (e: Exception) {
-                showError("Error: ${e.message}")
-                onResult(emptySet())
-            }
-        }
-    }
 }
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountAuthDelegate.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountAuthDelegate.kt
@@ -1,9 +1,10 @@
-package su.reya.coop.viewmodel
+package su.reya.coop.viewmodel.account

-import androidx.lifecycle.viewModelScope
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
@@ -23,46 +24,46 @@ import su.reya.coop.nostr.SignerPermissions
 import su.reya.coop.repository.MediaRepository
 import kotlin.time.Duration.Companion.seconds

-data class AuthState(
+data class AccountState(
    val signerRequired: Boolean? = null,
    val isNotificationBannerDismissed: Boolean = false,
    val isImporting: Boolean = false,
    val importError: String? = null,
 )

-class AuthViewModel(
+class AccountAuthDelegate(
    private val nostr: Nostr,
    private val storage: AppStorage,
    private val mediaRepository: MediaRepository,
    private val externalSignerHandler: ExternalSignerHandler? = null,
    private val defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
-) : BaseViewModel() {
+    private val onError: (String) -> Unit,
+    private val onSignerReady: () -> Unit,
+    private val scope: CoroutineScope,
+) {
    companion object {
        private const val KEY_USER_SIGNER = "user_signer"
        private const val KEY_APP_KEYS = "app_keys"
        private const val KEY_BANNER_DISMISSED = "notification_banner_dismissed"
    }

-    private val _state = MutableStateFlow(AuthState())
-    val state = _state.asStateFlow()
+    private val _state = MutableStateFlow(AccountState())
+    val state: StateFlow<AccountState> = _state.asStateFlow()

-    init {
-        // Check if the notification banner has been dismissed
+    fun init() {
        checkNotificationBannerDismissedStatus()
-
-        // Check local stored secret (secret key or bunker)
        login()
    }

    private fun checkNotificationBannerDismissedStatus() {
-        viewModelScope.launch {
+        scope.launch {
            val dismissed = storage.get(KEY_BANNER_DISMISSED) == "true"
            _state.update { it.copy(isNotificationBannerDismissed = dismissed) }
        }
    }

    private fun login() {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val secret = withTimeoutOrNull(5.seconds) {
                    storage.getSecret(KEY_USER_SIGNER)
@@ -78,39 +79,36 @@ class AuthViewModel(
                    nostr.setSigner(signer)
                }.onSuccess {
                    _state.update { it.copy(signerRequired = false) }
+                    onSignerReady()
                }.onFailure { e ->
-                    showError("Login failed: ${e.message}")
+                    onError("Login failed: ${e.message}")
                    _state.update { it.copy(signerRequired = true) }
                }
            } catch (e: Exception) {
-                showError("Login failed: ${e.message}")
+                onError("Login failed: ${e.message}")
                _state.update { it.copy(signerRequired = true) }
            }
        }
    }

    fun logout(onLogout: () -> Unit = {}) {
-        viewModelScope.launch {
+        scope.launch {
            try {
-                // Reset the nostr signer and prune the database
                nostr.signer.switch(Keys.generate())
                nostr.prune()
            } catch (e: Exception) {
-                showError("Logout encountered an error: ${e.message}")
+                onError("Logout encountered an error: ${e.message}")
            } finally {
-                // Clear credentials from persistent storage
                storage.clear(KEY_USER_SIGNER)
                storage.clear(KEY_BANNER_DISMISSED)
-                // Call cleanup callback (e.g. to reset other ViewModels)
                onLogout()
-                // Reset local states
                _state.update { it.copy(signerRequired = true) }
            }
        }
    }

    fun dismissNotificationBanner() {
-        viewModelScope.launch {
+        scope.launch {
            storage.set(KEY_BANNER_DISMISSED, "true")
            _state.update { it.copy(isNotificationBannerDismissed = true) }
        }
@@ -118,9 +116,7 @@ class AuthViewModel(

    private suspend fun getOrInitAppKeys(): Keys = withContext(defaultDispatcher) {
        val secret = storage.getSecret(KEY_APP_KEYS)
-        // If app keys are already stored, use them
        if (secret != null) return@withContext Keys.parse(secret)
-        // Generate new app keys and save to the secret storage
        val keys = Keys.generate()
        storage.setSecret(KEY_APP_KEYS, keys.secretKey().toBech32())
        keys
@@ -136,9 +132,8 @@ class AuthViewModel(
            secret.startsWith("ncryptsec1") -> {
                if (password == null) throw IllegalArgumentException("Password is required")
                val enc = EncryptedSecretKey.fromBech32(secret)
-                val secret = enc.decrypt(password)
-                val keys = Keys(secret)
-
+                val decrypted = enc.decrypt(password)
+                val keys = Keys(decrypted)
                keys to keys.secretKey().toBech32()
            }

@@ -153,7 +148,6 @@ class AuthViewModel(
                val handler = externalSignerHandler
                    ?: throw IllegalStateException("External signer not available on this platform")

-                // Format: nip55://packageName/hexPubkey
                val parts = secret.removePrefix("nip55://").split("/", limit = 2)
                val packageName = parts[0]
                val pubkey = PublicKey.parse(parts[1])
@@ -167,25 +161,23 @@ class AuthViewModel(
    }

    fun importIdentity(secret: String, password: String? = null) {
-        viewModelScope.launch {
+        scope.launch {
            _state.update { it.copy(isImporting = true, importError = null) }
            try {
                val (signer, decryptedSecret) = createSigner(secret, password)
-                // Update signer
                nostr.setSigner(signer)
-                // Persist the secret in the secret storage
                storage.setSecret(KEY_USER_SIGNER, decryptedSecret ?: secret)
-                // Update local states
                _state.update { it.copy(signerRequired = false, isImporting = false) }
+                onSignerReady()
            } catch (e: Exception) {
-                showError("Import failed: ${e.message}")
+                onError("Import failed: ${e.message}")
                _state.update { it.copy(isImporting = false, importError = e.message) }
            }
        }
    }

    fun connectExternalSigner() {
-        viewModelScope.launch {
+        scope.launch {
            _state.update { it.copy(isImporting = true, importError = null) }
            try {
                val handler = externalSignerHandler
@@ -209,17 +201,15 @@ class AuthViewModel(
                val result = handler.getPublicKey(permissions) ?: throw Exception("Rejected")
                val signer = ExternalSignerProxy(handler, result.pubkey)

-                // Update signer
                nostr.setSigner(signer)
-                // Store the signer in the secret storage
                storage.setSecret(
                    KEY_USER_SIGNER,
                    "nip55://${result.packageName}/${result.pubkey.toHex()}"
                )
-                // Update local states
                _state.update { it.copy(signerRequired = false, isImporting = false) }
+                onSignerReady()
            } catch (e: Exception) {
-                showError("External signer connection failed: ${e.message}")
+                onError("External signer connection failed: ${e.message}")
                _state.update { it.copy(isImporting = false, importError = e.message) }
            }
        }
@@ -235,7 +225,7 @@ class AuthViewModel(
        picture: ByteArray?,
        contentType: String? = null
    ) {
-        viewModelScope.launch {
+        scope.launch {
            _state.update { it.copy(isImporting = true, importError = null) }
            try {
                val keys = Keys.generate()
@@ -243,19 +233,17 @@ class AuthViewModel(
                val avatarUrl = picture?.let {
                    mediaRepository.blossomUpload(keys, it, contentType ?: "image/jpeg")
                }
-                // Create identity
                nostr.profiles.createIdentity(
                    keys = keys,
                    name = name,
                    bio = bio,
                    picture = avatarUrl
                )
-                // Persist the secret in the secret storage
                storage.setSecret(KEY_USER_SIGNER, secret)
-                // Update local states
                _state.update { it.copy(signerRequired = false, isImporting = false) }
+                onSignerReady()
            } catch (e: Exception) {
-                showError("Identity creation failed: ${e.message}")
+                onError("Identity creation failed: ${e.message}")
                _state.update { it.copy(isImporting = false, importError = e.message) }
            }
        }
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountContactDelegate.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountContactDelegate.kt
@@ -0,0 +1,137 @@
+package su.reya.coop.viewmodel.account
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.Timestamp
+import su.reya.coop.nostr.Nostr
+
+class AccountContactDelegate(
+    private val nostr: Nostr,
+    private val scope: CoroutineScope,
+    private val onError: (String) -> Unit,
+) {
+    private val _contactList = MutableStateFlow<Set<PublicKey>>(emptySet())
+    val contactList: StateFlow<Set<PublicKey>> = _contactList.asStateFlow()
+
+    fun init() {
+        observeContactList()
+    }
+
+    fun reset() {
+        _contactList.value = emptySet()
+    }
+
+    private fun observeContactList() {
+        scope.launch {
+            nostr.waitUntilInitialized()
+            nostr.profiles.contactListUpdates.collect { contacts ->
+                _contactList.value = contacts.toSet()
+            }
+        }
+    }
+
+    private fun newContact(publicKey: PublicKey) {
+        if (publicKey in contactList.value) return
+
+        scope.launch {
+            try {
+                val updated = contactList.value + publicKey
+                nostr.profiles.setContactList(updated.toList())
+                _contactList.update { it + publicKey }
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun addContact(address: String) {
+        scope.launch {
+            val pubkey = try {
+                if (address.contains("@")) {
+                    nostr.profiles.searchByAddress(address)
+                } else {
+                    PublicKey.parse(address)
+                }
+            } catch (e: Exception) {
+                onError("Invalid contact address: ${e.message}")
+                return@launch
+            }
+
+            newContact(pubkey)
+        }
+    }
+
+    fun removeContact(publicKey: PublicKey) {
+        scope.launch {
+            if (publicKey !in contactList.value) return@launch
+
+            try {
+                val updated = contactList.value - publicKey
+                nostr.profiles.setContactList(updated.toList())
+                _contactList.update { it - publicKey }
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+            }
+        }
+    }
+
+    fun searchByAddress(query: String, onResult: (PublicKey?) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.searchByAddress(query))
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+                onResult(null)
+            }
+        }
+    }
+
+    fun searchByNostr(query: String, onResult: (List<PublicKey>) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.searchByNostr(query))
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+                onResult(emptyList())
+            }
+        }
+    }
+
+    fun verifyActivity(pubkey: PublicKey, onResult: (Timestamp?) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.verifyActivity(pubkey))
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+                onResult(null)
+            }
+        }
+    }
+
+    fun verifyContact(pubkey: PublicKey, onResult: (Boolean) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.verifyContact(pubkey))
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+                onResult(false)
+            }
+        }
+    }
+
+    fun mutualContacts(pubkey: PublicKey, onResult: (Set<PublicKey>) -> Unit) {
+        scope.launch {
+            try {
+                onResult(nostr.profiles.mutualContacts(pubkey))
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+                onResult(emptySet())
+            }
+        }
+    }
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountProfileDelegate.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountProfileDelegate.kt
@@ -0,0 +1,81 @@
+package su.reya.coop.viewmodel.account
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import rust.nostr.sdk.PublicKey
+import su.reya.coop.Profile
+import su.reya.coop.nostr.Nostr
+import su.reya.coop.repository.MediaRepository
+
+class AccountProfileDelegate(
+    private val nostr: Nostr,
+    private val mediaRepository: MediaRepository,
+    private val onError: (String) -> Unit,
+    private val scope: CoroutineScope,
+) {
+    private val _isUpdatingProfile = MutableStateFlow(false)
+    val isUpdatingProfile: StateFlow<Boolean> = _isUpdatingProfile.asStateFlow()
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val currentUserProfile: StateFlow<Profile?> = nostr.signer.publicKeyFlow
+        .flatMapLatest { pubkey ->
+            if (pubkey != null) currentUserProfileFlow(pubkey) else flowOf(null)
+        }
+        .stateIn(scope, SharingStarted.WhileSubscribed(5000), null)
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private fun currentUserProfileFlow(pubkey: PublicKey) = merge(
+        flow {
+            nostr.waitUntilInitialized()
+            val cached = nostr.profiles.getAllCacheMetadata()[pubkey]
+            if (cached != null) emit(Profile(pubkey, cached))
+            nostr.profiles.fetchMetadataBatch(listOf(pubkey))
+        },
+        nostr.profiles.metadataUpdates
+            .filter { (p, _) -> p == pubkey }
+            .map { (p, m) -> Profile(p, m) }
+    )
+
+    fun getUserMetadata() {
+        scope.launch {
+            nostr.profiles.getUserMetadata()
+        }
+    }
+
+    fun updateProfile(
+        name: String? = null,
+        bio: String? = null,
+        picture: ByteArray? = null,
+        contentType: String? = null
+    ) {
+        scope.launch {
+            _isUpdatingProfile.value = true
+            try {
+                val avatarUrl = picture?.let {
+                    mediaRepository.blossomUpload(
+                        nostr.signer.get(),
+                        it,
+                        contentType ?: "image/jpeg"
+                    )
+                }
+                nostr.profiles.updateProfile(name, bio, avatarUrl)
+                _isUpdatingProfile.value = false
+            } catch (e: Exception) {
+                onError("Error: ${e.message}")
+                _isUpdatingProfile.value = false
+            }
+        }
+    }
+}
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountRelayDelegate.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountRelayDelegate.kt
@@ -1,9 +1,9 @@
-package su.reya.coop.viewmodel
+package su.reya.coop.viewmodel.account

-import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
@@ -13,11 +13,13 @@ import rust.nostr.sdk.RelayUrl
 import su.reya.coop.nostr.Nostr
 import kotlin.time.Duration.Companion.seconds

-class RelayViewModel(
+class AccountRelayDelegate(
    private val nostr: Nostr,
-) : BaseViewModel() {
+    private val onError: (String) -> Unit,
+    private val scope: CoroutineScope,
+) {
    private val _isRelayListEmpty = MutableStateFlow(false)
-    val isRelayListEmpty: StateFlow<Boolean> = _isRelayListEmpty.asStateFlow()
+    val isRelayListEmpty = _isRelayListEmpty.asStateFlow()

    private val _currentUserRelayList = MutableStateFlow<Map<RelayUrl, RelayMetadata?>>(emptyMap())
    val currentUserRelayList = _currentUserRelayList.asStateFlow()
@@ -25,22 +27,19 @@ class RelayViewModel(
    private val _currentUserMsgRelayList = MutableStateFlow<List<RelayUrl>>(emptyList())
    val currentUserMsgRelayList = _currentUserMsgRelayList.asStateFlow()

-    init {
-        checkRelayList()
+    fun reset() {
+        _isRelayListEmpty.value = false
    }

-    private fun checkRelayList() {
-        viewModelScope.launch {
-            // Wait until the client is ready
-            nostr.waitUntilInitialized()
-
-            // Wait until a signer is explicitly set (which updates publicKeyFlow)
+    @OptIn(ExperimentalCoroutinesApi::class)
+    fun checkRelayList() {
+        scope.launch {
            val currentUser = nostr.signer.publicKeyFlow.filterNotNull().first()
+            println("user: ${currentUser.toBech32()}")

-            // Small delay to ensure all relays are connected
-            delay(2.seconds)
+            // Small delay to ensure subscription is ready
+            delay(6.seconds)

-            // Check if the relay list is empty
            val relays = nostr.relays.getMsgRelays(currentUser)
            if (relays.isEmpty()) _isRelayListEmpty.value = true
        }
@@ -50,12 +49,8 @@ class RelayViewModel(
        _isRelayListEmpty.value = false
    }

-    fun resetInternalState() {
-        _isRelayListEmpty.value = false
-    }
-
    fun refetchMsgRelays() {
-        viewModelScope.launch {
+        scope.launch {
            val currentUser = nostr.signer.getPublicKeyAsync() ?: return@launch
            val relays = nostr.relays.fetchMsgRelays(currentUser)

@@ -64,23 +59,24 @@ class RelayViewModel(
    }

    fun useDefaultMsgRelayList() {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val defaultRelays = nostr.relays.getDefaultMsgRelayList()
                nostr.relays.setMsgRelays(defaultRelays)
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }

    fun loadCurrentUserRelayList() {
-        viewModelScope.launch {
+        scope.launch {
            try {
-                val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
+                val currentUser =
+                    nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
                _currentUserRelayList.value = nostr.relays.getRelayList(currentUser)
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }
@@ -90,13 +86,13 @@ class RelayViewModel(
            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
            return nostr.relays.getRelayList(currentUser)
        } catch (e: Exception) {
-            showError("Error: ${e.message}")
+            onError("Error: ${e.message}")
            return emptyMap()
        }
    }

    fun addInboxRelay(relay: String) {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val relayUrl = RelayUrl.parse(relay)
                val relays = currentUserRelayListInternal().toMutableMap()
@@ -104,13 +100,13 @@ class RelayViewModel(

                nostr.relays.setRelaylist(relays)
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }

    fun addOutboxRelay(relay: String) {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val relayUrl = RelayUrl.parse(relay)
                val relays = currentUserRelayListInternal().toMutableMap()
@@ -118,13 +114,13 @@ class RelayViewModel(

                nostr.relays.setRelaylist(relays)
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }

    fun removeRelay(relay: String) {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val relayUrl = RelayUrl.parse(relay)
                val relays = currentUserRelayListInternal().toMutableMap()
@@ -132,18 +128,19 @@ class RelayViewModel(

                nostr.relays.setRelaylist(relays)
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }

    fun loadCurrentUserMsgRelayList() {
-        viewModelScope.launch {
+        scope.launch {
            try {
-                val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
+                val currentUser =
+                    nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
                _currentUserMsgRelayList.value = nostr.relays.getMsgRelays(currentUser)
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }
@@ -153,13 +150,13 @@ class RelayViewModel(
            val currentUser = nostr.signer.getPublicKeyAsync() ?: throw Exception("User not found")
            return nostr.relays.getMsgRelays(currentUser)
        } catch (e: Exception) {
-            showError("Error: ${e.message}")
+            onError("Error: ${e.message}")
            return emptyList()
        }
    }

    fun addMsgRelay(relay: String) {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val relayUrl = RelayUrl.parse(relay)
                val relays = currentUserMsgRelayListInternal().toMutableSet()
@@ -167,13 +164,13 @@ class RelayViewModel(

                nostr.relays.setMsgRelays(relays.toList())
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }

    fun removeMsgRelay(relay: String) {
-        viewModelScope.launch {
+        scope.launch {
            try {
                val relayUrl = RelayUrl.parse(relay)
                val relays = currentUserMsgRelayListInternal().toMutableSet()
@@ -181,7 +178,7 @@ class RelayViewModel(

                nostr.relays.setMsgRelays(relays.toList())
            } catch (e: Exception) {
-                showError("Error: ${e.message}")
+                onError("Error: ${e.message}")
            }
        }
    }
--- a/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountViewModel.kt
+++ b/shared/src/commonMain/kotlin/su/reya/coop/viewmodel/account/AccountViewModel.kt
@@ -0,0 +1,146 @@
+package su.reya.coop.viewmodel.account
+
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.StateFlow
+import rust.nostr.sdk.PublicKey
+import rust.nostr.sdk.RelayMetadata
+import rust.nostr.sdk.RelayUrl
+import rust.nostr.sdk.Timestamp
+import su.reya.coop.AppStorage
+import su.reya.coop.Profile
+import su.reya.coop.nostr.ExternalSignerHandler
+import su.reya.coop.nostr.Nostr
+import su.reya.coop.repository.MediaRepository
+import su.reya.coop.viewmodel.BaseViewModel
+
+class AccountViewModel(
+    nostr: Nostr,
+    storage: AppStorage,
+    mediaRepository: MediaRepository,
+    externalSignerHandler: ExternalSignerHandler? = null,
+    defaultDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : BaseViewModel() {
+    private val relays = AccountRelayDelegate(
+        nostr = nostr,
+        onError = ::showError,
+        scope = viewModelScope,
+    )
+
+    private val auth = AccountAuthDelegate(
+        nostr = nostr,
+        storage = storage,
+        mediaRepository = mediaRepository,
+        externalSignerHandler = externalSignerHandler,
+        defaultDispatcher = defaultDispatcher,
+        onError = ::showError,
+        onSignerReady = {
+            profile.getUserMetadata()
+            relays.checkRelayList()
+        },
+        scope = viewModelScope,
+    )
+
+    private val profile = AccountProfileDelegate(
+        nostr = nostr,
+        mediaRepository = mediaRepository,
+        onError = ::showError,
+        scope = viewModelScope,
+    )
+
+    private val contacts = AccountContactDelegate(
+        nostr = nostr,
+        onError = ::showError,
+        scope = viewModelScope,
+    )
+
+
+    val state = auth.state
+
+    val currentUserProfile: StateFlow<Profile?> = profile.currentUserProfile
+
+    val isUpdatingProfile: StateFlow<Boolean> = profile.isUpdatingProfile
+
+    val contactList: StateFlow<Set<PublicKey>> = contacts.contactList
+
+    val isRelayListEmpty: StateFlow<Boolean> = relays.isRelayListEmpty
+
+    val currentUserRelayList: StateFlow<Map<RelayUrl, RelayMetadata?>> = relays.currentUserRelayList
+
+    val currentUserMsgRelayList: StateFlow<List<RelayUrl>> = relays.currentUserMsgRelayList
+
+    init {
+        auth.init()
+        contacts.init()
+    }
+
+    fun logout(onLogout: () -> Unit = {}) = auth.logout(onLogout)
+
+    fun dismissNotificationBanner() = auth.dismissNotificationBanner()
+
+    fun connectExternalSigner() = auth.connectExternalSigner()
+
+    fun isExternalSignerAvailable(): Boolean = auth.isExternalSignerAvailable()
+
+    fun importIdentity(secret: String, password: String? = null) =
+        auth.importIdentity(secret, password)
+
+    fun createIdentity(
+        name: String,
+        bio: String? = null,
+        picture: ByteArray? = null,
+        contentType: String? = null,
+    ) = auth.createIdentity(name, bio, picture, contentType)
+
+    fun updateProfile(
+        name: String? = null,
+        bio: String? = null,
+        picture: ByteArray? = null,
+        contentType: String? = null,
+    ) {
+        profile.updateProfile(name, bio, picture, contentType)
+    }
+
+    fun resetInternalState() {
+        contacts.reset()
+        relays.reset()
+    }
+
+    fun addContact(address: String) = contacts.addContact(address)
+
+    fun removeContact(publicKey: PublicKey) = contacts.removeContact(publicKey)
+
+    fun searchByAddress(query: String, onResult: (PublicKey?) -> Unit) =
+        contacts.searchByAddress(query, onResult)
+
+    fun searchByNostr(query: String, onResult: (List<PublicKey>) -> Unit) =
+        contacts.searchByNostr(query, onResult)
+
+    fun verifyActivity(pubkey: PublicKey, onResult: (Timestamp?) -> Unit) =
+        contacts.verifyActivity(pubkey, onResult)
+
+    fun verifyContact(pubkey: PublicKey, onResult: (Boolean) -> Unit) =
+        contacts.verifyContact(pubkey, onResult)
+
+    fun mutualContacts(pubkey: PublicKey, onResult: (Set<PublicKey>) -> Unit) =
+        contacts.mutualContacts(pubkey, onResult)
+
+    fun dismissRelayWarning() = relays.dismissRelayWarning()
+
+    fun refetchMsgRelays() = relays.refetchMsgRelays()
+
+    fun useDefaultMsgRelayList() = relays.useDefaultMsgRelayList()
+
+    fun loadCurrentUserRelayList() = relays.loadCurrentUserRelayList()
+
+    fun addInboxRelay(relay: String) = relays.addInboxRelay(relay)
+
+    fun addOutboxRelay(relay: String) = relays.addOutboxRelay(relay)
+
+    fun loadCurrentUserMsgRelayList() = relays.loadCurrentUserMsgRelayList()
+
+    fun addMsgRelay(relay: String) = relays.addMsgRelay(relay)
+
+    fun removeMsgRelay(relay: String) = relays.removeMsgRelay(relay)
+}