1 files changed, 124 insertions, 4 deletions

diff --git a/tools/nwc-sw-test.js b/tools/nwc-sw-test.js
index e3bdb7b..816b9ce 100644
--- a/tools/nwc-sw-test.js
+++ b/tools/nwc-sw-test.js
@@ -5,7 +5,8 @@ import { hex } from '@scure/base';
 import * as nip04 from 'nostr-tools/nip04';
 import * as nip44 from 'nostr-tools/nip44';
 import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure';
-import { respondFromBg } from '../src/nwc-respond.js';
+import { respondFromBg, tendLnPays } from '../src/nwc-respond.js';
+import { maybeBolt11 } from '../src/ark/lightning.js';
 
 let fails = 0;
 const check = (name, ok, detail = '') => {
@@ -178,6 +179,112 @@ const INV21 = 'lnbc210n1p4xuk2wpp506wkjr0xk3677nu7je9c55vq4lzlkyd0ztcq2mlvumap0z
   check('exhausted key window → wake the user', handled === false);
 }
 
+console.log('\n[pay outcome]');
+{
+  // a payment that goes through: the worker hands the push handler a
+  // "Payment sent" heads-up (unless the user turned those off)
+  const { ArkManager } = await import('../src/ark/manager.js');
+  const orig = { init: ArkManager.prototype.init, pay: ArkManager.prototype.payLnInvoice, wait: ArkManager.prototype.awaitLnPay, act: ArkManager.prototype.lnAction };
+  const done = { id: 'ln-1', step: 'done', amountSat: 21, feeSat: 0, preimage: 'ab'.repeat(32) };
+  ArkManager.prototype.init = async function () { this.state = this.storage.load(); return this; };
+  ArkManager.prototype.payLnInvoice = async () => 'ln-1';
+  ArkManager.prototype.awaitLnPay = async () => done;
+  ArkManager.prototype.lnAction = () => done;
+  try {
+    const { deps, published, decryptReply } = harness();
+    const handled = await respondFromBg({ type: 'nwc', event: ev(makeReq('pay_invoice', { invoice: INV21 })) }, deps);
+    check('a paid invoice answers with the preimage', published.length === 1 && decryptReply(published[0]).result?.preimage === done.preimage, JSON.stringify(handled));
+    check('…and asks for a "Payment sent" notification', handled && handled.notify && handled.notify.title === 'Payment sent', JSON.stringify(handled));
+    const rec = baseRec(); rec.prefs = { paySent: false };
+    const h2 = harness({ rec });
+    const quiet = await respondFromBg({ type: 'nwc', event: ev(makeReq('pay_invoice', { invoice: INV21 })) }, h2.deps);
+    check('payments-sent notifications off → paid quietly', quiet === true && h2.published.length === 1);
+  } finally {
+    Object.assign(ArkManager.prototype, { init: orig.init, payLnInvoice: orig.pay, awaitLnPay: orig.wait, lnAction: orig.act });
+  }
+}
+
+console.log('\n[sends begun on an earlier wake]');
+// The worker died mid-payment on an earlier wake: the action sits in the
+// mirror at 'created' with its coin reserved (PullCap, 2026-10-23).
+{
+  const { ArkManager } = await import('../src/ark/manager.js');
+  const HASH = maybeBolt11(INV21).paymentHash;
+  const PRE = 'cd'.repeat(32);
+  const names = ['init', 'payLnInvoice', 'awaitLnPay', 'lnAction', 'driveLn'];
+  const orig = Object.fromEntries(names.map((k) => [k, ArkManager.prototype[k]]));
+  ArkManager.prototype.init = async function () { this.state = this.storage.load(); return this; };
+  // a fresh attempt at an invoice with an action on the books is refused…
+  ArkManager.prototype.payLnInvoice = async function (invoice) {
+    const hash = maybeBolt11(invoice).paymentHash;
+    if (this.state.actions.some((a) => a.type === 'ln-pay' && a.paymentHash === hash && a.step !== 'failed')) throw new Error('a payment for this invoice is already in progress');
+    const a = { id: 'lnpay-new', type: 'ln-pay', step: 'done', invoice, paymentHash: hash, amountSat: 21, feeSat: 0, preimage: 'ab'.repeat(32) };
+    this.state.actions.push(a); this.storage.save(this.state);
+    return a.id;
+  };
+  // …and a drive takes the stuck one through to done, freeing its change
+  ArkManager.prototype.awaitLnPay = async function (id) { return this.driveLn(id); };
+  ArkManager.prototype.driveLn = async function (id) {
+    const a = this.state.actions.find((x) => x.id === id);
+    if (a && a.step !== 'done') {
+      a.step = 'done'; a.preimage = PRE;
+      for (const v of this.state.vtxos) if (v.state === 'pending') v.state = 'spendable';
+      this.storage.save(this.state);
+    }
+    return a;
+  };
+  ArkManager.prototype.lnAction = function (id) { return this.state.actions.find((x) => x.id === id); };
+  const stuckRec = (hash) => {
+    const rec = baseRec();
+    rec.mgr.vtxos[0].state = 'pending';
+    rec.mgr.actions.push({ id: 'lnpay-stuck', type: 'ln-pay', step: 'created', invoice: INV21, paymentHash: hash, amountSat: 21, feeSat: 0 });
+    rec.pendingPays = [{ hash, connId: 'c1', ts: 1 }];
+    return rec;
+  };
+  try {
+    {
+      // the SAME invoice asked again: finish that send, answer with ITS preimage
+      const rec = stuckRec(HASH);
+      const log = [];
+      const { deps, published, decryptReply } = harness({ rec });
+      const handled = await respondFromBg({ type: 'nwc', event: ev(makeReq('pay_invoice', { invoice: INV21 })) }, { ...deps, log: (m) => log.push(m) });
+      check('same invoice → the stuck send is finished and answered with its preimage', published.length === 1 && decryptReply(published[0]).result?.preimage === PRE, JSON.stringify(handled));
+      check('…recorded once on the spend log, under its connection', rec.spends.length === 1 && rec.spends[0].connId === 'c1' && rec.spends[0].preimage === PRE && rec.pendingPays.length === 0, JSON.stringify(rec.spends));
+      check('…with a "Payment sent" heads-up', handled && handled.notify && handled.notify.title === 'Payment sent');
+      check('…and the diary names the step it reached', log.some((m) => /already created/.test(m)) && log.some((m) => /→ done/.test(m)), log.join(' | '));
+    }
+    {
+      // a send that settled earlier (in the app, say): its preimage again,
+      // nothing new on the spend log
+      const rec = baseRec();
+      rec.mgr.actions.push({ id: 'lnpay-old', type: 'ln-pay', step: 'done', invoice: INV21, paymentHash: HASH, amountSat: 21, feeSat: 0, preimage: PRE });
+      const { deps, published, decryptReply } = harness({ rec });
+      await respondFromBg({ type: 'nwc', event: ev(makeReq('pay_invoice', { invoice: INV21 })) }, deps);
+      check('an invoice paid earlier answers with the same preimage', published.length === 1 && decryptReply(published[0]).result?.preimage === PRE);
+      check('…without a second spend', (rec.spends || []).length === 0);
+    }
+    {
+      // a stuck send for ANOTHER invoice holds the only coin: finish it first,
+      // then pay the new request from the freed coin
+      const rec = stuckRec('ee'.repeat(32));
+      const { deps, published, decryptReply } = harness({ rec });
+      const handled = await respondFromBg({ type: 'nwc', event: ev(makeReq('pay_invoice', { invoice: INV21 })) }, deps);
+      check('another invoice → the earlier send is finished, then this one paid', published.length === 1 && decryptReply(published[0]).result?.preimage === 'ab'.repeat(32), JSON.stringify(handled));
+      check('…both on the spend log', rec.spends.length === 2 && rec.spends[0].preimage === PRE && rec.spends[1].preimage === 'ab'.repeat(32));
+      check('…the earlier one gets its own "Payment sent" line', handled && handled.notices && handled.notices.length === 1 && handled.notify && handled.notify.title === 'Payment sent', JSON.stringify(handled));
+    }
+    {
+      // any wake at all finishes it (a lookup, a push for something else)
+      const rec = stuckRec(HASH);
+      const notices = await tendLnPays({ recordsFn: async () => [{ walletKey: 'w1', rec }], saveFn: async () => {} });
+      check('tendLnPays finishes a stuck send and reports it', notices.length === 1 && notices[0].title === 'Payment sent' && rec.spends.length === 1 && rec.spends[0].connId === 'c1', JSON.stringify(notices));
+      check('…and a second wake has nothing left to do', (await tendLnPays({ recordsFn: async () => [{ walletKey: 'w1', rec }], saveFn: async () => {} })).length === 0);
+    }
+  } finally {
+    Object.assign(ArkManager.prototype, orig);
+  }
+}
+
 console.log('\n[network fit]');
 {
   // a mutinynet-era mirror must not answer a mainnet invoice with a nonsense
@@ -332,16 +439,17 @@ console.log('\n[tending renewals while closed]');
     if (ran) (this.state.actions ||= []).push({ id: 'r1', type: 'refresh', step: 'submitted', unlockHash: ran.unlockHash });
   };
   ArkManager.prototype._driveRefresh = async function (a) { calls.push(['claim', a.id, a.step]); a.step = 'done'; };
-  ArkManager.prototype.ensureScheduledRefreshes = async function (margin, max) { calls.push(['ensure', margin, max]); return 1; };
+  ArkManager.prototype.ensureScheduledRefreshes = async function (margin, max, grid) { calls.push(['ensure', margin, max, grid]); return 1; };
   try {
     const rec = baseRec();
     rec.key4 = 'ff'.repeat(32);
+    rec.custody = 'self'; // a renewing tier: the worker covers bare coins
     rec.mgr.nextKeyIndex = 5;
     rec.keys = { 1: 'aa', 5: 'bb', 6: 'cc' }; // two upcoming indices in the window
     rec.mgr.scheduled = [{ unlockHash: 'ran', inputIds: ['v1'], outKeyIndex: 2 }, { unlockHash: 'waiting', inputIds: ['v1'], outKeyIndex: 3 }];
     const saved = [];
     const n = await tendRenewals({ recordsFn: async () => [{ walletKey: 'w1', rec }], saveFn: async (k, r) => saved.push(k), log: () => {} });
-    check('claims what ran, then covers what is bare: orders limited to the key window', JSON.stringify(calls) === JSON.stringify([['init', 'mainnet'], ['tip'], ['drive', 2], ['claim', 'r1', 'submitted'], ['ensure', 36, 2]]), JSON.stringify(calls));
+    check('claims what ran, then covers what is bare: orders limited to the key window, snapped to the 48-block grid', JSON.stringify(calls) === JSON.stringify([['init', 'mainnet'], ['tip'], ['drive', 2], ['claim', 'r1', 'submitted'], ['ensure', 36, 2, 48]]), JSON.stringify(calls));
     check('one claim and one order counted, the record saved', n === 2 && saved.includes('w1'));
     check('the claimed order is gone from the mirror, its claim done', rec.mgr.scheduled.length === 1 && rec.mgr.scheduled[0].unlockHash === 'waiting' && rec.mgr.actions[0].step === 'done');
     // a claim left in flight by an earlier wake (out of time, unconfirmed) is driven on by the next
@@ -351,8 +459,20 @@ console.log('\n[tending renewals while closed]');
     const n5 = await tendRenewals({ recordsFn: async () => [{ walletKey: 'w5', rec: rec5 }], saveFn: async () => {} });
     check('a renewal claim in flight is driven on; finished ones and other actions are not', JSON.stringify(calls) === JSON.stringify([['init', 'mainnet'], ['tip'], ['drive', 0], ['claim', 'r2', 'issued']]) && n5 === 1, JSON.stringify(calls));
 
+    // the default tier — coinos holds the coins — registers no order at all,
+    // however many keys the window holds (the claim of an order that already
+    // ran still happens: it was priced and promised when registered)
+    calls.length = 0;
+    const rec6 = baseRec(); rec6.key4 = 'ff'.repeat(32); rec6.mgr.nextKeyIndex = 5; rec6.keys = { 1: 'aa', 5: 'bb', 6: 'cc' };
+    await tendRenewals({ recordsFn: async () => [{ walletKey: 'w6', rec: rec6 }], saveFn: async () => {} });
+    check('custodial (default, or a mirror without the field) → claims only, no orders', JSON.stringify(calls) === JSON.stringify([['init', 'mainnet'], ['tip'], ['drive', 0]]), JSON.stringify(calls));
+    calls.length = 0;
+    const rec7 = baseRec(); rec7.key4 = 'ff'.repeat(32); rec7.custody = 'exit'; rec7.mgr.nextKeyIndex = 5; rec7.keys = { 1: 'aa', 5: 'bb' };
+    await tendRenewals({ recordsFn: async () => [{ walletKey: 'w7', rec: rec7 }], saveFn: async () => {} });
+    check('exit tier → the same backstop as self (depth is the app\'s business)', JSON.stringify(calls) === JSON.stringify([['init', 'mainnet'], ['tip'], ['drive', 0], ['ensure', 36, 1, 48]]), JSON.stringify(calls));
+
     calls.length = 0;
-    const rec2 = baseRec(); rec2.key4 = 'ff'.repeat(32); rec2.ark.network = 'regtest'; rec2.mgr.nextKeyIndex = 9; rec2.keys = { 1: 'aa' }; // no upcoming key
+    const rec2 = baseRec(); rec2.key4 = 'ff'.repeat(32); rec2.custody = 'self'; rec2.ark.network = 'regtest'; rec2.mgr.nextKeyIndex = 9; rec2.keys = { 1: 'aa' }; // no upcoming key
     await tendRenewals({ recordsFn: async () => [{ walletKey: 'w2', rec: rec2 }], saveFn: async () => {} });
     check('no key for an order\'s output → claims still, registers nothing (regtest margin would be 6)', JSON.stringify(calls) === JSON.stringify([['init', 'regtest'], ['tip'], ['drive', 0]]), JSON.stringify(calls));