fix(lightning): never report a slow in-flight payment as failed

Slow multi-hop payments (>15s routing) surfaced as "Payment failed"
while LND settled them in the background: the shared LND REST client's
15s total timeout aborted the synchronous /v1/channels/transactions
wait, and every UI path treated that abort as a definitive failure. The
payment then succeeded anyway and only appeared in history on the next
background poll.

Backend: lnd.payinvoice now decodes the invoice up front for its payment
hash, pays on a dedicated 120s client, and answers status:"pending" with
the hash (never an error) when the wait elapses after the payment was
handed to LND — only a pre-connect failure is still a hard error. New
lnd.paymentstatus RPC reports succeeded/failed/in_flight (with humanized
failure reasons) from /v1/payments.

Frontend: new rpcClient.payLightningInvoice() pays then polls
lnd.paymentstatus to a real terminal state (3s interval, up to 2 min);
all five call sites (send modal, scan modal, web5 unified send, peer-file
purchase, app-launcher payments) migrated. Failure is only shown when LND
itself declares FAILED; a still-settling payment shows an in-flight state
and success fires the transaction refresh.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

neode-ui/src/components/AppLauncherOverlay.vue

@@ -525,10 +525,10 @@ async function approvePayment() {
       receipt = { method: 'ecash', token: res.token, amount_sats: res.amount_sats }
     } else if (method === 'lightning') {
       if (pay.invoice) {
-        const res = await rpcClient.call<{ payment_hash: string; amount_sats: number }>({
-          method: 'lnd.payinvoice',
-          params: { payment_request: pay.invoice },
-        })
+        // Tracked to a real terminal state — slow routing is not a failure.
+        const res = await rpcClient.payLightningInvoice({ payment_request: pay.invoice })
+        if (res.status === 'failed') throw new Error(res.failure_reason || 'Payment failed')
+        if (res.status === 'pending') throw new Error('Payment is still settling — check your wallet transactions before retrying.')
         receipt = { method: 'lightning', payment_hash: res.payment_hash, amount_sats: res.amount_sats }
       } else {
         // Create and immediately return an invoice for the requester to display

neode-ui/src/components/SendBitcoinModal.vue

@@ -620,11 +620,21 @@ async function send() {
       ecashToken.value = res.token
     } else if (method === 'lightning') {
       if (!dest.value.trim()) { error.value = t('web5.pasteInvoice'); return }
-      const res = await rpcClient.call<{ payment_hash: string }>({
-        method: 'lnd.payinvoice',
-        params: { payment_request: dest.value.trim() },
-      })
-      successInfo.value = { amount: paidAmount, methodLabel: 'Paid over Lightning', hash: res.payment_hash }
+      // Waits out slow multi-hop routing and only reports failure when LND
+      // itself declares the payment failed — never on a timeout.
+      const res = await rpcClient.payLightningInvoice({ payment_request: dest.value.trim() })
+      if (res.status === 'failed') {
+        error.value = res.failure_reason || t('web5.sendFailed')
+        return
+      }
+      successInfo.value = {
+        amount: paidAmount,
+        methodLabel: res.status === 'pending' ? 'Payment in flight' : 'Paid over Lightning',
+        hash: res.payment_hash || undefined,
+        ...(res.status === 'pending'
+          ? { note: 'This payment is taking longer than usual to settle. It will appear in your transactions once it completes.' }
+          : {}),
+      }
     } else {
       if (!dest.value.trim()) { error.value = t('web5.enterBitcoinAddress'); return }
       const res = await rpcClient.call<{ txid: string }>({

neode-ui/src/components/WalletScanModal.vue

@@ -701,16 +701,17 @@ async function confirmSend() {
   error.value = ''
   try {
     if (action.value === 'pay-invoice') {
-      const params: Record<string, unknown> = { payment_request: dest.value }
+      const params: { payment_request: string; amount_sats?: number } = { payment_request: dest.value }
       if (!amountLocked.value && effectiveAmount.value > 0) params.amount_sats = effectiveAmount.value
-      const res = await rpcClient.call<{ payment_hash: string; amount_sats: number }>({
-        method: 'lnd.payinvoice',
-        params,
-        timeout: 60000,
-      })
+      // Waits out slow multi-hop routing and only reports failure when LND
+      // itself declares the payment failed — never on a timeout.
+      const res = await rpcClient.payLightningInvoice(params)
+      if (res.status === 'failed') throw new Error(res.failure_reason || 'Payment failed')
       successAmount.value = res.amount_sats || effectiveAmount.value
-      successVerb.value = 'PAID'
-      successDetail.value = 'Lightning invoice paid'
+      successVerb.value = res.status === 'pending' ? 'SENDING' : 'PAID'
+      successDetail.value = res.status === 'pending'
+        ? 'Payment in flight — it will appear in your transactions once it settles'
+        : 'Lightning invoice paid'
       successRef.value = res.payment_hash
     } else if (action.value === 'send-onchain') {
       const res = await rpcClient.call<{ txid: string }>({