chore: update Kotlin code

Author: JOHN

app/src/main/java/to/bitkit/paykit/services/DirectoryService.kt

@@ -149,6 +149,7 @@ class DirectoryService @Inject constructor(
      */
     fun configureWithPubkySession(session: PubkySession, homeserver: HomeserverURL? = null) {
         homeserverURL = homeserver ?: HomeserverDefaults.defaultHomeserverURL
+        ownerPubkey = session.pubkey
 
         // Configure authenticated transport and adapter
         val adapter = pubkyStorage.createAuthenticatedAdapter(session.sessionSecret, session.pubkey, homeserverURL)
@@ -162,6 +163,35 @@ class DirectoryService @Inject constructor(
         Logger.info("Configured DirectoryService with Pubky session for ${session.pubkey}", context = TAG)
     }
 
+    /** Owner pubkey for the current session, cached for profile operations */
+    private var ownerPubkey: String? = null
+
+    /** Cached profile for the current session */
+    private var cachedProfile: PubkyProfile? = null
+
+    /**
+     * Prefetch and cache the user's profile after session establishment.
+     * This enables instant profile loading in the UI.
+     */
+    suspend fun prefetchProfile() {
+        val pubkey = ownerPubkey ?: return
+        runCatching {
+            cachedProfile = fetchProfile(pubkey)
+            Logger.debug("Prefetched profile for $pubkey", context = TAG)
+        }.onFailure { e ->
+            Logger.debug("Could not prefetch profile: ${e.message}", context = TAG)
+        }
+    }
+
+    /**
+     * Get the cached profile if available, otherwise fetch it.
+     */
+    suspend fun getOrFetchProfile(): PubkyProfile? {
+        val pubkey = ownerPubkey ?: keyManager.getCurrentPublicKeyZ32() ?: return null
+        cachedProfile?.let { return it }
+        return fetchProfile(pubkey).also { cachedProfile = it }
+    }
+
     /**
      * Attempt to auto-configure from stored keychain credentials.
      * Returns true if successfully configured, false if no stored session exists.

app/src/main/java/to/bitkit/paykit/storage/ContactStorage.kt

@@ -92,10 +92,21 @@ class ContactStorage @Inject constructor(
         contactsCache.remove(identity)
     }
 
+    /**
+     * Import contacts with upsert semantics: update existing, insert new, preserve local-only fields.
+     */
     suspend fun importContacts(newContacts: List<Contact>) {
         val contacts = listContacts().toMutableList()
         for (newContact in newContacts) {
-            if (!contacts.any { it.id == newContact.id }) {
+            val index = contacts.indexOfFirst { it.id == newContact.id }
+            if (index >= 0) {
+                // Upsert: update existing, preserving local-only fields (payment history)
+                val existing = contacts[index]
+                contacts[index] = newContact.copy(
+                    lastPaymentAt = existing.lastPaymentAt,
+                    paymentCount = existing.paymentCount,
+                )
+            } else {
                 contacts.add(newContact)
             }
         }

app/src/main/java/to/bitkit/paykit/viewmodels/ContactsViewModel.kt

@@ -12,22 +12,33 @@ import kotlinx.coroutines.withContext
 import to.bitkit.paykit.models.Contact
 import to.bitkit.paykit.services.DirectoryService
 import to.bitkit.paykit.services.DiscoveredContact
+import to.bitkit.paykit.services.PubkySDKService
 import to.bitkit.paykit.storage.ContactStorage
+import to.bitkit.utils.Logger
 import dagger.hilt.android.lifecycle.HiltViewModel
 import javax.inject.Inject
 
 /**
- * ViewModel for Contacts management
+ * ViewModel for Contacts management.
+ * Contacts are synchronized with Pubky follows - the homeserver is the source of truth.
  */
 @HiltViewModel
 class ContactsViewModel @Inject constructor(
     private val contactStorage: ContactStorage,
     private val directoryService: DirectoryService,
+    private val pubkySDKService: PubkySDKService,
 ) : ViewModel() {
 
+    companion object {
+        private const val TAG = "ContactsViewModel"
+    }
+
     private val _contacts = MutableStateFlow<List<Contact>>(emptyList())
     val contacts: StateFlow<List<Contact>> = _contacts.asStateFlow()
 
+    /** Unfiltered list of all contacts (used for searching) */
+    private var allContacts: List<Contact> = emptyList()
+
     private val _searchQuery = MutableStateFlow("")
     val searchQuery: StateFlow<String> = _searchQuery.asStateFlow()
 
@@ -50,29 +61,89 @@ class ContactsViewModel @Inject constructor(
     fun loadContacts() {
         viewModelScope.launch {
             _isLoading.value = true
-            _contacts.value = contactStorage.listContacts()
+            runCatching {
+                // Sync contacts from Pubky follows (source of truth)
+                val follows = withContext(Dispatchers.IO) {
+                    directoryService.discoverContactsFromFollows()
+                }
+                
+                // Convert discovered contacts to Contact model and merge with local data
+                val followContacts = follows.map { discovered ->
+                    val existing = contactStorage.getContact(discovered.pubkey)
+                    Contact(
+                        id = discovered.pubkey,
+                        publicKeyZ32 = discovered.pubkey,
+                        name = discovered.name ?: existing?.name ?: "",
+                        notes = existing?.notes,
+                        createdAt = existing?.createdAt ?: System.currentTimeMillis(),
+                        lastPaymentAt = existing?.lastPaymentAt,
+                        paymentCount = existing?.paymentCount ?: 0,
+                    )
+                }
+                
+                // Persist synced contacts locally for offline access
+                contactStorage.importContacts(followContacts)
+                
+                // Store unfiltered list for searching
+                allContacts = followContacts
+                
+                _contacts.value = if (_searchQuery.value.isEmpty()) {
+                    followContacts
+                } else {
+                    followContacts.filter { contact ->
+                        contact.name.contains(_searchQuery.value, ignoreCase = true) ||
+                            contact.publicKeyZ32.contains(_searchQuery.value, ignoreCase = true)
+                    }
+                }
+                
+                // Also update discovered contacts for the discovery screen
+                _discoveredContacts.value = follows
+                
+                Logger.debug("Loaded ${followContacts.size} contacts from Pubky follows", context = TAG)
+            }.onFailure { e ->
+                Logger.error("Failed to load contacts from follows", e, context = TAG)
+                // Fallback to local storage
+                val localContacts = contactStorage.listContacts()
+                allContacts = localContacts
+                _contacts.value = localContacts
+            }
             _isLoading.value = false
         }
     }
 
     fun searchContacts() {
-        viewModelScope.launch {
-            if (_searchQuery.value.isEmpty()) {
-                _contacts.value = contactStorage.listContacts()
-            } else {
-                _contacts.value = contactStorage.searchContacts(_searchQuery.value)
+        // Filter from the in-memory list (not storage) to match visible list after network sync
+        val source = allContacts.ifEmpty { contactStorage.listContacts() }
+        _contacts.value = if (_searchQuery.value.isEmpty()) {
+            source
+        } else {
+            source.filter { contact ->
+                contact.name.contains(_searchQuery.value, ignoreCase = true) ||
+                    contact.publicKeyZ32.contains(_searchQuery.value, ignoreCase = true)
             }
         }
     }
 
     fun addContact(contact: Contact) {
         viewModelScope.launch {
             runCatching {
+                // Save locally first for immediate feedback
                 contactStorage.saveContact(contact)
                 loadContacts()
             }.onFailure { e ->
                 _errorMessage.update { "Failed to add contact: ${e.message}" }
             }
+            
+            // Then create Pubky follow in background
+            runCatching {
+                withContext(Dispatchers.IO) {
+                    directoryService.addFollow(contact.publicKeyZ32)
+                }
+                Logger.info("Added follow for contact: ${contact.publicKeyZ32.take(12)}...", context = TAG)
+            }.onFailure { e ->
+                _errorMessage.update { "Failed to sync follow to Pubky: ${e.message}" }
+                Logger.error("Failed to add follow: ${e.message}", context = TAG)
+            }
         }
     }
 
@@ -90,26 +161,31 @@ class ContactsViewModel @Inject constructor(
     fun deleteContact(contact: Contact) {
         viewModelScope.launch {
             runCatching {
+                // Delete locally first for immediate feedback
                 contactStorage.deleteContact(contact.id)
                 loadContacts()
             }.onFailure { e ->
                 _errorMessage.update { "Failed to delete contact: ${e.message}" }
             }
-        }
-    }
-
-    fun discoverContacts() {
-        viewModelScope.launch {
-            _isLoading.value = true
+            
+            // Then remove Pubky follow in background
             runCatching {
-                _discoveredContacts.value = directoryService.discoverContactsFromFollows()
+                withContext(Dispatchers.IO) {
+                    directoryService.removeFollow(contact.publicKeyZ32)
+                }
+                Logger.info("Removed follow for contact: ${contact.publicKeyZ32.take(12)}...", context = TAG)
             }.onFailure { e ->
-                _errorMessage.update { "Failed to discover contacts: ${e.message}" }
+                _errorMessage.update { "Failed to sync unfollow to Pubky: ${e.message}" }
+                Logger.error("Failed to remove follow: ${e.message}", context = TAG)
             }
-            _isLoading.value = false
         }
     }
 
+    fun discoverContacts() {
+        // Discovery is now unified with loadContacts - just refresh from follows
+        loadContacts()
+    }
+
     fun importDiscovered(contacts: List<Contact>) {
         viewModelScope.launch {
             runCatching {
@@ -132,24 +208,56 @@ class ContactsViewModel @Inject constructor(
 
     fun followContact(pubkey: String) {
         viewModelScope.launch {
+            _isLoading.value = true
             runCatching {
                 withContext(Dispatchers.IO) {
+                    // 1. Add follow to Pubky homeserver
                     directoryService.addFollow(pubkey)
+                    
+                    // 2. Fetch profile for the followed user
+                    val profile = runCatching { pubkySDKService.fetchProfile(pubkey) }.getOrNull()
+                    
+                    // 3. Add to local contacts
+                    val contact = Contact(
+                        id = pubkey,
+                        publicKeyZ32 = pubkey,
+                        name = profile?.name ?: "",
+                        notes = null,
+                        createdAt = System.currentTimeMillis(),
+                        lastPaymentAt = null,
+                        paymentCount = 0,
+                    )
+                    contactStorage.saveContact(contact)
+                    
+                    Logger.info("Followed and added contact: $pubkey", context = TAG)
                 }
+                // 4. Refresh contacts list
+                loadContacts()
             }.onFailure { e ->
+                Logger.error("Failed to follow: ${e.message}", context = TAG)
                 _errorMessage.update { "Failed to follow: ${e.message}" }
+                _isLoading.value = false
             }
         }
     }
 
     fun unfollowContact(pubkey: String) {
         viewModelScope.launch {
+            _isLoading.value = true
             runCatching {
                 withContext(Dispatchers.IO) {
+                    // Remove follow from Pubky homeserver
                     directoryService.removeFollow(pubkey)
+                    // Remove from local contacts
+                    contactStorage.deleteContact(pubkey)
+                    Logger.info("Unfollowed and removed contact: $pubkey", context = TAG)
                 }
+                // Refresh contacts list
+                loadContacts()
             }.onFailure { e ->
+                Logger.error("Failed to unfollow: ${e.message}", context = TAG)
                 _errorMessage.update { "Failed to unfollow: ${e.message}" }
+                _isLoading.value = false
             }
         }
     }

app/src/main/java/to/bitkit/paykit/viewmodels/PubkyRingAuthViewModel.kt

@@ -55,6 +55,8 @@ class PubkyRingAuthViewModel @Inject constructor(
                 directoryService.configureWithPubkySession(session)
                 // Update PaykitManager with owner pubkey for polling and other operations
                 paykitManager.setOwnerPubkey(session.pubkey)
+                // Prefetch profile for instant loading in UI
+                directoryService.prefetchProfile()
                 onSuccess(session)
             } catch (e: Exception) {
                 _errorMessage.value = e.message
@@ -81,7 +83,7 @@ class PubkyRingAuthViewModel @Inject constructor(
 
     fun startPollingForSession(onSuccess: (PubkySession) -> Unit) {
         val request = _crossDeviceRequest.value ?: return
-        
+
         viewModelScope.launch {
             _isPolling.value = true
             _errorMessage.value = null
@@ -91,6 +93,8 @@ class PubkyRingAuthViewModel @Inject constructor(
                 directoryService.configureWithPubkySession(session)
                 // Update PaykitManager with owner pubkey for polling and other operations
                 paykitManager.setOwnerPubkey(session.pubkey)
+                // Prefetch profile for instant loading in UI
+                directoryService.prefetchProfile()
                 onSuccess(session)
             } catch (e: Exception) {
                 _errorMessage.value = e.message
@@ -111,6 +115,8 @@ class PubkyRingAuthViewModel @Inject constructor(
                 directoryService.configureWithPubkySession(session)
                 // Update PaykitManager with owner pubkey for polling and other operations
                 paykitManager.setOwnerPubkey(session.pubkey)
+                // Prefetch profile for instant loading in UI
+                directoryService.prefetchProfile()
                 onSuccess(session)
             } catch (e: Exception) {
                 _errorMessage.value = e.message

app/src/main/java/to/bitkit/ui/ContentView.kt

@@ -1662,7 +1662,15 @@ private fun NavGraphBuilder.paykit(navController: NavHostController) {
         to.bitkit.ui.paykit.PaykitContactsScreen(
             onNavigateBack = { navController.popBackStack() },
             onNavigateToContactDiscovery = { navController.navigate(Routes.PaykitContactDiscovery) },
-            onNavigateToContactDetail = { id -> /* TODO: Navigate to contact detail */ }
+            onNavigateToContactDetail = { id -> navController.navigate(Routes.PaykitContactDetail(id)) },
+        )
+    }
+    composableWithDefaultTransitions<Routes.PaykitContactDetail> { backStackEntry ->
+        val id = backStackEntry.toRoute<Routes.PaykitContactDetail>().id
+        to.bitkit.ui.paykit.ContactDetailScreen(
+            contactId = id,
+            onNavigateBack = { navController.popBackStack() },
+            onNavigateToNoisePayment = { pubkey -> navController.navigate(Routes.PaykitNoisePayment(pubkey)) },
         )
     }
     composableWithDefaultTransitions<Routes.PaykitContactDiscovery> {
@@ -1711,9 +1719,11 @@ private fun NavGraphBuilder.paykit(navController: NavHostController) {
             onNavigateBack = { navController.popBackStack() }
         )
     }
-    composableWithDefaultTransitions<Routes.PaykitNoisePayment> {
+    composableWithDefaultTransitions<Routes.PaykitNoisePayment> { backStackEntry ->
+        val route = backStackEntry.toRoute<Routes.PaykitNoisePayment>()
         to.bitkit.ui.paykit.NoisePaymentScreen(
-            onNavigateBack = { navController.popBackStack() }
+            onNavigateBack = { navController.popBackStack() },
+            prefillRecipient = route.recipientPubkey,
         )
     }
     composableWithDefaultTransitions<Routes.PaykitPrivateEndpoints> {
@@ -2068,6 +2078,9 @@ sealed interface Routes {
     @Serializable
     data object PaykitContactDiscovery : Routes
 
+    @Serializable
+    data class PaykitContactDetail(val id: String) : Routes
+
     @Serializable
     data object PaykitReceipts : Routes
 
@@ -2090,7 +2103,7 @@ sealed interface Routes {
     data object PaykitPaymentRequests : Routes
 
     @Serializable
-    data object PaykitNoisePayment : Routes
+    data class PaykitNoisePayment(val recipientPubkey: String? = null) : Routes
 
     @Serializable
     data object PaykitPrivateEndpoints : Routes

app/src/main/java/to/bitkit/ui/components/DrawerMenu.kt

@@ -169,8 +169,11 @@ private fun Menu(
         DrawerItem(
             label = stringResource(R.string.wallet__drawer__profile),
             iconRes = R.drawable.ic_user_square,
-            onClick = null, // TODO IMPLEMENT PROFILE
-            modifier = Modifier.testTag("DrawerProfile")
+            onClick = {
+                rootNavController.navigateIfNotCurrent(Routes.PaykitProfileEdit)
+                scope.launch { drawerState.close() }
+            },
+            modifier = Modifier.testTag("DrawerProfile"),
         )
 
         DrawerItem(