feat(nwc): make_invoice against mints with wallet-named outputs

The named-mint branch claims by the wallet's secret and treats the verify
preimage as an ordinary payment receipt - but keeps the rotated guard
before handing it out, because the rescue path (a mint that credited the
preimage despite the binding) claims through claimFromPreimage, where a
failed rotate leaves that preimage a live note secret. possibleCopy is
committed exactly like the unnamed path.

src/lnurlcash/nwc/invoices.ts

@@ -1,15 +1,18 @@
 // The invoice registry the two-phase make_invoice / lookup_invoice pair
 // shares: make_invoice answers with the invoice immediately while this
 // module's settleAndClaim watches settlement in the background, claims
-// the minted note (rotating it immediately), and only THEN records the
-// settlement the lookup reports.
+// the minted note, and only THEN records the settlement the lookup
+// reports.
 //
-// THE PREIMAGE, in lnurlcash terms: the payment preimage IS the minted
-// note's initial secret. NIP-47 clients expect it as the settlement
-// receipt, so it is handed out - but only after claimFromPreimage has
-// rotated the fresh note, when that secret is burned and worthless. If
-// the rotation failed (claimed.rotated === false) the preimage is
-// withheld: fund safety over spec comfort.
+// THE PREIMAGE, in lnurlcash terms: on an UNNAMED mint the payment
+// preimage IS the minted note's initial secret. NIP-47 clients expect it
+// as the settlement receipt, so it is handed out - but only after
+// claimFromPreimage has rotated the fresh note, when that secret is
+// burned and worthless. If the rotation failed (claimed.rotated ===
+// false) the preimage is withheld: fund safety over spec comfort. On a
+// NAMED mint the note lives at a wallet-chosen secret from the start and
+// the preimage opens nothing at all, so it is an ordinary payment receipt
+// and always safe to hand out.
 
 import {isPreimage, sameInvoice} from 'lnurlcash-kit'
 import {sha256} from '@noble/hashes/sha2.js'
@@ -17,7 +20,7 @@ import {bytesToHex, utf8ToBytes} from '@noble/hashes/utils.js'
 
 import type {NewBearer} from '../types'
 import type {PreparedMint} from '../ops'
-import {claimFromPreimage} from '../ops/mint'
+import {claimFromPreimage, claimFromSecret} from '../ops/mint'
 import {pollVerifyUntilSettled} from '../ops/shared'
 import type {PollOptions} from '../ops/shared'
 
@@ -61,13 +64,14 @@ export const invoiceResult = (entry: PendingInvoice): Record<string, unknown> =>
 }
 
 // the background half of make_invoice: watch the invoice, and once it
-// settles claim the note (rotating it immediately) and hand the fresh
-// bearer to the caller. Settlement is recorded LAST - after the rotate and
-// bearer commit - so lookup can only reveal durably tracked funds and an
-// already-burned secret.
+// settles claim the note (rotating it immediately on an unnamed mint) and
+// hand the fresh bearer to the caller. Settlement is recorded LAST - after
+// the claim and bearer commit - so lookup can only reveal durably tracked
+// funds and, on an unnamed mint, an already-burned secret.
 // Throws on any failure; the caller marks the entry failed and reports
 // through deps.onError.
 export const settleAndClaim = async (ctx: RequestContext, entry: PendingInvoice): Promise<void> => {
+  if (entry.prepared.mode === 'named') return settleAndClaimNamed(ctx, entry)
   if (!entry.prepared.verifyUrl) {
     throw new Error(
       'This mint did not advertise a verify URL - the invoice cannot be auto-claimed.',
@@ -114,3 +118,61 @@ export const settleAndClaim = async (ctx: RequestContext, entry: PendingInvoice)
     entry.preimage = preimage
   }
 }
+
+// the named-mint half of settleAndClaim: the note lands at the wallet's
+// own secret, so its APPEARANCE there is the settlement observation and no
+// rotate follows. When the mint also serves the quote's verify, that
+// answer's preimage is kept as the NIP-47 receipt (an ordinary payment
+// proof on a named mint); a named mint without verify yields a settled
+// lookup with no preimage - correct, just receipt-less.
+const settleAndClaimNamed = async (
+  ctx: RequestContext,
+  entry: PendingInvoice,
+): Promise<void> => {
+  const noteSecret = entry.prepared.noteSecret
+  if (!noteSecret) {
+    throw new Error('This mint was prepared in named mode without a note secret.')
+  }
+  const prepared = entry.prepared
+  const claimPoll = ctx.deps.claimPoll ?? DEFAULT_CLAIM_POLL
+  let preimage: string | null = null
+  if (prepared.verifyUrl) {
+    // the interruptible observation half: watch settlement on verify,
+    // then claim by secret below (fund-critical, uninterruptible)
+    const result = await pollVerifyUntilSettled(
+      prepared.verifyUrl,
+      {...claimPoll, signal: ctx.stopSignal},
+      ctx.deps.kit ?? {},
+    )
+    if (!sameInvoice(result.pr, prepared.invoice)) {
+      throw new Error("The service's verify response is for a different invoice than requested.")
+    }
+    if (result.preimage && isPreimage(result.preimage)) preimage = result.preimage
+  }
+  // without a verify URL the claim poll IS the observation half, so it
+  // stays interruptible; after a verify-observed settlement the note is
+  // already there and this returns on the first check
+  const claimed = await claimFromSecret(
+    {...prepared, noteSecret},
+    prepared.verifyUrl ? claimPoll : {...claimPoll, signal: ctx.stopSignal},
+    {
+      ...(ctx.deps.kit ?? {}),
+      assertOwner: ctx.assertOwner,
+    },
+  )
+  const add: NewBearer[] = [claimed.note]
+  if (claimed.possibleCopy) add.push(claimed.possibleCopy)
+  await ctx.deps.applyChangeset(
+    {add, markSpent: []},
+    ctx.connection(),
+    'make_invoice',
+    ctx.assertOwner,
+  )
+  entry.settledAt = ctx.nowSeconds()
+  entry.state = 'settled'
+  // the rotate guard still matters here: the rescue path (a mint that
+  // took the hash but credited the PREIMAGE) claims through
+  // claimFromPreimage, and if its rotate failed the preimage is still a
+  // LIVE note secret - withheld exactly like the unnamed path
+  if (preimage && claimed.rotated) entry.preimage = preimage
+}