bitspire/apps/machine/electron/lnurl-withdraw.test.ts

import { describe, it, expect, vi } from 'vitest'
import { executeLnurlWithdraw, executeWithdrawCallback, lnurlwToHttps } from './lnurl-withdraw'

const BOLT11 = 'lnbc10u1p3xyz...'
const LNURLW =
  'lnurlw://lnbits.l484.com/boltcards/api/v1/scan/abc123?p=DEADBEEFDEADBEEFDEADBEEFDEADBEEF&c=1122334455667788'

/** Build a mock fetch that returns the given JSON bodies per call, in order. */
function mockFetch(bodies: unknown[]) {
  const calls: string[] = []
  const impl = vi.fn(async (url: string | URL) => {
    calls.push(url.toString())
    const body = bodies[calls.length - 1]
    return { json: async () => body } as Response
  })
  return { impl: impl as unknown as typeof fetch, calls }
}

describe('lnurlwToHttps', () => {
  it('maps lnurlw:// and lnurl:// to https://', () => {
    expect(lnurlwToHttps('lnurlw://host/p?x=1')).toBe('https://host/p?x=1')
    expect(lnurlwToHttps('lnurl://host/p')).toBe('https://host/p')
  })
  it('strips a lightning: prefix', () => {
    expect(lnurlwToHttps('lightning:lnurlw://host/p')).toBe('https://host/p')
  })
  it('passes https:// through and trims', () => {
    expect(lnurlwToHttps('  https://host/p  ')).toBe('https://host/p')
  })
  it('rejects http://, bech32 lnurl1…, and empty', () => {
    expect(lnurlwToHttps('http://host/p')).toBeNull()
    expect(lnurlwToHttps('LNURL1DP68GURN8GHJ7')).toBeNull()
    expect(lnurlwToHttps('')).toBeNull()
  })
})

describe('executeLnurlWithdraw', () => {
  const withdrawReq = {
    tag: 'withdrawRequest',
    callback: 'https://lnbits.l484.com/boltcards/api/v1/scan/cb',
    k1: 'K1TOKEN',
    minWithdrawable: 1000,
    maxWithdrawable: 5_000_000,
  }

  it('completes the two-step withdraw and passes k1 + pr to the callback', async () => {
    const { impl, calls } = mockFetch([withdrawReq, { status: 'OK' }])
    const res = await executeLnurlWithdraw(LNURLW, BOLT11, { fetchImpl: impl })
    expect(res).toEqual({ ok: true })
    // First call = the lnurlw as https; second = callback with k1 + pr.
    expect(calls[0]).toContain('https://lnbits.l484.com/boltcards/api/v1/scan/abc123')
    expect(calls[1]).toContain('k1=K1TOKEN')
    expect(calls[1]).toContain(`pr=${encodeURIComponent(BOLT11)}`)
  })

  it('rejects a non-lnurlw tag', async () => {
    const { impl } = mockFetch([])
    const res = await executeLnurlWithdraw('http://nope', BOLT11, { fetchImpl: impl })
    expect(res.ok).toBe(false)
    expect(res.reason).toMatch(/not a valid Bolt Card/i)
  })

  it('rejects when there is no invoice', async () => {
    const { impl } = mockFetch([])
    const res = await executeLnurlWithdraw(LNURLW, '', { fetchImpl: impl })
    expect(res).toMatchObject({ ok: false, reason: 'no invoice to charge' })
  })

  it('surfaces an ERROR from the withdraw request', async () => {
    const { impl } = mockFetch([{ status: 'ERROR', reason: 'spent today limit' }])
    const res = await executeLnurlWithdraw(LNURLW, BOLT11, { fetchImpl: impl })
    expect(res).toMatchObject({ ok: false, reason: 'spent today limit' })
  })

  it('rejects a response that is not a withdrawRequest', async () => {
    const { impl } = mockFetch([{ tag: 'payRequest', callback: 'x' }])
    const res = await executeLnurlWithdraw(LNURLW, BOLT11, { fetchImpl: impl })
    expect(res).toMatchObject({ ok: false })
    expect(res.reason).toMatch(/withdraw voucher/i)
  })

  it('rejects (without calling the callback) when the amount exceeds the card limit', async () => {
    const { impl, calls } = mockFetch([{ ...withdrawReq, maxWithdrawable: 2000 }])
    const res = await executeLnurlWithdraw(LNURLW, BOLT11, { fetchImpl: impl, amountMsat: 5000 })
    expect(res).toMatchObject({ ok: false, reason: 'card limit is below this amount' })
    expect(calls).toHaveLength(1) // callback never hit
  })

  it('surfaces an ERROR from the callback (card declined)', async () => {
    const { impl } = mockFetch([withdrawReq, { status: 'ERROR', reason: 'insufficient funds' }])
    const res = await executeLnurlWithdraw(LNURLW, BOLT11, { fetchImpl: impl })
    expect(res).toMatchObject({ ok: false, reason: 'insufficient funds' })
  })

  it('handles a network failure gracefully', async () => {
    const impl = vi.fn(async () => {
      throw new Error('ECONNREFUSED')
    }) as unknown as typeof fetch
    const res = await executeLnurlWithdraw(LNURLW, BOLT11, { fetchImpl: impl })
    expect(res.ok).toBe(false)
    expect(res.reason).toMatch(/could not reach the card/i)
  })
})

describe('executeWithdrawCallback (session second step, no tap)', () => {
  const step = {
    callback: 'https://lnbits.l484.com/boltcards/api/v1/lnurl/cb/hit1',
    k1: 'hit1',
    maxWithdrawable: 5_000_000,
  }

  it('hands the invoice straight to the callback with k1', async () => {
    const f = mockFetch([{ status: 'OK' }])
    const out = await executeWithdrawCallback(step, BOLT11, { fetchImpl: f.impl })
    expect(out).toEqual({ ok: true })
    expect(f.calls).toHaveLength(1)
    expect(f.calls[0]).toContain('k1=hit1')
    expect(f.calls[0]).toContain('pr=' + BOLT11)
  })

  it('refuses an amount above the step limit without calling out', async () => {
    const f = mockFetch([])
    const out = await executeWithdrawCallback(step, BOLT11, {
      fetchImpl: f.impl,
      amountMsat: 6_000_000,
    })
    expect(out).toEqual({ ok: false, reason: 'card limit is below this amount' })
    expect(f.calls).toHaveLength(0)
  })

  it('surfaces a callback decline', async () => {
    const f = mockFetch([{ status: 'ERROR', reason: 'Payment already claimed.' }])
    const out = await executeWithdrawCallback(step, BOLT11, { fetchImpl: f.impl })
    expect(out).toEqual({ ok: false, reason: 'Payment already claimed.' })
  })

  it('rejects a missing invoice', async () => {
    const f = mockFetch([])
    expect(await executeWithdrawCallback(step, '', { fetchImpl: f.impl })).toEqual({
      ok: false,
      reason: 'no invoice to charge',
    })
  })
})