feat: support restore from RN app

Author: ben-kaufman

app/src/main/java/to/bitkit/env/Env.kt

@@ -187,6 +187,18 @@ internal object Env {
     const val BITREFILL_APP = "Bitkit"
     const val BITREFILL_REF = "AL6dyZYt"
 
+    val rnBackupServerHost: String
+        get() = when (network) {
+            Network.BITCOIN -> "https://blocktank.synonym.to/backups-ldk"
+            else -> "https://bitkit.stag0.blocktank.to/backups-ldk"
+        }
+
+    val rnBackupServerPubKey: String
+        get() = when (network) {
+            Network.BITCOIN -> "0236efd76e37f96cf2dced9d52ff84c97e5b3d4a75e7d494807291971783f38377"
+            else -> "02c03b8b8c1b5500b622646867d99bf91676fac0f38e2182c91a9ff0d053a21d6d"
+        }
+
     // endregion
 }
 

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

@@ -7,6 +7,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -21,6 +23,8 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.Serializable
 import to.bitkit.R
 import to.bitkit.data.AppDb
 import to.bitkit.data.CacheStore
@@ -49,6 +53,7 @@ import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.time.Clock
+import kotlin.time.Duration.Companion.seconds
 import kotlin.time.ExperimentalTime
 
 /**
@@ -536,6 +541,37 @@ class BackupRepo @Inject constructor(
         }
     }
 
+    suspend fun getLatestBackupTime(): ULong? = withContext(ioDispatcher) {
+        runCatching {
+            withTimeout(VSS_TIMESTAMP_TIMEOUT) {
+                vssBackupClient.setup()
+                coroutineScope {
+                    BackupCategory.entries
+                        .filter { it != BackupCategory.LIGHTNING_CONNECTIONS }
+                        .map { category -> async { getRemoteBackupTimestamp(category) } }
+                        .mapNotNull { it.await() }
+                        .filter { it > 0uL }
+                        .maxOrNull()
+                }
+            }
+        }.onFailure { e ->
+            Logger.warn("Failed to get VSS backup timestamp: $e", context = TAG)
+        }.getOrNull()
+    }
+
+    private suspend fun getRemoteBackupTimestamp(category: BackupCategory): ULong? {
+        val item = vssBackupClient.getObject(category.name).getOrNull() ?: return null
+        val data = item.value ?: return null
+
+        @Serializable
+        data class BackupWithCreatedAt(val createdAt: Long? = null)
+
+        return runCatching {
+            val millis = json.decodeFromString<BackupWithCreatedAt>(String(data)).createdAt ?: return@runCatching null
+            (millis / 1000).toULong()
+        }.getOrNull()
+    }
+
     fun scheduleFullBackup() {
         Logger.debug("Scheduling backups for all categories", context = TAG)
         BackupCategory.entries
@@ -578,5 +614,6 @@ class BackupRepo @Inject constructor(
         private const val FAILED_BACKUP_CHECK_TIME = 30 * 60 * 1000L // 30 minutes
         private const val FAILED_BACKUP_NOTIFICATION_INTERVAL = 10 * 60 * 1000L // 10 minutes
         private const val SYNC_STATUS_DEBOUNCE = 500L // 500ms debounce for sync status updates
+        private val VSS_TIMESTAMP_TIMEOUT = 60.seconds
     }
 }

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

@@ -29,6 +29,7 @@ import org.lightningdevkit.ldknode.Address
 import org.lightningdevkit.ldknode.BalanceDetails
 import org.lightningdevkit.ldknode.BestBlock
 import org.lightningdevkit.ldknode.ChannelConfig
+import org.lightningdevkit.ldknode.ChannelDataMigration
 import org.lightningdevkit.ldknode.ChannelDetails
 import org.lightningdevkit.ldknode.ClosureReason
 import org.lightningdevkit.ldknode.Event
@@ -167,7 +168,7 @@ class LightningRepo @Inject constructor(
         walletIndex: Int,
         customServerUrl: String? = null,
         customRgsServerUrl: String? = null,
-        channelMigration: org.lightningdevkit.ldknode.ChannelDataMigration? = null,
+        channelMigration: ChannelDataMigration? = null,
     ) = withContext(bgDispatcher) {
         return@withContext try {
             val trustedPeers = getTrustedPeersFromBlocktank()
@@ -197,7 +198,7 @@ class LightningRepo @Inject constructor(
         customServerUrl: String? = null,
         customRgsServerUrl: String? = null,
         eventHandler: NodeEventHandler? = null,
-        channelMigration: org.lightningdevkit.ldknode.ChannelDataMigration? = null,
+        channelMigration: ChannelDataMigration? = null,
     ): Result<Unit> = withContext(bgDispatcher) {
         if (_isRecoveryMode.value) {
             return@withContext Result.failure(RecoveryModeException())

app/src/main/java/to/bitkit/services/CoreService.kt

@@ -586,19 +586,15 @@ class ActivityService(
         timestamp: ULong,
     ): ConfirmationData {
         var isConfirmed = false
-        var confirmedTimestamp: ULong? = null
+        var blockTimestamp: ULong? = null
 
         val status = kind.status
         if (status is ConfirmationStatus.Confirmed) {
             isConfirmed = true
-            confirmedTimestamp = status.timestamp
+            blockTimestamp = status.timestamp
         }
 
-        if (isConfirmed && confirmedTimestamp != null && confirmedTimestamp < timestamp) {
-            confirmedTimestamp = timestamp
-        }
-
-        return ConfirmationData(isConfirmed, confirmedTimestamp, timestamp)
+        return ConfirmationData(isConfirmed, blockTimestamp, timestamp)
     }
 
     private fun buildUpdatedOnchainActivity(
@@ -636,6 +632,14 @@ class ActivityService(
         channelId: String? = null,
     ): OnchainActivity {
         val isTransfer = channelId != null
+        val paymentTimestamp = confirmationData.timestamp
+        val blockTimestamp = confirmationData.confirmedTimestamp
+
+        val activityTimestamp = if (blockTimestamp != null && blockTimestamp < paymentTimestamp) {
+            blockTimestamp
+        } else {
+            paymentTimestamp
+        }
 
         return OnchainActivity.create(
             id = payment.id,
@@ -644,10 +648,10 @@ class ActivityService(
             value = payment.amountSats ?: 0u,
             fee = (payment.feePaidMsat ?: 0u) / 1000u,
             address = resolvedAddress ?: "Loading...",
-            timestamp = confirmationData.timestamp,
+            timestamp = activityTimestamp,
             confirmed = confirmationData.isConfirmed,
             isTransfer = isTransfer,
-            confirmTimestamp = confirmationData.confirmedTimestamp,
+            confirmTimestamp = blockTimestamp,
             channelId = channelId,
             seenAt = null,
         )