fix: keep paykit flag out of backup

Author: ben-kaufman

app/src/main/java/to/bitkit/data/SettingsStore.kt

@@ -157,6 +157,10 @@ fun SettingsData.resetPin() = this.copy(
     isBiometricEnabled = false,
 )
 
+fun SettingsData.resetLocalOnlySettings() = copy(
+    isPaykitEnabled = false,
+)
+
 fun SettingsData.hasPublicPaykitPublicationState(): Boolean =
     hasConfirmedPublicPaykitEndpoints ||
         sharesPublicPaykitEndpoints ||

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

@@ -25,13 +25,16 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonObject
 import to.bitkit.R
 import to.bitkit.data.AppDb
 import to.bitkit.data.CacheStore
 import to.bitkit.data.SettingsStore
 import to.bitkit.data.WidgetsStore
 import to.bitkit.data.backup.VssBackupClient
 import to.bitkit.data.backup.VssBackupClientLdk
+import to.bitkit.data.resetLocalOnlySettings
 import to.bitkit.data.resetPin
 import to.bitkit.di.IoDispatcher
 import to.bitkit.di.json
@@ -468,12 +471,12 @@ class BackupRepo @Inject constructor(
 
     private suspend fun getBackupDataBytes(category: BackupCategory): ByteArray = when (category) {
         BackupCategory.SETTINGS -> {
-            val data = settingsStore.data.first().resetPin()
+            val data = settingsStore.data.first().resetLocalOnlySettings().resetPin()
             val payload = SettingsBackupV1(
                 createdAt = currentTimeMillis(),
                 settings = data,
             )
-            json.encodeToString(payload).toByteArray()
+            payload.toSanitizedBackupBytes()
         }
 
         BackupCategory.WIDGETS -> {
@@ -699,6 +702,15 @@ class BackupRepo @Inject constructor(
         }
     }
 
+    private fun SettingsBackupV1.toSanitizedBackupBytes(): ByteArray {
+        val payload = json.encodeToJsonElement(SettingsBackupV1.serializer(), this).jsonObject
+        val settings = payload.getValue("settings").jsonObject
+        val sanitizedPayload = JsonObject(
+            payload + ("settings" to JsonObject(settings - "isPaykitEnabled"))
+        )
+        return json.encodeToString(JsonObject.serializer(), sanitizedPayload).toByteArray()
+    }
+
     companion object {
         private const val TAG = "BackupRepo"
 

app/src/test/java/to/bitkit/repositories/BackupRepoTest.kt

@@ -3,10 +3,13 @@ package to.bitkit.repositories
 import android.content.Context
 import com.synonym.vssclient.VssItem
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.serialization.json.jsonObject
 import org.junit.Before
 import org.junit.Test
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
@@ -23,11 +26,13 @@ import to.bitkit.data.entities.TransferEntity
 import to.bitkit.di.json
 import to.bitkit.models.BackupCategory
 import to.bitkit.models.PrivatePaykitContactLinkBackupV1
+import to.bitkit.models.SettingsBackupV1
 import to.bitkit.models.WalletBackupV1
 import to.bitkit.services.LightningService
 import to.bitkit.test.BaseUnitTest
 import to.bitkit.utils.AppError
 import javax.inject.Provider
+import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import kotlin.time.Clock
 import kotlin.time.ExperimentalTime
@@ -65,6 +70,8 @@ class BackupRepoTest : BaseUnitTest() {
         whenever(settingsStore.data).thenReturn(settingsData)
         whenever { settingsStore.update(any()) }.thenReturn(Unit)
         whenever { vssBackupClient.getObject(any()) }.thenReturn(Result.success(null))
+        whenever { vssBackupClient.putObject(any(), any()) }
+            .thenReturn(Result.success(VssItem(key = BackupCategory.SETTINGS.name, value = byteArrayOf(), version = 1)))
         whenever { privatePaykitRepo.restoreBackup(anyOrNull()) }.thenReturn(Result.success(Unit))
         whenever { privatePaykitAddressReservationRepo.restoreBackup(any()) }.thenReturn(Result.success(Unit))
         whenever {
@@ -126,6 +133,27 @@ class BackupRepoTest : BaseUnitTest() {
         verify(privatePaykitRepo).setContactSharingCleanupPending(true)
     }
 
+    @Test
+    fun `settings backup excludes local Paykit UI flag`() = test {
+        settingsData.value = SettingsData(
+            isPaykitEnabled = true,
+            sharesPublicPaykitEndpoints = true,
+            publicPaykitBolt11 = "lnbc1backup",
+        )
+        val dataCaptor = argumentCaptor<ByteArray>()
+
+        sut.triggerBackup(BackupCategory.SETTINGS)
+
+        verify(vssBackupClient).putObject(eq(BackupCategory.SETTINGS.name), dataCaptor.capture())
+        val backupJson = json.parseToJsonElement(dataCaptor.firstValue.decodeToString()).jsonObject
+        val settingsJson = backupJson.getValue("settings").jsonObject
+        val payload = json.decodeFromString<SettingsBackupV1>(dataCaptor.firstValue.decodeToString())
+        assertFalse("isPaykitEnabled" in settingsJson)
+        assertFalse(payload.settings.isPaykitEnabled)
+        assertTrue(payload.settings.sharesPublicPaykitEndpoints)
+        assertTrue(payload.settings.publicPaykitBolt11.isNotBlank())
+    }
+
     private fun stubWalletBackup(
         privatePaykitContactLinks: Map<String, PrivatePaykitContactLinkBackupV1>? = null,
     ) {