fix: expire stale LNbits pending invoices

Author: kanishka0411

.changeset/expire-stale-lnbits-invoices.md

@@ -0,0 +1,5 @@
+---
+'nostream': patch
+---
+
+Expire stale pending invoices when LNbits no longer has the invoice or reports it as unpaid past its expiry time.

src/app/maintenance-worker.ts

@@ -21,6 +21,11 @@ const CLEAR_OLD_EVENTS_TIMEOUT_MS = 5000
 
 const logger = createLogger('maintenance-worker')
 
+const isNotFoundError = (error: unknown): boolean => (error as any)?.response?.status === 404
+
+const isExpiredInvoice = (invoice: { expiresAt?: Date | null }): boolean =>
+  invoice.expiresAt instanceof Date && invoice.expiresAt.getTime() <= Date.now()
+
 /**
  * Merge a re-verification outcome onto an existing verification row.
  *
@@ -168,6 +173,16 @@ export class MaintenanceWorker implements IRunnable {
         }
         successful++
       } catch (error) {
+        if (isNotFoundError(error) && isExpiredInvoice(invoice)) {
+          logger('marking expired invoice %s after payment processor returned 404', invoice.id)
+          await this.paymentsService.updateInvoiceStatus({
+            id: invoice.id,
+            status: InvoiceStatus.EXPIRED,
+          })
+          successful++
+          continue
+        }
+
         logger.error('Unable to update invoice from payment processor. Reason:', error)
       }
 

src/payments-processors/lnbits-payment-processor.ts

@@ -53,6 +53,7 @@ export class LNbitsPaymentsProcessor implements IPaymentsProcessor {
       })
       const invoice = new LNbitsInvoice()
       const data = response.data
+      const expiresAt = new Date(data.details.expiry * 1000)
       invoice.id = data.details.payment_hash
       invoice.pubkey = data.details.extra.internalId
       invoice.bolt11 = data.details.bolt11
@@ -61,10 +62,16 @@ export class LNbitsPaymentsProcessor implements IPaymentsProcessor {
         invoice.amountPaid = BigInt(Math.floor(data.details.amount / 1000))
       }
       invoice.unit = InvoiceUnit.SATS
-      invoice.status = data.paid ? InvoiceStatus.COMPLETED : InvoiceStatus.PENDING
+      if (data.paid) {
+        invoice.status = InvoiceStatus.COMPLETED
+      } else if (expiresAt.getTime() <= Date.now()) {
+        invoice.status = InvoiceStatus.EXPIRED
+      } else {
+        invoice.status = InvoiceStatus.PENDING
+      }
       invoice.description = data.details.memo
       invoice.confirmedAt = data.paid ? new Date(data.details.time * 1000) : null
-      invoice.expiresAt = new Date(data.details.expiry * 1000)
+      invoice.expiresAt = expiresAt
       invoice.createdAt = new Date(data.details.time * 1000)
       invoice.updatedAt = new Date()
       return invoice

test/unit/app/maintenance-worker.spec.ts

@@ -440,6 +440,53 @@ describe('MaintenanceWorker', () => {
       expect(maintenanceService.clearOldEvents).to.have.been.calledOnce
       expect(paymentsService.updateInvoiceStatus).to.have.been.calledOnce
     })
+
+    it('marks an expired pending invoice as expired when the payment processor returns 404', async () => {
+      const expiredInvoice = {
+        ...pendingInvoice,
+        expiresAt: new Date(Date.now() - 60000),
+      }
+      const notFoundError = {
+        response: { status: 404 },
+      }
+      settingsState.payments = { enabled: true } as any
+      paymentsService.getPendingInvoices.resolves([expiredInvoice])
+      paymentsService.getInvoiceFromPaymentsProcessor.rejects(notFoundError)
+
+      await (worker as any).onSchedule()
+
+      expect(paymentsService.updateInvoiceStatus).to.have.been.calledOnceWithExactly({
+        id: expiredInvoice.id,
+        status: InvoiceStatus.EXPIRED,
+      })
+    })
+
+    it('keeps an expired pending invoice pending when the processor lookup fails without 404', async () => {
+      const expiredInvoice = {
+        ...pendingInvoice,
+        expiresAt: new Date(Date.now() - 60000),
+      }
+      settingsState.payments = { enabled: true } as any
+      paymentsService.getPendingInvoices.resolves([expiredInvoice])
+      paymentsService.getInvoiceFromPaymentsProcessor.rejects(new Error('network error'))
+
+      await (worker as any).onSchedule()
+
+      expect(paymentsService.updateInvoiceStatus).not.to.have.been.called
+    })
+
+    it('keeps a non-expired pending invoice pending when the processor returns 404', async () => {
+      const notFoundError = {
+        response: { status: 404 },
+      }
+      settingsState.payments = { enabled: true } as any
+      paymentsService.getPendingInvoices.resolves([pendingInvoice])
+      paymentsService.getInvoiceFromPaymentsProcessor.rejects(notFoundError)
+
+      await (worker as any).onSchedule()
+
+      expect(paymentsService.updateInvoiceStatus).not.to.have.been.called
+    })
   })
 
   describe('onError', () => {

test/unit/payments-processors/lnbits-payment-processor.spec.ts

@@ -0,0 +1,85 @@
+import chai from 'chai'
+import sinon from 'sinon'
+import sinonChai from 'sinon-chai'
+
+import { InvoiceStatus, InvoiceUnit } from '../../../src/@types/invoice'
+import { LNbitsPaymentsProcessor } from '../../../src/payments-processors/lnbits-payment-processor'
+
+chai.use(sinonChai)
+
+const { expect } = chai
+
+const invoiceResponse = (overrides: any = {}) => ({
+  data: {
+    paid: false,
+    details: {
+      payment_hash: 'lnbits-payment-hash',
+      extra: {
+        internalId: 'a'.repeat(64),
+      },
+      bolt11: 'lnbc1test',
+      amount: 42000,
+      memo: 'LNbits test invoice',
+      time: Math.floor(Date.now() / 1000),
+      expiry: Math.floor((Date.now() + 600000) / 1000),
+      ...overrides.details,
+    },
+    ...overrides.data,
+  },
+})
+
+describe('LNbitsPaymentsProcessor', () => {
+  const makeProcessor = (response: any) => {
+    const httpClient = {
+      get: sinon.stub().resolves(response),
+    }
+
+    return {
+      processor: new LNbitsPaymentsProcessor(httpClient as any, (() => ({})) as any),
+      httpClient,
+    }
+  }
+
+  describe('getInvoice', () => {
+    it('returns PENDING for unpaid invoices that have not expired', async () => {
+      const { processor } = makeProcessor(invoiceResponse())
+
+      const invoice = await processor.getInvoice('lnbits-payment-hash')
+
+      expect(invoice.status).to.equal(InvoiceStatus.PENDING)
+      expect(invoice.unit).to.equal(InvoiceUnit.SATS)
+    })
+
+    it('returns EXPIRED for unpaid invoices past their LNbits expiry time', async () => {
+      const { processor } = makeProcessor(
+        invoiceResponse({
+          details: {
+            expiry: Math.floor((Date.now() - 60000) / 1000),
+          },
+        }),
+      )
+
+      const invoice = await processor.getInvoice('lnbits-payment-hash')
+
+      expect(invoice.status).to.equal(InvoiceStatus.EXPIRED)
+    })
+
+    it('keeps paid invoices COMPLETED even if the expiry time has passed', async () => {
+      const { processor } = makeProcessor(
+        invoiceResponse({
+          data: {
+            paid: true,
+          },
+          details: {
+            expiry: Math.floor((Date.now() - 60000) / 1000),
+          },
+        }),
+      )
+
+      const invoice = await processor.getInvoice('lnbits-payment-hash')
+
+      expect(invoice.status).to.equal(InvoiceStatus.COMPLETED)
+      expect(invoice.amountPaid).to.equal(42n)
+    })
+  })
+})