fix: settle a spark send that finished before it was watched

Author: ovitrif

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

@@ -2309,6 +2309,9 @@ class LightningRepo @Inject constructor(
     fun getChannels(): List<ChannelDetails>? =
         if (_lightningState.value.nodeLifecycleState.isRunning()) lightningService.channels else null
 
+    /** The completion event of a Spark send that settled before its caller started watching for it. */
+    suspend fun settledSparkSendEvent(paymentHash: String): Event? = sparkRepo.settledSendEvent(paymentHash)
+
     /**
      * Whether Lightning can be received, through a usable channel or Spark; Paykit publishes a Lightning endpoint
      * only then.

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

@@ -290,6 +290,22 @@ class SparkRepo @Inject constructor(
             }
     }
 
+    /**
+     * The completion event of a Spark Lightning send that has already settled. A Spark-to-Spark payment settles inside
+     * the send call, so its event can fire before the caller starts watching for it.
+     */
+    suspend fun settledSendEvent(paymentHash: String): Event? = withContext(bgDispatcher) {
+        if (!sparkService.isConnected) return@withContext null
+        runSuspendCatching { sparkService.listPayments() }
+            .onFailure { Logger.warn("Failed to list Spark payments", it, context = TAG) }
+            .getOrNull()
+            ?.firstOrNull {
+                val hash = (it.details as? PaymentDetails.Lightning)?.htlcDetails?.paymentHash
+                it.paymentType == SparkPaymentType.SEND && hash.equals(paymentHash, ignoreCase = true)
+            }
+            ?.toNodeEvent()
+    }
+
     /** Payment hashes of the Lightning payments Spark received. */
     suspend fun receivedLightningPaymentHashes(): Set<String> =
         lightningPaymentHashes { it.paymentType == SparkPaymentType.RECEIVE && it.status == PaymentStatus.COMPLETED }

app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt

@@ -6682,18 +6682,22 @@ class AppViewModel @Inject constructor(
             paymentDeadlineAt = paymentDeadlineAt,
             onBeforeSend = onBeforeSend,
         ).onSuccess { hash ->
-            // Wait until matching payment event is received (with timeout for hold invoices)
-            val result = lightningRepo.nodeEvents.watchUntil(LightningRepo.SEND_LN_TIMEOUT) {
-                when (it) {
-                    is Event.PaymentSuccessful if it.paymentHash == hash -> WatchResult.Complete(Result.success(hash))
-                    is Event.PaymentFailed if it.paymentHash == hash -> WatchResult.Complete(
-                        Result.failure(
-                            LightningPaymentFailedError(reason = it.reason, paymentRequest = bolt11)
-                        )
-                    )
+            fun outcome(event: Event): Result<PaymentId>? = when (event) {
+                is Event.PaymentSuccessful if event.paymentHash == hash -> Result.success(hash)
+                is Event.PaymentFailed if event.paymentHash == hash -> Result.failure(
+                    LightningPaymentFailedError(reason = event.reason, paymentRequest = bolt11)
+                )
 
-                    else -> WatchResult.Continue()
+                else -> null
+            }
+            // Wait until matching payment event is received (with timeout for hold invoices)
+            val result = coroutineScope {
+                val watch = async(start = CoroutineStart.UNDISPATCHED) {
+                    lightningRepo.nodeEvents.watchUntil(LightningRepo.SEND_LN_TIMEOUT) {
+                        outcome(it)?.let { result -> WatchResult.Complete(result) } ?: WatchResult.Continue()
+                    }
                 }
+                lightningRepo.settledSparkSendEvent(hash)?.let(::outcome)?.also { watch.cancel() } ?: watch.await()
             }
             return result ?: Result.failure(PaymentPendingException(hash))
         }

app/src/test/java/to/bitkit/viewmodels/AppViewModelSendFlowTest.kt

@@ -13094,6 +13094,36 @@ class AppViewModelSendFlowTest : BaseUnitTest() {
         verify(privatePaykitRepo).consumePrivatePaymentList(contactKey, privateContext)
     }
 
+    @Test
+    fun `spark send that settled before the watch started completes without pending`() = test {
+        val bolt11 = "lnbcrt1sparktospark"
+        val paymentHash = "spark_hash"
+        balanceState.value = BalanceState(maxSendLightningSats = 100_000u)
+        whenever(lightningRepo.payInvoice(bolt11 = bolt11, sats = null)).thenReturn(Result.success(paymentHash))
+        whenever(lightningRepo.settledSparkSendEvent(paymentHash)).thenReturn(
+            Event.PaymentSuccessful(
+                paymentId = paymentHash,
+                paymentHash = paymentHash,
+                paymentPreimage = "preimage",
+                feePaidMsat = 0uL,
+            ),
+        )
+        setSendState(
+            SendUiState(
+                address = bolt11,
+                amount = 1000u,
+                payMethod = SendMethod.LIGHTNING,
+                decodedInvoice = lightningInvoice(bolt11, amountSats = 1000u),
+            ),
+        )
+
+        sut.setSendEvent(SendEvent.PayConfirmed)
+        advanceTimeBy(LightningRepo.SEND_LN_TIMEOUT.inWholeMilliseconds + 1_000)
+        runCurrent()
+
+        verify(pendingPaymentRepo, never()).track(paymentHash)
+    }
+
     @Test
     fun `private lightning pending payment consumes private list`() = test {
         val bolt11 = "lnbcrt1pending"