fix: harden paykit receiver state

Author: ben-kaufman

app/src/main/java/to/bitkit/repositories/PrivatePaykitRepo.kt

@@ -153,10 +153,15 @@ class PrivatePaykitRepo @Inject constructor(
         }
     }
 
-    suspend fun refreshSavedContactEndpoints(publicKey: String): Result<Unit> =
+    suspend fun refreshSavedContactEndpoints(
+        publicKey: String,
+        savedPublicKeys: Collection<String>,
+    ): Result<Unit> =
         withContext(serializedDispatcher) {
             runSuspendCatching {
-                val keys = rememberSavedContacts(listOf(publicKey), replacing = false)
+                val normalizedKey = normalizedPublicKey(publicKey) ?: return@runSuspendCatching
+                rememberSavedContacts(savedPublicKeys + normalizedKey, replacing = false)
+                val keys = listOf(normalizedKey)
                 if (!canPublishPrivateEndpoints()) {
                     prepareRelevantPrivateLinksIfAvailable(keys, "refresh")
                     return@runSuspendCatching

app/src/main/java/to/bitkit/ui/screens/profile/EditProfileViewModel.kt

@@ -269,9 +269,6 @@ class EditProfileViewModel @Inject constructor(
         }
         val cleanupResult = privatePaykitRepo.removePublishedEndpointsForCleanup(TAG)
         if (cleanupResult.isFailure) {
-            val error = requireNotNull(cleanupResult.exceptionOrNull()) {
-                "Private Paykit cleanup failed without an error"
-            }
             _uiState.update {
                 it.copy(
                     isSaving = false,

app/src/main/java/to/bitkit/usecases/RefreshContactPaykitReceiversUseCase.kt

@@ -22,7 +22,8 @@ class RefreshContactPaykitReceiversUseCase @Inject constructor(
     suspend operator fun invoke(publicKey: String): Result<Unit> = withContext(ioDispatcher) {
         runSuspendCatching {
             pubkyRepo.refreshContactReceiverPaths(publicKey).getOrThrow()
-            privatePaykitRepo.refreshSavedContactEndpoints(publicKey).getOrThrow()
+            val savedPublicKeys = (pubkyRepo.contacts.value.map { it.publicKey } + publicKey).distinct()
+            privatePaykitRepo.refreshSavedContactEndpoints(publicKey, savedPublicKeys).getOrThrow()
         }.onFailure {
             Logger.warn(
                 "Failed to refresh Paykit receivers for '${PubkyPublicKeyFormat.redacted(publicKey)}'",

app/src/test/java/to/bitkit/usecases/RefreshContactPaykitReceiversUseCaseTest.kt

@@ -1,11 +1,14 @@
 package to.bitkit.usecases
 
+import kotlinx.coroutines.flow.MutableStateFlow
+import org.junit.Before
 import org.junit.Test
 import org.mockito.kotlin.inOrder
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
+import to.bitkit.models.PubkyProfile
 import to.bitkit.repositories.PrivatePaykitRepo
 import to.bitkit.repositories.PubkyRepo
 import to.bitkit.test.BaseUnitTest
@@ -16,24 +19,43 @@ class RefreshContactPaykitReceiversUseCaseTest : BaseUnitTest() {
     private val pubkyRepo = mock<PubkyRepo>()
     private val privatePaykitRepo = mock<PrivatePaykitRepo>()
     private val contactKeys = listOf("pubky-alice", "pubky-bob")
+    private val contacts = MutableStateFlow(
+        contactKeys.map { publicKey ->
+            PubkyProfile(
+                publicKey = publicKey,
+                name = publicKey,
+                bio = "",
+                imageUrl = null,
+                links = emptyList(),
+                status = null,
+            )
+        },
+    )
 
     private val sut = RefreshContactPaykitReceiversUseCase(
         ioDispatcher = testDispatcher,
         pubkyRepo = pubkyRepo,
         privatePaykitRepo = privatePaykitRepo,
     )
 
+    @Before
+    fun setUp() {
+        whenever(pubkyRepo.contacts).thenReturn(contacts)
+    }
+
     @Test
     fun `refreshes receiver paths before publishing the contact`() = test {
         whenever { pubkyRepo.refreshContactReceiverPaths(contactKeys.last()) }.thenReturn(Result.success(Unit))
-        whenever { privatePaykitRepo.refreshSavedContactEndpoints(contactKeys.last()) }.thenReturn(Result.success(Unit))
+        whenever {
+            privatePaykitRepo.refreshSavedContactEndpoints(contactKeys.last(), contactKeys)
+        }.thenReturn(Result.success(Unit))
 
         val result = sut(contactKeys.last())
 
         assertTrue(result.isSuccess)
         inOrder(pubkyRepo, privatePaykitRepo).apply {
             verify(pubkyRepo).refreshContactReceiverPaths(contactKeys.last())
-            verify(privatePaykitRepo).refreshSavedContactEndpoints(contactKeys.last())
+            verify(privatePaykitRepo).refreshSavedContactEndpoints(contactKeys.last(), contactKeys)
         }
     }
 
@@ -45,6 +67,6 @@ class RefreshContactPaykitReceiversUseCaseTest : BaseUnitTest() {
         val result = sut(contactKeys.last())
 
         assertEquals(error, result.exceptionOrNull())
-        verify(privatePaykitRepo, never()).refreshSavedContactEndpoints(contactKeys.last())
+        verify(privatePaykitRepo, never()).refreshSavedContactEndpoints(contactKeys.last(), contactKeys)
     }
 }