lib/countries.ts


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248

export default {
  AF: "AFN",
  AL: "ALL",
  DZ: "DZD",
  AD: "EUR",
  AO: "AOA",
  AI: "XCD",
  AQ: "USD",
  AR: "ARS",
  AM: "AMD",
  AW: "AWG",
  AU: "AUD",
  AT: "EUR",
  AZ: "AZN",
  BS: "BSD",
  BH: "BHD",
  BD: "BDT",
  BB: "BBD",
  BY: "BYN",
  BE: "EUR",
  BZ: "BZD",
  BJ: "XOF",
  BM: "BMD",
  BT: "BTN",
  BO: "BOB",
  BW: "BWP",
  BV: "NOK",
  BR: "BRL",
  IO: "USD",
  VG: "USD",
  BN: "BND",
  BG: "BGN",
  BF: "XOF",
  BI: "BIF",
  KH: "KHR",
  CM: "XAF",
  CA: "CAD",
  IC: "EUR",
  CV: "CVE",
  KY: "KYD",
  CF: "XAF",
  TD: "XAF",
  CL: "CLP",
  CN: "CNY",
  CX: "AUD",
  CC: "AUD",
  CO: "COP",
  KM: "KMF",
  CG: "XAF",
  CD: "CDF",
  CK: "NZD",
  CR: "CRC",
  CI: "XOF",
  HR: "HRK",
  CU: "CUP",
  CW: "ANG",
  CY: "EUR",
  CZ: "CZK",
  DK: "DKK",
  DJ: "DJF",
  DM: "XCD",
  DO: "DOP",
  TL: "USD",
  EC: "USD",
  EG: "EGP",
  SV: "USD",
  GQ: "XAF",
  ER: "ERN",
  EE: "EUR",
  ET: "ETB",
  FK: "FKP",
  FO: "DKK",
  FJ: "FJD",
  FI: "EUR",
  FR: "EUR",
  GF: "EUR",
  PF: "XPF",
  TF: "EUR",
  GA: "XAF",
  GM: "GMD",
  GE: "GEL",
  DE: "EUR",
  GH: "GHS",
  GI: "GIP",
  GR: "EUR",
  GL: "DKK",
  GD: "XCD",
  GP: "EUR",
  GU: "USD",
  GT: "GTQ",
  GG: "GBP",
  GN: "GNF",
  GW: "XOF",
  GY: "GYD",
  HT: "HTG",
  HM: "AUD",
  HN: "HNL",
  HK: "HKD",
  HU: "HUF",
  IS: "ISK",
  IN: "INR",
  ID: "IDR",
  IR: "IRT",
  IQ: "IQD",
  IE: "EUR",
  IM: "GBP",
  IL: "ILS",
  IT: "EUR",
  JM: "JMD",
  JP: "JPY",
  JE: "GBP",
  JO: "JOD",
  KZ: "KZT",
  KE: "KES",
  KI: "AUD",
  XK: "EUR",
  KW: "KWD",
  KG: "KGS",
  LA: "LAK",
  LV: "EUR",
  LB: "LBP",
  LS: "LSL",
  LR: "LRD",
  LY: "LYD",
  LI: "CHF",
  LT: "EUR",
  LU: "EUR",
  MO: "MOP",
  MK: "MKD",
  MG: "MGA",
  MW: "MWK",
  MY: "MYR",
  MV: "MVR",
  ML: "XOF",
  MT: "EUR",
  MH: "USD",
  MQ: "EUR",
  MR: "MRO",
  MU: "MUR",
  YT: "EUR",
  MX: "MXN",
  FM: "USD",
  MD: "MDL",
  MC: "EUR",
  MN: "MNT",
  ME: "EUR",
  MS: "XCD",
  MA: "MAD",
  MZ: "MZN",
  MM: "MMK",
  NA: "NAD",
  NR: "AUD",
  NP: "NPR",
  NL: "EUR",
  AN: "ANG",
  NC: "XPF",
  NZ: "NZD",
  NI: "NIO",
  NE: "XOF",
  NG: "NGN",
  NU: "NZD",
  NF: "AUD",
  KP: "KPW",
  MP: "USD",
  NO: "NOK",
  OM: "OMR",
  PK: "PKR",
  PW: "USD",
  PS: "ILS",
  PA: "PAB",
  PG: "PGK",
  PY: "PYG",
  PE: "PEN",
  PH: "PHP",
  PN: "NZD",
  PL: "PLN",
  PT: "EUR",
  PR: "USD",
  QA: "QAR",
  RE: "EUR",
  RO: "RON",
  RU: "RUB",
  RW: "RWF",
  BL: "EUR",
  SH: "SHP",
  KN: "XCD",
  LC: "XCD",
  MF: "EUR",
  PM: "EUR",
  VC: "XCD",
  WS: "WST",
  SM: "EUR",
  ST: "STN",
  SA: "SAR",
  SN: "XOF",
  RS: "RSD",
  SC: "SCR",
  SL: "SLL",
  SG: "SGD",
  SX: "ANG",
  SK: "EUR",
  SI: "EUR",
  SB: "SBD",
  SO: "SOS",
  ZA: "ZAR",
  GS: "GBP",
  KR: "KRW",
  SS: "SSP",
  ES: "EUR",
  LK: "LKR",
  SD: "SDG",
  SR: "SRD",
  SJ: "NOK",
  SZ: "SZL",
  SE: "SEK",
  CH: "CHF",
  SY: "SYP",
  TW: "TWD",
  TJ: "TJS",
  TZ: "TZS",
  TH: "THB",
  TG: "XOF",
  TK: "NZD",
  TO: "TOP",
  TT: "TTD",
  TA: "SHP",
  TN: "TND",
  TR: "TRY",
  TM: "TMT",
  TC: "USD",
  TV: "AUD",
  UM: "USD",
  VI: "USD",
  UG: "UGX",
  UA: "UAH",
  AE: "AED",
  GB: "GBP",
  US: "USD",
  UY: "UYU",
  UZ: "UZS",
  VU: "VUV",
  VA: "EUR",
  VE: "VES",
  VN: "VND",
  YE: "YER",
  ZM: "ZMW",
  ZW: "ZWL",
};
// Ark feature — off-chain payments via an ASP (Second's bark/captaind
// protocol, spoken natively by ../ark). Receive address + boarding, instant
// sends, history entries, refresh/consolidation, server settings.

import * as btc from '@scure/btc-signer';
import { HDKey } from '@scure/bip32';
import { hex, base32nopad, bech32 } from '@scure/base';
import { sha256 } from '@noble/hashes/sha256';
import { ArkManager } from '../ark/manager.js';
import { loadBg, saveBg, buildBg, disarmSiblingRecords } from '../nwc-bg.js';
import { boardFee, p2trAddress } from '../ark/board.js';
import { maybeBolt11, maybeLnInvoice, lnSendFee } from '../ark/lightning.js';
import { decodeVtxo, getVtxoStatus, VTXO_STATE_SPENT, concatBytes, vtxoBytesFromStr, vtxoBytesToHex } from '../ark/proto.js';
import { arkStore } from '../ark/store.js';
import { signedExitTxs, exitTxVsizes, buildBumpChild, buildExitClaim, submitPackage } from '../ark/exit.js';
import { utxoId } from '../wallet.js';
import {
  getNetwork, setNetwork, getArkProviderId, getArkConfig,
} from '../api.js';
import { t } from '../i18n.js';
import { resolveBip353, parsePaymentName, parseBip21 as parseBip21Uri } from '../bip353.js';
import { parseZapTarget, fetchPayParams, requestInvoice } from '../lnurl.js';
import { shortAddr, shortTxid, timeAgo, fmtSats, ARK_ICON, ARK_MARK, BITCOIN_ICON } from '../format.js';

// t?ark1… bech32m — an Ark address for this or another ASP.
export function isArkAddress(a) { return /^t?ark1[a-z0-9]{20,}$/i.test((a || '').trim()); }

// Use the funding transaction's actual input selection and P2TR output size
// for both Max and the fee preview. Mining fees are paid from Savings; only
// the ASP service fee comes out of the amount deposited into Spending.
export function previewBoardFunding(wallet, ark, amountSat = 0, sendMax = false) {
  const feeRate = (wallet.feeRates && wallet.feeRates.halfHourFee) || 5;
  const hrp = { bitcoin: 'bc', regtest: 'bcrt' }[ark?.info?.network] || 'tb';
  const dest = ark ? p2trAddress(ark._key(0).pubkey.slice(1), hrp) : wallet.freshChange().address;
  const draft = wallet.buildTx({ recipients: [{ address: dest, amount: amountSat }], feeRate, sendMax, noSort: true });
  const fundingSat = draft.outputs[0].amount;
  const serviceFeeSat = boardFee(fundingSat, ark?.info?.boardFees);
  return { fundingSat, chainFeeSat: draft.fee, serviceFeeSat,
    feeSat: draft.fee + serviceFeeSat, netSat: fundingSat - serviceFeeSat };
}

// Ark movement types that actually touch the chain — each is a real bitcoin
// tx with a txid, so it wears the Bitcoin mark, not the Ark one: board pulls
// coins in from on-chain, offboard and exit push them back out.
const ONCHAIN_ARK = new Set(['board', 'offboard', 'exit']);

// Every live ark manager registers its debounced persist here so a pending
// write is never lost: flushed synchronously when the page hides, and on a
// wallet switch (see stopArk).
const arkPersistFlushers = new Set();
if (typeof document !== 'undefined') {
  const flushAll = () => { for (const f of [...arkPersistFlushers]) { try { f(); } catch {} } };
  addEventListener('pagehide', flushAll);
  document.addEventListener('visibilitychange', () => { if (document.visibilityState === 'hidden') flushAll(); });
}

// Wallet storage/key helpers for this feature, installed onto the core
// wallet instance so a build without the feature ships none of it.
export function installArkWallet(wallet) {
  if (wallet.loadArkState) return; // already installed
  const store = arkStore(); // IndexedDB-backed, memory-fronted; opens now
  Object.assign(wallet, {
    _arkStore: store,
    // ---- Ark support -------------------------------------------------------
    // Persisted ArkManager state (vtxos, in-flight action checkpoints, movement
    // history — no secrets: vtxo keys are re-derived from the seed).
    // Ark state is per WALLET *and* per ASP: vtxos are cosigned by one
    // specific server, so showing another server's coins (or resuming its
    // in-flight board) is meaningless and alarming. Switching providers must
    // therefore switch state, and switching back must restore it.
    _arkNs(url) {
      // short, stable id for an ASP endpoint
      let h = 5381;
      for (const c of String(url || '')) h = ((h * 33) ^ c.charCodeAt(0)) >>> 0;
      return h.toString(36);
    },
    _arkKey(url) { return this._cacheKey() + ':ark:' + this._arkNs(url); },
    _arkLegacyKey() { return this._cacheKey() + ':ark'; },
    // Who really cosigned this state's coins? A vtxo names its server in its
    // own bytes, which is cryptographic fact — unlike the stamp, which is
    // just something we wrote and could have written wrongly.
    _arkVtxoOwner(st) {
      const v = (st?.vtxos || []).find((x) => x.bytes);
      if (!v) return null;
      try { return decodeVtxo(vtxoBytesFromStr(v.bytes)).serverPubkey; } catch { return null; }
    },
    // Park state under the server that actually owns it, until the URL for
    // that server is selected and can adopt it.
    _arkHoldKey(pubkey) { return this._cacheKey() + ':ark:pk:' + String(pubkey).slice(0, 16); },
    loadArkState(url) {
      // NB deliberately no fallback to the legacy key: the UI renders from
      // this before any server is contacted, so returning another ASP's state
      // here is exactly how you get a phantom balance. Pre-namespacing state
      // is claimed via adoptArkState() once we know who cosigned it.
      try {
        const st = store.get(this._arkKey(url));
        if (!st) return null;
        // Self-repair: an earlier build could stamp state with whichever
        // server happened to be connected, filing one ASP's coins under
        // another. The vtxos themselves settle it — if they disagree with the
        // stamp, this state is misfiled. Move it to its real owner and show
        // nothing here.
        const owner = this._arkVtxoOwner(st);
        if (owner && st.serverPubkey && owner !== st.serverPubkey) {
          st.serverPubkey = owner;
          store.set(this._arkHoldKey(owner), st);
          store.remove(this._arkKey(url));
          return null;
        }
        return st;
      } catch { return null; }
    },
    // Offer up pre-namespacing state, but only to the ASP that actually
    // cosigned it. Its owner is read from the state's own stamp, or failing
    // that decoded straight out of a vtxo — the vtxo wire format carries the
    // server pubkey, so this needs no network call and cannot guess wrong.
    adoptArkState(serverPubkey, url) {
      try {
        // state parked by the self-repair above belongs to exactly one server
        const held = store.get(this._arkHoldKey(serverPubkey));
        if (held) {
          this.saveArkState(held, url);
          store.remove(this._arkHoldKey(serverPubkey));
          return held;
        }
        const st = store.get(this._arkLegacyKey());
        if (!st) return null;
        let owner = st.serverPubkey || null;
        if (!owner) {
          const v = (st.vtxos || []).find((x) => x.bytes);
          if (v) { try { owner = decodeVtxo(vtxoBytesFromStr(v.bytes)).serverPubkey; } catch {} }
        }
        if (owner && owner !== serverPubkey) return null; // belongs to another ASP
        if (!owner) return null;                          // can't prove ownership: leave it
        st.serverPubkey = owner;
        this.saveArkState(st, url);
        store.remove(this._arkLegacyKey()); // now safely namespaced
        return st;
      } catch { return null; }
    },
    saveArkState(state, url) {
      store.set(this._arkKey(url), state);
    },
  });
}

// A slim projection of ark state for the sync snapshot. Oversized domains
// now travel as encrypted Blossom blobs, so preserve the complete history
// and spent-coin stubs instead of rebuilding them from the mailbox. Another
// device needs, per vtxo: id/amount/state (+ bytes ONLY for spendable/pending,
// which it might spend/exit); the movement log for ark history; and
// done board/offboard/exit actions (stripped of hex) so on-chain rows still
// label. In-flight actions and their signing material stay device-local.
export function slimArkForSync(s) {
  if (!s) return null;
  const HEAVY = ['bytes', 'destBytes', 'changeBytes', 'vtxoBytes', 'txHex', 'fundingTxHex', 'outputVtxos'];
  return {
    v: s.v, serverPubkey: s.serverPubkey, mailboxCheckpoint: s.mailboxCheckpoint, nextKeyIndex: s.nextKeyIndex, receiveAckTs: s.receiveAckTs,
    // Spent stubs keep old snapshots/mailbox messages from resurrecting coins.
    vtxos: (() => {
      // On the wire the bytes stay HEX for now: a device still on a build
      // that only reads hex would otherwise fail to decode every coin merged
      // from this one. Flip to base64 once builds before 2026-09-10 are gone.
      const live = (s.vtxos || []).filter((v) => v.state !== 'spent')
        .map((v) => (v.bytes ? { ...v, bytes: vtxoBytesToHex(v.bytes) } : v));
      const stubs = (s.vtxos || []).filter((v) => v.state === 'spent')
        .map((v) => ({ id: v.id, amountSat: v.amountSat, state: 'spent', keyIndex: v.keyIndex, expiryHeight: v.expiryHeight }));
      return [...live, ...stubs];
    })(),
    actions: (() => {
      const done = (s.actions || []).filter((a) => a.step === 'done');
      const core = done.filter((a) => ['board', 'offboard', 'exit'].includes(a.type))
        .map((a) => { const c = { ...a }; for (const k of HEAVY) delete c[k]; return c; });
      // Spends travel as SLIVERS — id, net amount, and which coins they
      // consumed. That last field is what lets ANOTHER device recognize a
      // vanished coin as this send rather than painting a red "spent on
      // another device" row beside the synced Sent movement (one spend was
      // showing twice, at input magnitude the second time).
      const spends = done.filter((a) => ['send', 'ln-pay'].includes(a.type))
        .map((a) => ({
          id: a.id, type: a.type, step: 'done', amountSat: a.amountSat,
          inputIds: [...new Set([...(a.inputIds || []), ...(a.parts || []).map((p) => p.inputId), a.inputId].filter(Boolean))],
        }));
      return [...core, ...spends];
    })(),
    movements: (s.movements || []).map((m, i, arr) =>
      // Older rows only need to render a history line; the bolt11 (~400 chars
      // each) and preimage are what pushed snapshots past relay size limits.
      (arr.length - i <= 50 ? m : (({ invoice, preimage, ...rest }) => rest)(m))),
    gifts: s.gifts,
  };
}

// Merge two ark states so devices can't clobber each other through the sync
// snapshot: additive union of vtxos (a device keeps its own full copy, gains
// ones it lacks), actions/movements/gifts union by id, counters take the max
// (so two devices never reuse a key index).
export function mergeArkStates(a, b) {
  if (!a) return b;
  if (!b) return a;
  // never fuse state from two different ASPs
  if (a.serverPubkey && b.serverPubkey && a.serverPubkey !== b.serverPubkey) return a;
  const out = { ...a };
  // ADDITIVE union only: bring in vtxos this device is missing (the whole
  // point — board/change coins that live only where they were created), but
  // NEVER let a remote snapshot change the state of a vtxo we already track.
  // Spend detection is each device's own job via reconcile() against the
  // server (the authority), so a stale-or-wrong "spent" on one device can't
  // propagate and permanently poison the others. A newly-merged-in vtxo that
  // was actually spent elsewhere gets caught by the reconcile on next connect
  // / send-intent, exactly like any other drift.
  const vtxos = new Map((a.vtxos || []).map((v) => [v.id, { ...v }]));
  for (const rv of b.vtxos || []) if (!vtxos.has(rv.id)) vtxos.set(rv.id, { ...rv });
  out.vtxos = [...vtxos.values()];
  const unionById = (x = [], y = []) => {
    const ids = new Set(x.map((i) => i.id));
    return [...x, ...y.filter((i) => !ids.has(i.id))];
  };
  out.actions = unionById(a.actions, b.actions);
  // Union keeps the local copy of a movement forever — but a movement can be
  // ENRICHED after other devices synced it (the cooney rescue stamped
  // inputIds/unlockHash/fee onto its renewal movement post-hoc, and those
  // fields are what lets history exclude the matching "spent on another
  // device" rows). Adopt fields the local copy lacks; never overwrite ones
  // it has.
  const bM = new Map((b.movements || []).map((m) => [m.id, m]));
  const enriched = (a.movements || []).map((lm) => {
    const rm = bM.get(lm.id);
    if (!rm) return lm;
    const take = {};
    if (rm.inputIds != null && lm.inputIds == null) take.inputIds = rm.inputIds;
    if (rm.unlockHash != null && lm.unlockHash == null) take.unlockHash = rm.unlockHash;
    // a fee learned late (the rescue computed it from inputs − outputs)
    // upgrades a recorded zero — the row only renders when the fee is real
    if ((rm.feeSat || 0) > 0 && !(lm.feeSat > 0)) take.feeSat = rm.feeSat;
    if (rm.chainFeeSat != null && lm.chainFeeSat == null) take.chainFeeSat = rm.chainFeeSat;
    if (rm.serviceFeeSat != null && lm.serviceFeeSat == null) take.serviceFeeSat = rm.serviceFeeSat;
    // an LN-origin tag learned on another device (matched against the
    // registrar's receipts there) rides the snapshot to this one
    if (rm.viaLn && !lm.viaLn) { take.viaLn = true; if (rm.lnHash) take.lnHash = rm.lnHash; }
    return Object.keys(take).length ? { ...lm, ...take } : lm;
  });
  // Two devices (or the push and the poll, pre-guard) can each record the
  // SAME lightning payment under different movement ids — same preimage is
  // the same payment, keep the earliest telling of it.
  const seenPay = new Set();
  out.movements = unionById(enriched, b.movements)
    .sort((m, n) => (m.ts || 0) - (n.ts || 0))
    .filter((m) => {
      if (!m.type || !m.type.startsWith('ln-') || m.status !== 'complete') return true;
      const key = m.type + ':' + (m.paymentHash || m.preimage || m.invoice || m.id);
      if (seenPay.has(key)) return false;
      seenPay.add(key);
      return true;
    });
  const gifts = new Map((a.gifts || []).map((g) => [g.id, { ...g }]));
  for (const rg of b.gifts || []) {
    const lg = gifts.get(rg.id);
    if (!lg) gifts.set(rg.id, { ...rg });
    else { lg.claimed = lg.claimed || rg.claimed; lg.revoked = lg.revoked || rg.revoked; }
  }
  out.gifts = [...gifts.values()];
  // Targeted spend knowledge beats waiting for a reconcile: a completed
  // movement or done action that names its consumed inputs is direct
  // evidence those coins are gone. A device waking cold used to merge in
  // another device's renewal/send OUTPUT while still counting the consumed
  // inputs as spendable — the balance visibly ticked high, then dropped
  // when the reconcile caught up. (This is narrow, evidence-based state —
  // not the blanket remote-state adoption the rule above forbids.)
  const consumed = new Set();
  for (const x of out.actions || []) {
    if (x.step !== 'done') continue;
    for (const id of x.inputIds || []) consumed.add(id);
    for (const part of x.parts || []) if (part.inputId) consumed.add(part.inputId);
  }
  for (const m of out.movements || []) {
    if (m.status !== 'complete') continue;
    for (const id of m.inputIds || []) consumed.add(id);
  }
  for (const v of out.vtxos) if (v.state === 'spendable' && consumed.has(v.id)) v.state = 'spent';
  // The checkpoint is READING PROGRESS, not state: adopting a remote one
  // skips every message this device never processed — balance appears (the
  // vtxo unions in) but its receive movement and celebration never happen.
  // Keep the local checkpoint; re-read messages dedupe harmlessly.
  const pristine = !a.mailboxCheckpoint && !a.vtxos?.length && !a.movements?.length
    && !a.actions?.length && !a.scheduled?.length;
  // A manager's empty shell is not local history. Restore the snapshot's
  // cursor with its coins/history, just as the !a case above does, rather
  // than replaying the entire mailbox on a first login.
  out.mailboxCheckpoint = pristine ? b.mailboxCheckpoint || 0 : a.mailboxCheckpoint || 0;
  out.nextKeyIndex = Math.max(a.nextKeyIndex || 1, b.nextKeyIndex || 1);
  out.nextLnRecvIndex = Math.max(a.nextLnRecvIndex || 0, b.nextLnRecvIndex || 0);
  out.receiveAckTs = Math.max(a.receiveAckTs || 0, b.receiveAckTs || 0);
  out.serverPubkey = a.serverPubkey || b.serverPubkey || null;
  return out;
}

// Apply sync to a connected manager without restarting payment ceremonies.
// Drivers retain references across awaits, so preserve the state, coin and
// action objects they already hold while adding/enriching the remote records.
export function adoptArkSnapshot(manager, snapshot) {
  if (!snapshot || !manager.state) return false;
  const state = manager.state;
  const merged = mergeArkStates(state, snapshot);
  if (JSON.stringify(merged) === JSON.stringify(state)) return false;
  for (const field of ['vtxos', 'actions', 'movements', 'gifts']) {
    const existing = new Map((state[field] || []).map(item => [item.id, item]));
    merged[field] = (merged[field] || []).map(item => {
      const current = existing.get(item.id);
      return current ? Object.assign(current, item) : item;
    });
  }
  Object.assign(state, merged);
  manager._save();
  return true;
}

export function arkFeature(ctx) {
  const { h, ui, render, wallet, blankSend, fmtAmount, unitLabel, unitTag, copyBtn, toast, openExternal } = ctx;
  installArkWallet(wallet); // ark state storage lives outside the core wallet

  // Ride the encrypted sync snapshot so ark funds follow the seed across
  // devices. Board/change vtxo bytes exist only where they were created — a
  // second device can't otherwise see them. All devices share ONE replaceable
  // event slot (same seed -> same nostr key), so a naive publish can clobber
  // another device's coins. Anti-entropy fixes that: on receiving a snapshot,
  // union it with local; if it was missing coins we know (or brought coins we
  // didn't), re-publish the superset. The slot converges to the union no
  // matter who publishes when.
  wallet.registerCacheExtension({
    domain: 'ark', // published as its own sync slot — see splitSnapshotDomains
    mergeAlways: true, // load() is a commutative merge — apply older snapshots too
    syncOnly: true, // ark keeps its own store; the local cache blob needn't carry a copy
    save: () => {
      const cfg = getArkConfig();
      const s = cfg && wallet.loadArkState(cfg.ark);
      // tag the snapshot with the ASP it belongs to (see load())
      return s ? { arkState: slimArkForSync(s), arkServer: wallet._arkNs(cfg.ark) } : {};
    },
    load: (d) => {
      if (!d.arkState) return;
      const cfg = getArkConfig();
      if (!cfg) return;
      if (d.arkServer && d.arkServer !== wallet._arkNs(cfg.ark)) return;
      // A snapshot from an older build carries no tag, so the tag alone can't
      // be trusted — ask the vtxos who cosigned them. If they belong to a
      // different ASP (or we can't yet prove they belong to this one), park
      // the snapshot under its real owner instead of merging it in. Merging
      // blind is exactly how another server's balance appears here.
      const owner = d.arkState.serverPubkey || wallet._arkVtxoOwner(d.arkState);
      const mine = (ark && ark.info && ark.info.serverPubkey)
        || (wallet.loadArkState(cfg.ark) || {}).serverPubkey || null;
      if (owner && owner !== mine) {
        try {
          const key = wallet._arkHoldKey(owner);
          wallet._arkStore.set(key, mergeArkStates(wallet._arkStore.get(key), { ...d.arkState, serverPubkey: owner }));
        } catch {}
        // `mine` is null on a FRESH restore (no local state, not yet
        // connected), so even our own snapshot lands in the hold. Connecting
        // is what resolves it: the manager learns the server's pubkey and
        // adopts the held state if it matches — a seed imported on a new
        // device would otherwise show no ark balance until some manual poke.
        if (!mine) setTimeout(() => maybeInitArk(), 0);
        return;
      }
      const local = wallet.loadArkState(cfg.ark);
      const merged = mergeArkStates(local, d.arkState);
      // Every boot replays the sync slot, and on a converged slot the union
      // brings nothing — not worth rewriting ~1 MB of state or re-adopting
      // it into the manager (profiled at ~200ms per replay, twice per boot).
      // Bytes decide: unchanged means it serializes to what's already stored.
      let changed = true;
      try { changed = JSON.stringify(merged) !== JSON.stringify(local); } catch {}
      if (changed) wallet.saveArkState(merged, cfg.ark);
      const mergedN = (merged.vtxos || []).length;
      const remoteN = (d.arkState.vtxos || []).length;
      // We know vtxos this snapshot lacked — push our superset back up so the
      // sender (and the shared slot) learns them. Guarded by mergedN>remoteN so
      // it can't loop once every device has converged to the union.
      if (mergedN > remoteN) { try { wallet.saveCache(); } catch {} }
      // maybeInitArk deliberately does nothing when connected. Update that
      // manager directly or the newly synced change/history stays invisible
      // until reload, even though storage already contains the right balance.
      if (ark) { if (changed) adoptArkSnapshot(ark, merged); }
      else if (mergedN) setTimeout(() => maybeInitArk(), 0);
    },
  });

  // One manager per open wallet; null when Ark is off in Settings, watch-only,
  // or not yet dialed (lazy: fresh wallets connect on first use).
  let ark = null;
  let arkTimer = null;
  let arkConnectPromise = null;
  let arkInitGen = 0; // guards against a stale init() resolving after a wallet switch

  function stopArk() {
    // land any debounced ark write BEFORE bumping the gen (which would make the
    // old manager's flusher a no-op), then drop the stale flushers
    for (const f of [...arkPersistFlushers]) { try { f(); } catch {} }
    arkPersistFlushers.clear();
    arkInitGen++;
    lastAutoInit = 0;
    if (arkTimer) clearInterval(arkTimer);
    arkTimer = null;
    if (ark) ark.stopMailboxStream();
    stopNwcFunding();
    for (const timer of arkLnTimers.values()) clearInterval(timer);
    arkLnTimers.clear();
    clearTimeout(lnTagT);
    lnTagSeen = -1;
    ark = null;
    arkConnectPromise = null;
    // The renewal warning describes the coins of the wallet we're leaving.
    // Switching accounts used to carry it onto the next one — with the old
    // wallet's amount and deadline, over the new wallet's balance — and the
    // 30-minute throttle then kept it there. Both reset with the manager;
    // the next connect's first tick re-decides for the wallet now open.
    arkRenewWarn = null;
    arkAutoRefreshAt = 0;
  }

  function arkAvailable() {
    return !!getArkConfig() && !wallet.watchOnly && !!wallet.account;
  }

  function arkWanted() {
    const cfg = getArkConfig();
    const st = cfg && wallet.loadArkState(cfg.ark);
    return !!(st && ((st.vtxos || []).length || (st.movements || []).length
      || (st.actions || []).some((a) => !['done', 'failed'].includes(a.step))));
  }

  function initArk() {
    stopArk();
    ui.arkError = '';
    // The ark store is IndexedDB — asynchronous to OPEN, synchronous to read
    // once it has. A boot that beats it open reads no state at all: no
    // Spending balance, no Spending history, and nothing here that looks
    // worth connecting for. Wait for it and run again, so what the store
    // holds is on screen the moment it can be.
    const store = wallet._arkStore;
    if (store && !store.ready) {
      store.open().then(() => { ctx.forgetAmountAnim && ctx.forgetAmountAnim(); render(); initArk(); }).catch(() => {});
      return;
    }
    if (arkAvailable() && arkWanted()) { lastAutoInit = Date.now(); connectArk().catch(() => {}); }
  }

  // Automatic re-inits (a synced snapshot arriving) must not restart a
  // connection that is already in flight, or retry in a tight loop when the
  // server is unreachable: each one calls stopArk() first, so the settings
  // card's "connecting" indicator flickers on every snapshot. User-driven
  // calls to initArk() stay immediate.
  let lastAutoInit = 0;
  function maybeInitArk() {
    if (ark || arkConnectPromise) return;
    if (Date.now() - lastAutoInit < 20000) return;
    // A fresh snapshot may be held under its server pubkey, so arkWanted()
    // cannot see it until the handshake identifies the server and adopts it.
    if (arkAvailable()) { lastAutoInit = Date.now(); connectArk().catch(() => {}); }
  }

  // Operator console rescue for a round participation stranded server-side
  // 'unclaimed' (its action lost client-side): arkRescue('<unlockHash>',
  // ['<vtxoId>', ...]) from devtools, ids supplied from the server's DB.
  if (typeof globalThis !== 'undefined') {
    globalThis.arkRescue = async (unlockHash, inputIds) => {
      const mgr = await connectArk();
      return mgr.rescueParticipation(unlockHash, inputIds);
    };
  }

  function connectArk() {
    if (ark) return Promise.resolve(ark);
    if (arkConnectPromise) return arkConnectPromise;
    if (!arkAvailable()) return Promise.reject(new Error(t('arkNotConnected')));
    const cfg = getArkConfig();
    const gen = arkInitGen;
    // Persisting ark state is EXPENSIVE — a JSON.parse of the stored state, a
    // merge over every vtxo + movement, a JSON.stringify, a synchronous
    // localStorage write, then saveCache(). The manager fires _save() on every
    // mutation, and a boot reconcile mutates dozens of times in a burst —
    // that's the main-thread stall that made a mouse drag lurch right after a
    // refresh. The in-memory state is always current and every live READ goes
    // to it (arkStateNow returns ark.state); only the disk copy has to catch
    // up, so coalesce the writes: idle → write now, mid-burst → one write when
    // it quiets (capped so a steady stream still lands). Flushed on hide.
    let persistPending = null, persistT = 0, persistLastAt = 0, persistFirstAt = 0;
    const flushPersist = () => {
      clearTimeout(persistT); persistT = 0; persistFirstAt = 0;
      if (!persistPending || gen !== arkInitGen) { persistPending = null; return; }
      const s = persistPending; persistPending = null; persistLastAt = Date.now();
      wallet.saveArkState(mergeArkStates(s, wallet.loadArkState(cfg.ark)), cfg.ark);
      try { wallet.saveCache(); } catch {}
    };
    arkPersistFlushers.add(flushPersist);
    const mgr = new ArkManager({
      account: wallet.account(),
      storage: {
        load: () => wallet.loadArkState(cfg.ark),
        adopt: (serverPubkey) => wallet.adoptArkState(serverPubkey, cfg.ark),
        // merge-on-save: the MANAGER is authoritative for the state of the
        // vtxos it tracks (its reconcile/spends must persist), so its state
        // is the first arg and wins; storage only contributes vtxos the
        // manager hasn't loaded yet (a snapshot merged in from another device
        // between init and the next reinit). saveCache() then carries ark
        // state into the snapshot -> debounced nostr publish.
        save: (s) => {
          persistPending = s;
          const now = Date.now();
          if (!persistFirstAt) persistFirstAt = now;
          // a lone change after a quiet spell writes immediately; a burst
          // coalesces into one write ~200ms after it settles, but never waits
          // more than ~800ms so a steady stream still lands
          if (now - persistLastAt > 1000 && !persistT) { flushPersist(); return; }
          if (now - persistFirstAt > 800) { flushPersist(); return; }
          clearTimeout(persistT);
          persistT = setTimeout(flushPersist, 200);
        },
      },
      arkUrl: cfg.ark,
      esploraUrl: cfg.esplora,
      network: getNetwork(),
      // the wallet's own tx table as a second witness for confirmations —
      // its data source is user-configurable and often healthier than the
      // ark preset's esplora from this device
      statusHint: (txid2) => {
        const tx = (wallet.txs || []).find((t2) => t2.txid === txid2);
        return tx && tx.confirmed ? { confirmed: true, block_height: tx.blockHeight || NaN } : null;
      },
      onUpdate: (m) => { if (gen !== arkInitGen) return; maybeAutoSelectSpending(); scheduleLnTag(m); render(); },
    });
    ui.arkError = '';
    // Open the server connection while Nostr restores, but do not replay the
    // mailbox before the snapshot's history and cursor have arrived.
    const restored = Promise.resolve(wallet.nostrRestoreReady || wallet.syncFromNostr?.()).catch(() => false);
    arkConnectPromise = Promise.all([mgr.init(), restored]).then(() => {
      if (gen !== arkInitGen) throw new Error('superseded'); // wallet switched mid-connect
      ark = mgr;
      // Sync may have arrived while init awaited the server handshake.
      adoptArkSnapshot(mgr, wallet.loadArkState(cfg.ark));
      // Boards that died before funding (a failed tx build, a closed tab)
      // used to linger at 'created' forever — and an in-flight-looking
      // action blocks auto-renewal. Anything unfunded after an hour is a
      // stub, not a plan; the id carries its birth time.
      {
        let swept = false;
        for (const a of mgr.state.actions || []) {
          if (a.type !== 'board' || a.fundingTxid || ['done', 'failed'].includes(a.step)) continue;
          const ts = Number((a.id || '').split('-')[1]) || 0;
          if (ts && Date.now() - ts > 3600_000) { a.step = 'failed'; a.error = a.error || 'never funded'; swept = true; }
        }
        if (swept) mgr._save();
      }
      announceArkAddress(mgr); // ark zaps: tell nostr where our mailbox lives
      startNwcFunding(mgr);    // NWC bridge: honor funding requests within the allowance
      // Publish this device's ark state to its per-device sync slot on connect.
      // Cross-device sync only re-published on a state CHANGE (a send/board), so
      // an idle device never shared its coins — another device would never see
      // them. Publishing on connect guarantees every device's ark balance
      // reaches the relay (and gets merged) without needing a transaction first.
      if (mgr.state && (mgr.state.vtxos || []).length) { try { wallet.saveCache(); } catch {} }
      // A failed mailbox read must not starve the action drives: boards and
      // refreshes progress on chain state alone, so push them even when the
      // sync itself errored.
      let ticking = null;
      const tick = () => ticking || (ticking = mgr.sync().catch(async () => {
        // Even when mailbox catch-up fails, independently check stale coins
        // and advance recoverable local actions.
        await mgr.reconcile().catch(() => {});
        await mgr.resumePending().catch(() => {});
      })
        .then(() => driveExits(mgr)).catch(() => {})
        .then(() => { if (ark === mgr) return maybeAutoRefresh(mgr); }).catch(() => {})
        .then(() => { if (ark === mgr) return maybeAutoWithdraw(mgr); }).catch(() => {})
        .finally(() => { ticking = null; }));
      // sync() already reconciles on its first pass. Start the live stream
      // afterwards, at the caught-up cursor: running both together replayed
      // the backlog one message/render at a time alongside the batch read.
      tick().finally(() => { if (ark === mgr) mgr.startMailboxStream(); });
      mergeBgWorkerState(mgr).catch(() => {}); // absorb what the SW did while we were closed
      // Receives arrive in real time over the mailbox stream; the poll is the
      // fallback and what drives in-flight boards/refreshes forward.
      scheduleLnTag(mgr); // receives that landed while this device was closed
      arkTimer = setInterval(() => { if (ark === mgr) tick(); }, getNetwork() === 'regtest' ? 5000 : 30000);
      render();
      return mgr;
    }).catch((e) => {
      if (gen === arkInitGen) { ui.arkError = e.message; render(); }
      throw e;
    }).finally(() => { if (gen === arkInitGen) arkConnectPromise = null; });
    render();
    return arkConnectPromise;
  }

  // The current ark state for READ-ONLY rendering: the live manager if it's
  // connected, else the persisted state straight from storage. Lets the
  // balance and history icons paint immediately on refresh instead of
  // flickering (empty → populated) while the manager connects asynchronously.
  function arkStateNow() {
    if (ark && ark.state) return ark.state;
    // Read persisted state whenever Ark is configured for this network — even
    // watch-only (seed not loaded this session): the balance/history should
    // show read-only, just like the on-chain balance does. Acting on it
    // (send/exit) still requires the seed and is gated separately.
    const cfg = getArkConfig();
    if (!cfg) return null;
    return wallet.loadArkState(cfg.ark);
  }

  // Which receives actually arrived over Lightning? A payment to the user's
  // [email protected] address settles on the registrar's node and lands here as
  // an ordinary arkoor from its float wallet — the mailbox protocol carries
  // no memo, so the movement alone can't name the rail the sender used. The
  // registrar keeps a receipt per LN settlement it forwarded; matching those
  // against receive movements (exact amount, delivery within a couple of
  // minutes) marks the row viaLn so it wears the ⚡ the sender expects.
  // Best-effort and cosmetic: a rare amount+time collision only mislabels an
  // icon. The receipt's payment hash is stamped on the matched movement so a
  // receipt never claims a second row on later passes.
  let lnTagBusy = false, lnTagT = 0, lnTagSeen = -1;
  async function tagLnReceives(mgr) {
    if (lnTagBusy) return;
    // nothing a receipt could match (the registrar keeps them 7 days) —
    // don't spend a signed fetch on every boot of a quiet wallet
    if (!(mgr.state.movements || []).some((m) => m.type === 'receive' && m.status === 'complete'
        && !m.viaLn && (m.ts || 0) > Date.now() - 7 * 86400_000)) return;
    lnTagBusy = true;
    try {
      const receipts = await Promise.resolve(ctx.hook('namesLnReceipts')).catch(() => null);
      if (!receipts || !receipts.length || ark !== mgr || !mgr.state) return;
      const moves = (mgr.state.movements || [])
        .filter((m) => m.type === 'receive' && m.status === 'complete');
      const used = new Set(moves.filter((m) => m.lnHash).map((m) => m.lnHash));
      let changed = false;
      for (const r of receipts) {
        if (r.hash && used.has(r.hash)) continue;
        let best = null;
        for (const m of moves) {
          if (m.viaLn || m.amountSat !== r.sat) continue;
          const dt = Math.abs((m.ts || 0) - r.ts);
          if (dt > 180_000) continue;
          if (!best || dt < Math.abs((best.ts || 0) - r.ts)) best = m;
        }
        if (!best) continue;
        best.viaLn = true;
        if (r.hash) { best.lnHash = r.hash; used.add(r.hash); }
        changed = true;
      }
      if (changed) mgr._save();
    } finally { lnTagBusy = false; }
  }
  // Fires off onUpdate, so gate on the thing that actually warrants a fetch:
  // the count of untagged receives changed (a new receive landed, or a
  // snapshot brought some in). Debounced so a catch-up burst asks once.
  function scheduleLnTag(mgr) {
    const n = (mgr.state.movements || []).reduce((c, m) =>
      c + (m.type === 'receive' && m.status === 'complete' && !m.viaLn ? 1 : 0), 0);
    if (n === lnTagSeen) return;
    lnTagSeen = n;
    clearTimeout(lnTagT);
    lnTagT = setTimeout(() => { if (ark === mgr) tagLnReceives(mgr).catch(() => {}); }, 2000);
  }

  // A wallet that opens onto "Savings: 0" while its money sits in Spending
  // is answering the wrong question — a stale device-global selection (or
  // the default) shouldn't hide the balance. One shot per wallet open; any
  // manual switch afterwards is respected.
  let _autoSelected = false;
  function maybeAutoSelectSpending() {
    if (_autoSelected || wallet.watchOnly) return;
    // The user beat us to it: they've already scrolled/tapped/flicked to an
    // account this session. The "open onto Spending when Savings is empty"
    // convenience only applies to the UNTOUCHED open — arriving late (when
    // the ark balance finally syncs, a second after a refresh) and yanking
    // the card away from the one they just chose is the exact opposite of
    // convenient. Consume the one-shot so it can't fire behind them.
    if (ui.accountUserChosen) { _autoSelected = true; return; }
    const b = arkBalance();
    if (!b || b.spendableSat + b.pendingSat <= 0) return;
    _autoSelected = true;
    if ((wallet.spendable || 0) === 0 && ctx.getAccount() === 'savings') {
      ui.navAnimSkip = true; // a correction at open paints, never slides
      ctx.setAccount('spending'); // renders synchronously; the flip is decided here
      ui.navAnimSkip = false; // don't let the one-shot eat the next real navigation
    }
  }

  function arkBalance() {
    const s = arkStateNow();
    if (!s) return null;
    const sum = (st) => (s.vtxos || []).filter((v) => v.state === st && !v.expiryRejected).reduce((n, v) => n + v.amountSat, 0);
    const boardingSat = (s.actions || [])
      .filter((a) => a.type === 'board' && a.fundingTxid && !['done', 'failed'].includes(a.step))
      .reduce((n, a) => n + (a.amountSat - a.feeSat), 0);
    return { spendableSat: sum('spendable'), pendingSat: sum('pending'), boardingSat };
  }

  // An ark address in the send form signals a send is coming: verify our
  // spendable vtxos against the server now, so a stale one (same seed active
  // elsewhere, restored state) is dropped before coin selection instead of
  // failing at cosign time. Throttled — this fires from the render path.
  let arkReconciledAt = 0;
  function maybeReconcile() {
    if (Date.now() - arkReconciledAt < 30_000) return;
    arkReconciledAt = Date.now();
    connectArk().then((mgr) => mgr.reconcile()).catch(() => {});
  }

  function arkSendReview() {
    if (ui.arkSent) {
      return h(
        'div',
        {
          class: 'card col',
          style: 'align-items:center;text-align:center;gap:14px;cursor:pointer;padding:48px 20px',
          onClick: () => { ui.arkSent = null; ui.send = blankSend(); render(); },
        },
        h('div', { class: 'check-badge' }, '✓'),
        h('h2', { style: 'margin:0' }, t('arkSentTitle')),
        h('div', { class: 'amount-neg', style: 'font-size:18px' }, '-' + fmtAmount(ui.arkSent.amountSat) + ' ' + unitLabel()),
        h('div', { class: 'small muted' }, t('tapToProceed'))
      );
    }
    const a = ui.arkSend;
    const row = (k, v) => h('div', { class: 'row between' }, h('span', { class: 'small muted' }, k), h('span', { class: 'small' }, v));
    return h(
      'div',
      { class: 'card col', style: 'gap:12px' },
      h('h3', {}, t('arkSendTitle')),
      row(t('lnPayAmount'), fmtAmount(a.amountSat) + ' ' + unitLabel()),
      row(t('arkPayTo'), shortAddr(a.address, 14)),
      row(t('networkFee'), t('arkNoFee')),
      ui.sendError ? h('div', { class: 'notice err' }, ui.sendError) : null,
      // An amount Spending can't cover isn't a dead end while Savings can:
      // the Send button becomes the door to the board panel, prefilled with
      // what this payment needs — instead of letting the send run into an
      // "insufficient ark balance" wall.
      h('div', { class: 'row gap6' },
        h('button', { class: 'btn-ghost', onClick: () => { ui.arkSend = null; ui.sendError = ''; render(); } }, t('back')),
        ui.busy
          ? h('button', { class: 'btn-primary grow', disabled: true }, h('span', { class: 'spinner' }))
          : a.amountSat > (arkBalance()?.spendableSat || 0) && wallet.spendable > 0 && !wallet.watchOnly
            ? h('button', { class: 'btn-primary grow', onClick: () => {
                const need = a.amountSat;
                ui.arkSend = null; ui.sendError = '';
                ctx.hook('arkOfferBoard', need);
              } }, t('zapBoardBtn'))
            : h('button', { class: 'btn-primary grow', onClick: doArkSend }, t('arkSendBtn'))
      )
    );
  }

  async function doArkSend() {
    const a = ui.arkSend;
    ui.busy = true; ui.sendError = ''; render();
    try {
      const mgr = await connectArk();
      await mgr.send(a.address, a.amountSat);
      ui.arkSent = { amountSat: a.amountSat };
      ui.arkSend = null;
    } catch (e) {
      ui.sendError = e.message;
    }
    ui.busy = false; render();
  }

  // ---- lightning via the ASP (captaind pays/holds invoices natively) -------
  // One poll timer per in-flight lightning action; cleared on settle.
  const arkLnTimers = new Map();
  function stopArkLnPoll(id) {
    const timer = arkLnTimers.get(id);
    if (timer) { clearInterval(timer); arkLnTimers.delete(id); }
  }
  function pollArkLn(id, onSettle) {
    stopArkLnPoll(id);
    // One held call brings the settlement the moment the server has it;
    // the interval below is the fallback pace if that call breaks.
    if (ark) {
      ark.awaitLnPay(id).then((a) => {
        if (a && ['done', 'failed'].includes(a.step) && arkLnTimers.has(id)) {
          stopArkLnPoll(id);
          onSettle(a);
        }
        render();
      }).catch(() => {});
    }
    arkLnTimers.set(id, setInterval(async () => {
      if (!ark) return;
      const a = await ark.driveLn(id).catch(() => null);
      if (a && ['done', 'failed'].includes(a.step)) {
        stopArkLnPoll(id);
        onSettle(a);
      }
      render();
    }, 2500));
  }

  // ---- background NWC mirror ---------------------------------------------
  // The service worker answers wallet-connect requests while the app is
  // closed, spending the SAME ark balance the app does. The mirror is the
  // full manager state plus the chain-3 keys for its live coins and a window
  // of upcoming change indices (the worker cannot derive). nwc.js decides
  // WHEN to mirror (background answering on) and supplies the connections.
  // connections/offer belong to the nwc feature; when it isn't the caller
  // (an auto-withdraw setting changed, say) carry forward what's mirrored
  // rather than blanking someone's wallet connections.
  async function writeBgMirror(connections, offer, prefs) {
    const cfg = getArkConfig();
    if (!cfg || !ark || !ark.info || !ark.state) return;
    const prev = await loadBg(wallet._cacheKey());
    if (connections === undefined) connections = (prev && prev.connections) || [];
    if (offer === undefined) offer = (prev && prev.offer) || null;
    if (prefs === undefined) prefs = (prev && prev.prefs) || undefined;
    const rec = buildBg({
      ark: { arkUrl: cfg.ark, esploraUrl: cfg.esplora, network: getNetwork(), serverPubkey: ark.info.serverPubkey },
      mgrState: ark.state,
      keyFor: (chain, i) => hex.encode(ark.account.deriveChild(chain).deriveChild(i).privateKey),
      connections,
      offer,
      autowithdraw: await awMirror(prev),
    });
    if (prev) rec.spends = prev.spends; // the worker's log survives rewrites
    if (prefs) rec.prefs = prefs; // notification choices the worker honours
    await saveBg(wallet._cacheKey(), rec);
    await disarmSiblingRecords(wallet._cacheKey(), rec).catch(() => {});
  }

  // On connect, fold whatever the worker did while we were closed back into
  // the live state: its spent flips and change vtxos merge in (the additive
  // merge never resurrects anything reconcile() disproves), its key
  // allocations advance ours, and its in-flight ln actions become resumable.
  async function mergeBgWorkerState(mgr) {
    const rec = await loadBg(wallet._cacheKey());
    if (!rec) return;
    absorbBgAutoWithdraw(rec);
    if (rec.v < 3) {
      await sweepLegacyPouch(rec).catch((e) => console.warn('ark: pouch sweep failed', e.message));
      return;
    }
    if (!rec.mgr) return;
    const merged = mergeArkStates(mgr.state, rec.mgr);
    // the worker's view of OUR vtxos is newer for anything it spent
    const workerState = new Map((rec.mgr.vtxos || []).map((v) => [v.id, v.state]));
    for (const v of merged.vtxos) {
      if (workerState.get(v.id) === 'spent') v.state = 'spent';
    }
    merged.nextKeyIndex = Math.max(merged.nextKeyIndex || 1, rec.mgr.nextKeyIndex || 1);
    mgr.state = merged;
    mgr._save();
    await mgr.reconcile().catch(() => {});
    await mgr.resumePending().catch(() => {});
  }

  // A leftover chain-6 pouch from before whole-balance background spending:
  // sweep its coins home using the keys stored in the record itself, then
  // let the next mirror write replace it.
  async function sweepLegacyPouch(rec) {
    if (!(rec.vtxos || []).some((v) => (v.state || 'spendable') === 'spendable')) return;
    const cfg = getArkConfig();
    const mgr = await connectArk();
    const shim = { deriveChild: () => ({ deriveChild: (i) => ({ privateKey: hex.decode(rec.keys[String(i)] || rec.keys['0']) }) }) };
    let state = {
      v: 1, serverPubkey: rec.ark?.serverPubkey || null, mailboxCheckpoint: 0,
      nextKeyIndex: rec.nextKeyIndex || 20,
      vtxos: (rec.mgr?.vtxos || rec.vtxos || []).map((v) => ({ ...v, state: v.state || 'spendable' })),
      actions: [], movements: [],
    };
    const pm = await new ArkManager({
      account: shim,
      storage: { load: () => state, save: (s2) => { state = s2; } },
      arkUrl: cfg.ark, esploraUrl: cfg.esplora, network: getNetwork(),
    }).init();
    const dest = mgr.address();
    for (let guard = 0; guard < 30; guard++) {
      const v = (pm.state.vtxos || []).find((x) => x.state === 'spendable');
      if (!v) break;
      await pm.send(dest, v.amountSat);
    }
    await saveBg(wallet._cacheKey(), { ...rec, vtxos: [], mgr: state, sweptAt: Date.now() });
  }

  // Pay a bolt11 with no UI at all — used by the NWC wallet service. Same
  // routing as the interactive path: the cheaper bridge first, the ASP's own
  // lightning-send as fallback. Resolves { preimage, feeSat, amountSat }.
  async function payInvoiceHeadless(invoice, { maxAmountSat } = {}) {
    const dec = maybeBolt11(invoice);
    if (!dec) throw new Error('not a bolt11 invoice');
    if (!dec.amountSat) throw new Error('zero-amount invoices are not supported');
    if (maxAmountSat && dec.amountSat > maxAmountSat) {
      throw new Error(`amount ${dec.amountSat} exceeds the limit of ${maxAmountSat} sat`);
    }
    const mgr = await connectArk();
    // The sync merge is additive, so a vtxo spent on another device can sit
    // in local state looking spendable until someone checks. The interactive
    // send path reconciles on intent; this headless path must too, or an NWC
    // payment picks the stale coin and the ASP rejects it ("state: spent").
    await mgr.reconcile().catch(() => {});

    // Up to three attempts: each failure refunds in full, and the next try
    // brings one extra sat of routing budget for liquidity that shifted
    // between the quote and the send.
    let last = null;
    for (let attempt = 0; attempt < 3; attempt++) {
      const routingFeeSat = attempt === 0 ? undefined : (last?.routingFeeSat ?? 0) + 1;
      const id = await mgr.payLnInvoice(invoice, { routingFeeSat });
      await mgr.awaitLnPay(id).catch(() => {});
      for (let i = 0; i < 60; i++) {
        const a = mgr.lnAction(id);
        if (!a || ['done', 'failed'].includes(a.step)) break;
        await new Promise((r) => setTimeout(r, 2000));
        await mgr.driveLn(id).catch(() => {});
      }
      const a = mgr.lnAction(id);
      if (a && a.step === 'done') return { preimage: a.preimage, feeSat: a.feeSat, amountSat: a.amountSat };
      last = a;
      if (a && a.step === 'failed' && !lnRetryable(a)) break;
      if (!a || a.step !== 'failed') break; // still pending after 2 min — don't double-pay
    }
    throw new Error(last?.error || last?.lastError || 'payment did not complete');
  }

  // A bolt11 lands in Send (via the swaps feature's delegation hook, or
  // directly when swaps is absent): take over when the ark balance can
  // plausibly cover it, else decline so the Boltz path handles it.
  function startArkLnPay(invoice, meta) {
    const dec = maybeLnInvoice(invoice);
    if (!dec || !arkAvailable() || wallet.watchOnly) return false;
    const s = arkStateNow();
    // Coverage by SUM: multi-input pays gather up to 24 coins, so judging by
    // the single largest coin declined invoices the wallet could pay — a
    // tester holding 204+29 sats pasted a ~220-sat invoice and nothing
    // happened at all. Fees are the quote's business, not this gate's.
    const sum = (state) =>
      (s ? (s.vtxos || []) : []).filter((v) => v.state === state).reduce((n, v) => n + v.amountSat, 0);
    // pending funds count for the take-over decision: an in-flight payment or
    // revocation frees them in seconds
    if (sum('spendable') < (dec.amountSat || 1) && sum('pending') < (dec.amountSat || 1)) return false;
    // Will this pay itself (an armed budget that covers it)? Known before the
    // quote — from the invoice amount and the stored budget — so the view can
    // go straight to a paying screen and never flash the review card first.
    const armedBudget = meta && meta.autopay && meta.budgetKey && ctx.lnBudget ? ctx.lnBudget(meta.budgetKey) : 0;
    const autopaying = !!(meta && meta.autopay && dec.amountSat != null && armedBudget > 0 && dec.amountSat <= armedBudget);
    ui.arkLnPay = { invoice, meta: meta || null, amountSat: dec.amountSat, amount: '', feeSat: null, status: 'quote', autopaying };
    ui.sendError = '';
    render();
    // An auto-pay recipient (a budget the user set) pays as soon as the quote
    // lands — no tap. Guarded to the budget and to a single fire; anything
    // off-script (over budget, no amount, a quote error) falls back to the
    // normal review with the Pay button.
    const maybeAutopay = () => {
      const p2 = ui.arkLnPay;
      if (!p2 || p2.invoice !== invoice || p2._autopaid) return;
      if (p2.status !== 'ready' || !p2.meta || !p2.meta.autopay || p2.amountSat == null) return;
      const budget = p2.meta.budgetKey && ctx.lnBudget ? ctx.lnBudget(p2.meta.budgetKey) : 0;
      if (!(budget > 0 && p2.amountSat <= budget)) return;
      p2._autopaid = true;
      doArkLnPay();
    };
    quoteArkLnPay(invoice, meta).then(maybeAutopay).catch(() => {
      // The quote is a nicety — a dead esplora or quote service must not
      // wedge the form at an eternal spinner (it did: "Getting a quote…"
      // above a Failed-to-fetch, Pay unreachable). Price it like the outage
      // fallback and let Pay proceed; the payment path quotes again with
      // its own fallbacks and locks only what the route actually needs.
      const p2 = ui.arkLnPay;
      if (!p2 || p2.invoice !== invoice) return;
      p2.feeSat = p2.amountSat ? Math.max(3, Math.ceil(p2.amountSat / 1000)) : null;
      p2.status = 'ready';
      ui.sendError = '';
      render();
      maybeAutopay();
    });
    return true;
  }

  // Quote (or re-quote) an in-form lightning pay: smallest vtxo that covers
  // amount + its expiry-based fee. Funds locked by a settling action retry
  // themselves free; genuinely insufficient funds hand off to Boltz.
  async function quoteArkLnPay(invoice, meta) {
    const mgr = await connectArk();
    const p = ui.arkLnPay;
    if (!p || p.invoice !== invoice) return;
    if (!p.amountSat) { p.status = 'ready'; render(); return; }
    const tip = await mgr.chain.tipHeight();
    // what the lightning network itself will charge (0 for coinos-to-coinos)
    const routing = await mgr.lnRouteFee(invoice, p.amountSat);
    if (!ui.arkLnPay || ui.arkLnPay !== p || p.invoice !== invoice) return;
    p.routingFeeSat = routing;
    const spendables = mgr.vtxos().filter((v) => v.state === 'spendable');
    let fee = null;
    for (const v of [...spendables].sort((a, b) => a.amountSat - b.amountSat)) {
      const f = lnSendFee(p.amountSat, mgr.info.lnSendFees, [v], tip) + routing;
      if (v.amountSat >= p.amountSat + f) { fee = f; break; }
    }
    if (fee == null) {
      // no single coin covers it — the pay path gathers several, so quote for
      // the same largest-first set it will pick
      const picked = [];
      let sum = 0;
      for (const v of [...spendables].sort((a, b) => b.amountSat - a.amountSat)) {
        picked.push(v); sum += v.amountSat;
        const f = lnSendFee(p.amountSat, mgr.info.lnSendFees, picked, tip) + routing;
        if (sum >= p.amountSat + f) { fee = f; break; }
      }
    }
    if (fee == null) {
      const pendingCover = mgr.vtxos().some((v) => v.state === 'pending' && v.amountSat >= p.amountSat);
      if (pendingCover) {
        p.status = 'fundsPending';
        render();
        mgr.resumePending().catch(() => {}); // nudge whatever holds them
        setTimeout(() => {
          if (ui.arkLnPay === p) quoteArkLnPay(invoice, meta).catch(() => {});
        }, 4000);
        return;
      }
      // can't cover once fees are in
      ui.arkLnPay = null;
      ui.sendError = t('arkLnPayFailed');
      render();
      return;
    }
    p.feeSat = fee;
    p.status = 'ready';
    render();
  }

  async function doArkLnPay() {
    const p = ui.arkLnPay;
    const sats = p.amountSat || ctx.parseAmount(p.amount, ctx.getUnit());
    if (!sats || sats <= 0) { ui.sendError = t('enterValidAmtForN', { n: 1 }); render(); return; }
    ui.busy = true; ui.sendError = ''; render();
    try {
      const mgr = await connectArk();
      // Routing conditions can shift between quote and send: a failed
      // (and fully refunded) attempt re-tries with one extra sat of routing
      // budget before giving up — askrene fees are exact, liquidity isn't.
      let tries = 0;
      const attempt = async (routingFeeSat) => {
        const id = await mgr.payLnInvoice(p.invoice, { amountSat: sats, routingFeeSat });
        const a = mgr.lnAction(id);
        if (['done', 'failed'].includes(a.step)) settle(a);
        else { p.actionId = id; p.status = 'paying'; pollArkLn(id, settle); }
      };
      const settle = (a) => {
        if (a.step === 'done') {
          ui.arkLnPaid = { amountSat: a.amountSat, meta: p.meta, autopaid: !!(p._autopaid || p.autopaying) };
          if (p.meta && p.meta.pk) noteZap('inv:' + p.invoice, p.meta.pk);
          // the user opted this recipient into auto-pay: remember the chosen
          // budget so future fixed charges from them clear without a tap
          if (p.setBudget && p.meta && p.meta.budgetKey && ctx.setLnBudget)
            ctx.setLnBudget(p.meta.budgetKey, p.setBudget);
          ui.arkLnPay = null;
        } else if (ui.arkLnPay) {
          if (tries < 2 && lnRetryable(a)) {
            tries += 1;
            p.retrying = tries; // the spinner narrates instead of stonewalling
            render();
            attempt((a.routingFeeSat ?? 0) + 1).catch((e) => {
              ui.arkLnPay.status = 'ready'; ui.sendError = e.message; render();
            });
            return;
          }
          ui.arkLnPay.status = 'ready';
          ui.sendError = a.error === 'payment failed' ? t('arkLnRefunded') : (a.error || t('arkLnPayFailed'));
        }
        render();
      };
      await attempt(p.routingFeeSat);
    } catch (e) {
      ui.sendError = e.message;
    }
    ui.busy = false; render();
  }

  // A failed lightning pay is worth re-trying with a bumped routing budget
  // unless the error says the attempt itself was ill-formed.
  function lnRetryable(a) {
    return !a?.error || !/already|invalid|expired|unpayable|insufficient|consolidate|no amount|exceeds/i.test(a.error);
  }

  // The most a Lightning pay can carry: the spendable sum over the 24-input
  // cap, minus the schedule fee and the conservative routing reserve. The
  // real quote at pay time confirms or trims — Max leaves a few sats on the
  // table rather than promising ones the fees will eat.
  function lnMaxSat() {
    const s = arkStateNow();
    const coins = (s ? (s.vtxos || []) : []).filter((v) => v.state === 'spendable')
      .sort((a2, b2) => b2.amountSat - a2.amountSat).slice(0, 24);
    const sum = coins.reduce((n, v) => n + v.amountSat, 0);
    if (!sum) return 0;
    const tip = (ark && ark._tipH) || 0;
    const fees = (ark && ark.info && ark.info.lnSendFees) || {};
    let amt = sum;
    for (let i = 0; i < 3; i++) {
      const f = lnSendFee(amt, fees, coins, tip) + Math.max(3, Math.ceil(amt / 1000));
      amt = sum - f;
    }
    return Math.max(0, amt);
  }
  const amountFill = (sat) => (ctx.getUnit() === 'sats' ? String(sat) : (sat / 1e8).toFixed(8));

  // Auto-pay progress + success as ONE structurally identical card, so the
  // paying → paid step is a class flip (spinner ring settles into the green
  // check, amount and recipient never move) instead of a text/layout swap. No
  // "Paying" wording at all — the badge animation carries the state.
  const autopayCard = (paid, meta, amountSat) =>
    h('div', {
      class: 'card col autopay-card' + (paid ? ' paid' : ''),
      style: 'align-items:center;text-align:center;gap:14px;padding:48px 20px' + (paid ? ';cursor:pointer' : ''),
      onClick: paid ? () => { ui.arkLnPaid = null; ui.send = blankSend(); render(); } : undefined,
    },
      h('div', { class: 'check-badge autopay-badge' }, '⚡'),
      meta && meta.name ? h('div', { class: 'small muted' }, meta.name) : null,
      h('div', { class: 'amount-neg', style: 'font-size:18px' }, '-' + fmtAmount(amountSat) + ' ' + unitLabel()),
      h('div', { class: 'small muted autopay-foot' }, paid ? t('tapToProceed') : ''));

  function arkLnPayView() {
    const u = ' ' + unitLabel();
    if (ui.arkLnPaid) {
      const zap = ui.arkLnPaid.meta;
      if (ui.arkLnPaid.autopaid) return autopayCard(true, zap, ui.arkLnPaid.amountSat);
      return h('div', {
        class: 'card col',
        style: 'align-items:center;text-align:center;gap:14px;cursor:pointer;padding:48px 20px',
        onClick: () => { ui.arkLnPaid = null; ui.send = blankSend(); render(); },
      },
        h('div', { class: 'check-badge' }, '⚡'),
        h('h2', { style: 'margin:0' }, zap && zap.social ? t('arkZapSentTitle') : t('arkLnPaidTitle')),
        zap && zap.name ? h('div', { class: 'small muted' }, zap.name) : null,
        h('div', { class: 'amount-neg', style: 'font-size:18px' }, '-' + fmtAmount(ui.arkLnPaid.amountSat) + u),
        h('div', { class: 'small muted' }, t('tapToProceed')));
    }
    const p = ui.arkLnPay;
    if (!p) return null;
    const zap = p.meta;
    // Auto-pay in flight: the progress half of the same card (see autopayCard).
    if (p.autopaying) return autopayCard(false, p.meta, p.amountSat);
    const row = (label, sats, bold) => h('div', { class: 'row between' + (bold ? '' : ''), style: bold ? 'font-weight:600' : '' },
      h('span', { class: bold ? '' : 'small muted' }, label), h('span', {}, fmtAmount(sats) + u));
    const total = (p.amountSat || 0) + (p.feeSat || 0);
    return h('div', { class: 'col', style: 'gap:12px' },
      h('div', { class: 'card col', style: 'gap:10px' },
        h('h3', { style: 'margin:0' }, '⚡ ' + (zap && zap.social ? t('lnZapReviewTitle') : t('lnPayTitle'))),
        h('div', { class: 'small muted' }, t('arkLnPayVia')),
        zap && (zap.name || zap.address) ? h('div', { class: 'small muted', style: 'word-break:break-all' }, zap.name || zap.address) : null,
        zap && zap.comment ? h('div', { class: 'small faint', style: 'font-style:italic;word-break:break-word' }, '“' + zap.comment + '”') : null,
        p.status === 'quote'
          ? h('div', { class: 'row gap6', style: 'align-items:center' }, h('span', { class: 'spinner sm' }), h('span', { class: 'small muted' }, t('lnQuoting')))
          : null,
        p.status === 'fundsPending'
          ? h('div', { class: 'row gap6', style: 'align-items:center' }, h('span', { class: 'spinner sm' }), h('span', { class: 'small muted' }, t('arkLnFundsPending')))
          : null,
        p.amountSat == null && p.status !== 'quote'
          ? h('div', { class: 'input-group' },
              h('input', { type: 'number', min: '0', inputmode: 'decimal', placeholder: t('lnPayAmount'), value: p.amount,
                onInput: (e) => { p.amount = e.target.value; } }),
              h('button', { type: 'button', onClick: () => { p.amount = amountFill(lnMaxSat()); render(); } }, t('max')),
              h('div', { style: 'display:flex;align-items:center' }, unitTag()))
          : null,
        p.amountSat != null ? row(t('lnPayAmount'), p.amountSat) : null,
        p.feeSat != null && p.feeSat > 0 ? row(t('arkLnFee'), p.feeSat) : null,
        p.amountSat != null && p.feeSat != null
          ? [h('div', { style: 'border-top:1px solid var(--line, #ddd);margin:2px 0' }), row(t('lnPayTotal'), total, true)]
          : null),
      ui.sendError ? h('div', { class: 'notice err' }, ui.sendError) : null,
      // Offer to skip this confirmation next time: pick a budget and future
      // fixed charges from this recipient up to it auto-pay without this
      // screen. The chosen amount is stored on a successful pay (see settle).
      (zap && zap.budgetKey && zap.fixedSat && !zap.autopay
        && p.status === 'ready'
        && !(ctx.lnBudget && ctx.lnBudget(zap.budgetKey) > 0))
        ? h('div', { class: 'col', style: 'gap:6px' },
            h('span', { class: 'small muted' }, t('lnAutopaySetLabel', { name: zap.name || zap.address || '' })),
            h('div', { class: 'row gap6', style: 'flex-wrap:wrap' },
              ...[1000, 5000, 10000, 100000].map((amt) =>
                h('button', { type: 'button',
                  class: (p.setBudget === amt ? 'btn-primary' : 'btn-ghost') + ' btn-sm',
                  onClick: () => { p.setBudget = p.setBudget === amt ? 0 : amt; render(); } },
                  fmtAmount(amt) + ' ' + unitLabel()))))
        : null,
      p.status === 'paying'
        ? h('div', { class: 'card row gap6', style: 'align-items:center' },
            h('span', { class: 'spinner sm' }),
            h('span', { class: 'small muted' },
              p.retrying ? t('arkLnRetrying', { n: p.retrying + 1, of: 3 }) : t('arkLnPaying')))
        : h('button', { class: 'btn-primary btn-block', disabled: !!ui.busy || p.status !== 'ready', onClick: doArkLnPay },
            ui.busy ? h('span', { class: 'spinner' }) : t('lnPayConfirm')),
      p.status !== 'paying'
        ? h('button', { class: 'btn-ghost btn-block', onClick: () => { ui.arkLnPay = null; ui.sendError = ''; ui.send = blankSend(); render(); } }, t('back'))
        : null);
  }

  async function doArkLnInvoice() {
    const sats = parseInt((ui.arkLnRecvAmt || '').trim(), 10);
    if (!sats) return;
    ui.arkBusy = 'lninvoice'; ui.arkError = ''; render();
    try {
      const mgr = await connectArk();
      const a = await mgr.createLnInvoice(sats);
      ui.arkLnRecvId = a.id;
      pollArkLn(a.id, () => render()); // 'done' -> celebration via unseenReceives
    } catch (e) {
      ui.arkError = e.message;
    }
    ui.arkBusy = null; render();
  }


  // Who a zap went to, keyed by what the movement records (the ark address
  // for direct zaps, the invoice for Lightning ones) — enough to put a face
  // on history rows without touching the manager's movement schema.
  const zapNotes = () => wallet.loadFeatureState('zapnotes', {});
  function noteZap(key, pk) {
    const s = zapNotes();
    s[key] = pk;
    const keys = Object.keys(s);
    if (keys.length > 200) for (const k of keys.slice(0, keys.length - 200)) delete s[k];
    wallet.saveFeatureState('zapnotes', s);
  }
  const zapNoteFor = (m) =>
    m.type === 'send' && m.to ? zapNotes()['to:' + m.to]
    : m.type === 'ln-send' && m.invoice ? zapNotes()['inv:' + m.invoice]
    : null;

  function arkHistoryItem(m) {
    const failed = m.status === 'failed';
    const incoming = !['send', 'offboard', 'exit', 'ln-send', 'refresh'].includes(m.type);
    const label = failed ? t('arkLnPayFailed') : m.type === 'receive' ? t('received') : m.type === 'board' ? t('arkBoarded')
      : m.type === 'ln-send' ? t('arkLnPaidHistory') : m.type === 'ln-receive' ? t('arkLnReceivedHistory')
      : m.type === 'offboard' ? t('arkOffboarded') : m.type === 'exit' ? t('arkExited')
      : m.type === 'refresh' ? t('arkRenewedHistory') : t('sent');
    // A spent input proves neither a payment amount nor its date: it can
    // contain change, an offboard, or a renewal this device has not synced.
    // Show the missing history explicitly until its records arrive.
    if (m.type === 'reconcile') {
      return h('div', {
        class: 'item', style: 'cursor:pointer',
        onClick: () => {
          ui.arkReconDetail = { amountSat: m.amountSat, ts: m.ts, vtxoIds: [...(m.vtxoIds || [])] };
          render();
        },
      },
        h('div', { class: 'ico' }, '↻'),
        h('div', { class: 'grow' },
          h('div', {}, t('arkHistoryIncomplete')),
          h('div', { class: 'small faint' }, t('arkDetailsNotSynced'))),
        h('div', { style: 'text-align:right' },
          h('div', { class: 'small muted' }, fmtAmount(m.amountSat, m.ts / 1000) + ' ' + unitLabel())));
    }
    // a renewal moves nothing anywhere — its history amount is what it COST
    if (m.type === 'refresh') {
      return h('div', { class: 'item', style: 'cursor:pointer', onClick: () => { ui.arkMoveDetail = m.id; render(); } },
        h('div', { class: 'ico' }, '↻'),
        h('div', { class: 'grow' },
          h('div', {}, label),
          h('div', { class: 'small faint' }, timeAgo(m.ts / 1000))),
        h('div', { style: 'text-align:right' },
          m.feeSat > 0
            ? h('div', { class: 'amount-neg' }, '-' + fmtAmount(m.feeSat))
            : h('div', { class: 'small faint' }, t('arkDepthFree'))));
    }
    return h(
      'div',
      { class: 'item', style: 'cursor:pointer', onClick: () => { ui.arkMoveDetail = m.id; render(); } },
      // The circle's glyph names the RAIL the money actually rode: ⚡ for
      // Lightning (including a receive the registrar forwarded from an LN
      // settlement — viaLn, matched against its receipts), the Bitcoin mark
      // for the on-chain movements (board pulls coins in from chain;
      // offboard/exit push them back out — each is a real tx with a txid),
      // and the Ark mark for pure off-chain hops.
      // Direction is carried by the tint + signed amount, no text chip.
      m.type.startsWith('ln-') || m.viaLn
        ? h('div', { class: `ico ${incoming ? 'in' : 'out'}` }, '⚡')
        : ONCHAIN_ARK.has(m.type)
          ? h('div', { class: `ico ${incoming ? 'in' : 'out'}`, html: BITCOIN_ICON(20) })
          : h('div', { class: `ico ${incoming ? 'in' : 'out'}`, html: ARK_MARK(15) }),
      h('div', { class: 'grow' },
        h('div', { class: 'row gap6', style: 'align-items:center' },
          (() => {
            const g = giftForMovement(m);
            if (!g) return label;
            return h('span', {}, '🎁 ' + t('giftHistoryTitle'), ' ',
              h('span', { class: g.claimed ? 'tag conf' : 'tag' },
                g.claimed ? t('giftClaimedTag') : g.revoked ? t('giftRevokedTag') : t('giftUnclaimedTag')));
          })(),
          (() => { const pk = zapNoteFor(m); return pk ? ctx.hook('profileChip', pk) : null; })(),
          m.status !== 'complete' && !failed ? h('span', { class: 'tag pending' }, m.status) : null),
        h('div', { class: 'small faint' }, timeAgo(m.ts / 1000))),
      h('div', { style: 'text-align:right' },
        // in fiat this is what the payment was worth when it was made
        h('div', { class: failed ? 'muted' : incoming ? 'amount-pos' : 'amount-neg' }, (failed ? '' : incoming ? '+' : '-') + fmtAmount(m.amountSat, m.ts / 1000)))
    );
  }

  const exitStartedTs = (a) => Number((a.id || '').split('-')[1]) || Date.now();
  // Only link a tx that is KNOWN to be out there: the claim, a confirmed
  // hop, or the finished chain. Guessing from lastError made the link
  // flicker in time with the retry loop.
  const exitWatchTxid = (a) => a.claimTxid
    || (a.step !== 'chain' ? (a.txids || [])[(a.txids || []).length - 1]
      : a.hopsDone > 0 ? (a.txids || [])[Math.min(a.hopsDone, (a.txids || []).length - 1)]
      : null);

  function arkExitActionItem(a) {
    return h('div', { class: 'item', style: 'cursor:pointer', onClick: () => { ui.arkExitDetail = a.id; render(); } },
      h('div', { class: 'ico out', html: ARK_MARK(15) }),
      h('div', { class: 'grow' },
        h('div', { class: 'row gap6', style: 'align-items:center' },
          t('arkExitingHistory'), h('span', { class: 'tag pending' }, t('arkExitPendingTag'))),
        h('div', { class: 'small faint' }, timeAgo(exitStartedTs(a) / 1000))),
      h('div', { style: 'text-align:right' },
        h('div', { class: 'amount-neg' }, '-' + fmtAmount(a.amountSat))));
  }

  function arkExitActionDetail(a) {
    const exitDelta = (ark && ark.info && ark.info.vtxoExitDelta) || 144;
    const blocks = a.step === 'chain' ? ((a.txids || []).length - (a.hopsDone || 0)) + exitDelta + 1
      : a.step === 'timelock' ? Math.max(0, a.claimableAt - (a.tipSeen || 0)) + 1 : 1;
    const mins = blocks * 10;
    const eta = getNetwork() === 'regtest' ? t('arkExitSoon')
      : mins >= 2880 ? `${Math.round(mins / 1440)} days`
      : mins >= 120 ? `${Math.round(mins / 60)} hours`
      : `${mins} minutes`;
    const watch = exitWatchTxid(a);
    const url = watch ? wallet.api.explorerTx(watch) : null;
    const cancellable = a.actionable && !(a.hopsDone > 0) && a.step === 'chain';
    const row = (k, v) => h('div', { class: 'row between', style: 'gap:12px' },
      h('span', { class: 'small muted', style: 'flex-shrink:0' }, k), h('span', { class: 'small', style: 'text-align:right;word-break:break-all' }, v));
    return h('div', { class: 'card col', style: 'gap:10px' },
      h('div', { class: 'row gap6', style: 'align-items:center' },
        h('span', { html: ARK_ICON(18) }),
        h('h3', { style: 'margin:0' }, t('arkExitingHistory')),
        h('span', { class: 'tag pending' }, t('arkExitPendingTag'))),
      h('div', { class: 'amount-neg', style: 'font-size:20px' }, '-' + fmtAmount(a.amountSat) + ' ' + unitLabel()),
      row(t('dateLabel'), new Date(exitStartedTs(a)).toLocaleString()),
      h('div', { class: 'small muted' }, t('arkExitSummary', { n: fmtSats(a.amountSat), eta })),
      a.lastError ? h('div', { class: a.actionable ? 'small err' : 'small faint' }, a.actionable ? a.lastError : t('arkExitRetrying')) : null,
      url ? h('a', { class: 'btn btn-sm', href: url, target: '_blank', rel: 'noopener' }, t('arkExitViewTx')) : null,
      cancellable ? h('button', { class: 'linklike small', onClick: () => {
        a.step = 'failed';
        const v = ark && ark._vtxo(a.vtxoId);
        if (v && v.state === 'pending') v.state = 'spendable';
        if (ark) ark._save();
        ui.arkExitDetail = null;
        render();
      } }, t('arkExitCancel')) : null,
      h('button', { class: 'btn-ghost btn-block', onClick: () => ctx.goBack(() => { ui.arkExitDetail = null; }) }, t('back')));
  }

  // One label, N monospace coin ids — the send detail's consumed inputs and
  // the reconcile detail's vanished coins share the shape.
  const coinListRows = (label, ids) => !ids || !ids.length ? null
    : h('div', { class: 'col', style: 'gap:4px' },
        ...ids.map((id, i) => h('div', { class: 'row between', style: 'gap:12px' },
          h('span', { class: 'small muted', style: 'flex-shrink:0' }, i === 0 ? label : ''),
          h('span', { class: 'small', style: 'text-align:right;word-break:break-all' }, shortTxid(id)))));

  // Detail for a folded reconcile row: the hard facts only — when this wallet
  // learned of it, the original coin total, and which coins were consumed.
  function arkReconDetailView(d) {
    const row = (k, v) => h('div', { class: 'row between', style: 'gap:12px' },
      h('span', { class: 'small muted', style: 'flex-shrink:0' }, k),
      h('span', { class: 'small', style: 'text-align:right;word-break:break-all' }, v));
    return h('div', { class: 'card col', style: 'gap:10px' },
      h('div', { class: 'row gap6', style: 'align-items:center' },
        h('span', { html: ARK_ICON(18) }),
        h('h3', { style: 'margin:0' }, t('arkHistoryIncomplete'))),
      h('div', { class: 'small muted' }, t('arkHistoryIncompleteHelp')),
      row(t('arkOriginalCoins'), fmtAmount(d.amountSat) + ' ' + unitLabel()),
      row(t('arkDetectedAt'), new Date(d.ts).toLocaleString()),
      coinListRows((d.vtxoIds || []).length > 1 ? t('arkVtxoInputs') : t('arkVtxoId'), d.vtxoIds),
      h('button', { class: 'btn-ghost btn-block', onClick: () => ctx.goBack(() => { ui.arkReconDetail = null; }) }, t('back')));
  }

  function arkMoveDetailView(m) {
    const failed = m.status === 'failed';
    const incoming = m.type === 'refresh' ? false : !['send', 'offboard', 'exit', 'ln-send'].includes(m.type);
    const label = failed ? t('arkLnPayFailed') : m.type === 'receive' ? t('received') : m.type === 'board' ? t('arkBoarded')
      : m.type === 'ln-send' ? t('arkLnPaidHistory') : m.type === 'ln-receive' ? t('arkLnReceivedHistory')
      : m.type === 'offboard' ? t('arkOffboarded') : m.type === 'exit' ? t('arkExited')
      : m.type === 'refresh' ? t('arkRenewedHistory') : t('sent');
    const row = (k, v) => h('div', { class: 'row between', style: 'gap:12px' },
      h('span', { class: 'small muted', style: 'flex-shrink:0' }, k), h('span', { class: 'small', style: 'text-align:right;word-break:break-all' }, v));
    const url = m.txid ? wallet.api.explorerTx(m.txid) : null;
    return h(
      'div',
      { class: 'card col', style: 'gap:10px' },
      h('div', { class: 'row gap6', style: 'align-items:center' },
        // the rail the user chose is the one to show: a payment SENT over
        // Lightning stays Lightning here, however it settled underneath; an
        // on-chain move (board/offboard/exit) wears the Bitcoin mark
        m.type.startsWith('ln-') || m.viaLn ? h('span', { style: 'font-size:18px' }, '⚡')
          : ONCHAIN_ARK.has(m.type) ? h('span', { html: BITCOIN_ICON(18) })
          : h('span', { html: ARK_ICON(18) }),
        h('h3', { style: 'margin:0' }, label),
        m.status !== 'complete' && !failed ? h('span', { class: 'tag pending' }, m.status) : null),
      m.type === 'refresh'
        ? h('div', { class: m.feeSat > 0 ? 'amount-neg' : 'small faint', style: 'font-size:20px' },
            m.feeSat > 0 ? '-' + fmtAmount(m.feeSat) + ' ' + unitLabel() : t('arkDepthFree'))
        : h('div', { class: failed ? 'muted' : incoming ? 'amount-pos' : 'amount-neg', style: 'font-size:20px' },
            (failed ? '' : incoming ? '+' : '-') + fmtAmount(m.amountSat, m.ts / 1000) + ' ' + unitLabel()),
      row(t('dateLabel'), new Date(m.ts).toLocaleString()),
      ctx.worthLine ? ctx.worthLine(m.amountSat, m.ts / 1000, row) : null,
      (() => {
        const pk = zapNoteFor(m);
        const chip = pk ? ctx.hook('profileChip', pk) : null;
        return chip
          ? h('div', { class: 'row between', style: 'gap:12px;align-items:center' },
              h('span', { class: 'small muted' }, t('recipient')),
              chip)
          : null;
      })(),
      m.to ? row(t('arkPayTo'), shortAddr(m.to, 16, 12)) : null,
      m.vtxoId ? row(t('arkVtxoId'), shortTxid(m.vtxoId)) : null,
      // the coins this payment consumed — a send can gather up to 24 inputs
      coinListRows(t('arkVtxoInputs'), m.inputIds),
      // An offboard's fee is two different pockets — the miners' cut for the
      // on-chain weight and the ASP's service charge (base + lifetime ppm) —
      // shown apart so neither reads as the other being overpriced.
      m.chainFeeSat != null && m.serviceFeeSat != null
        ? h('div', { class: 'col', style: 'gap:10px' },
            row(t('arkFeeChain'), fmtAmount(m.chainFeeSat) + ' ' + unitLabel()),
            row(t('arkFeeService'), fmtAmount(m.serviceFeeSat) + ' ' + unitLabel()))
        : m.detail ? row(t('detailsLabel'), m.detail) : null,
      // proof of payment: the preimage is what a merchant asks for (its copy
      // button rides the grouped small-button row below with the others)
      m.preimage ? row(t('preimageLabel'), shortTxid(m.preimage)) : null,
      // A send that funded a bearer gift: show its fate, and while unclaimed
      // the sweep-back — the copy-link lives in the grouped small-button row
      // below, next to the other copy actions.
      (() => {
        const g = giftForMovement(m);
        if (!g) return null;
        refreshArkGiftRecords();
        const open = !g.claimed && !g.revoked;
        return h('div', { class: 'col', style: 'gap:8px;border-top:1px solid var(--border,rgba(128,128,128,.2));padding-top:10px' },
          h('div', { class: 'row gap6', style: 'align-items:center' },
            h('span', {}, '🎁 ' + t('giftHistoryTitle')),
            h('span', { class: g.claimed ? 'tag conf' : 'tag' },
              g.claimed ? t('giftClaimedTag') : g.revoked ? t('giftRevokedTag') : t('giftUnclaimedTag'))),
          open ? (ui.busy && ui.revokeId === g.id
            ? h('button', { class: 'btn-block btn-danger', disabled: true }, h('span', { class: 'spinner sm' }))
            : h('button', { class: 'btn-block btn-danger', onClick: async () => {
                ui.revokeId = g.id; ui.busy = true; render();
                try { await doArkGiftRevoke(g.id); toast(t('giftArkRevoked')); }
                catch (e) { toast(e.message); }
                ui.busy = false; ui.revokeId = null; render();
              } }, t('giftRevoke'))) : null);
      })(),
      m.txid
        ? h('div', { class: 'col', style: 'gap:6px' },
            h('div', { class: 'small muted' }, t('transactionId')),
            h('div', { class: 'addr-box', style: 'width:100%' }, m.txid))
        : null,
      // All the small copy/view actions travel TOGETHER in one wrapping row at
      // their natural width — not each stretched full-width and split apart by
      // the block buttons. The block actions (Revoke above, Back below) own
      // the full width; these are secondary and read as a cluster.
      (() => {
        const g = giftForMovement(m);
        const open = g && !g.claimed && !g.revoked;
        const chips = [
          open ? copyBtn(`${location.origin}/g/${encodeArkGiftCode(getNetwork(), g.amountSat, hex.decode(g.secretHex))}`, t('giftCopyLinkAgain')) : null,
          m.preimage ? copyBtn(m.preimage, t('copyPreimage')) : null,
          m.txid ? copyBtn(m.txid, t('copyTxid')) : null,
          m.txid ? h('a', { class: 'btn btn-sm', href: url, target: '_blank', rel: 'noopener', onClick: (e) => { e.preventDefault(); openExternal(url); } }, t('viewOnMempool')) : null,
          m.to ? copyBtn(m.to, t('copyAddress')) : null,
        ].filter(Boolean);
        return chips.length ? h('div', { class: 'row gap6 wrap' }, ...chips) : null;
      })(),
      h('button', { class: 'btn-ghost btn-block', onClick: () => ctx.goBack(() => { ui.arkMoveDetail = null; }) }, t('back'))
    );
  }

  async function doArkBoard() {
    const sats = parseInt((ui.arkBoardAmt || '').trim(), 10);
    if (!sats) return;
    ui.arkBusy = 'board'; ui.arkError = ''; render();
    let unfunded = null; // the action id, until the funding tx is on the wire
    try {
      const { actionId, fundingAddress, feeSat } = await ark.startBoard(sats);
      unfunded = actionId;
      const feeRate = (wallet.feeRates && wallet.feeRates.halfHourFee) || 5;
      const draft = wallet.buildTx({ recipients: [{ address: fundingAddress, amount: sats }], feeRate, noSort: true });
      const hexTx = wallet.sign(draft.tx);
      const txid = await wallet.broadcast(hexTx);
      unfunded = null; // money moved — this action must live on whatever happens next
      // Like the main send flow: reflect the spend locally and let the
      // poll/watcher reconcile. A scan here would race the explorer's indexing
      // and could resurrect the just-spent coin.
      wallet.applySentTx(draft.tx);
      await ark.completeBoard(actionId, txid);
      ui.arkBoardAmt = '';
      ui.arkBoarded = { txid, netSat: sats - feeSat };
    } catch (e) {
      // A board that never funded is not in flight. Leaving the stub at
      // 'created' looked like an in-flight action forever — which silently
      // blocked auto-renewal (it refuses to start a round beside one).
      if (unfunded && ark && ark.state) {
        const a = (ark.state.actions || []).find((x) => x.id === unfunded);
        if (a && !a.fundingTxid) { a.step = 'failed'; a.error = e.message; try { ark._save(); } catch {} }
      }
      ui.arkError = e.message;
    }
    ui.arkBusy = null; render();
  }

  // ---- ark zaps (draft protocol, NIP-61-shaped) ----------------------------
  // Lightning zaps (NIP-57) are built around LNURL + bolt11; ark needs
  // neither. Mirroring nutzaps (NIP-61): the recipient announces their ark
  // address as a replaceable event, the sender pays with a plain instant
  // arkoor send and publishes a receipt referencing the delivered vtxo.
  // Kinds are provisional until a NIP lands.
  const ARK_INFO_KIND = 10037; // replaceable: ["ark", <address>], ["network", <net>]
  const ARK_ZAP_KIND = 9737;   // receipt: ["p", pk], ["e", note?], ["amount", sats], ["vtxo", id], ["network", net], ["P", sender?]
  // The receipt is signed by the wallet key, which has no profile. When the
  // wallet is linked to a nostr login, name that identity as the sender (the
  // same "P" tag NIP-57 receipts use) so the zap reads as the person, not
  // as an npub nobody recognizes.
  const zapSenderTag = () => {
    const id = ctx.hook('nostrLoginIdentity');
    const me = wallet.nostrPubkey && wallet.nostrPubkey();
    return id && id.pubkey && id.pubkey !== me ? [['P', id.pubkey]] : [];
  };

  // npub decode without importing the nostr stack (keeps ark-only builds lean)
  function npubToHex(s) {
    try {
      const { prefix, words } = bech32.decode(String(s || '').trim(), 200);
      if (prefix !== 'npub') return null;
      return hex.encode(new Uint8Array(bech32.fromWords(words)));
    } catch { return null; }
  }

  // Tell the world where our ark mailbox lives (once per address, and only
  // when the sync/nostr feature is present in this build).
  function announceArkAddress(mgr) {
    if (!wallet.nostrPublish) return;
    const addr = mgr.address();
    if (mgr._zapAnnounced === addr) return;
    mgr._zapAnnounced = addr;
    wallet.nostrPublish({ kind: ARK_INFO_KIND, tags: [['ark', addr], ['network', getNetwork()]] }).catch(() => {});
  }

  // Resolve an npub to a same-network ark address via their announcement.
  // Paying a PERSON (an npub): resolve every way they can be paid and take
  // the best — ark over lightning over on-chain.
  //   1. their ark address: the kind-10037 advert, or an ark= instruction in
  //      BIP-353 (their coinos name via the registrar, or their nip05 name's
  //      own DNS record — a bare domain nip05 is the BIP-353 "_" user)
  //   2. lightning: profile lud16/lud06, via the zap flow
  //   3. an on-chain address from the BIP-353 record
  const NAMES_REGISTRAR = 'https://names.coinos.io';
  function startNpubPay(pk, npub, eventId = null, autoSat = 0) {
    const z = { npub, pk, eventId, amount: '', comment: '', status: 'lookup', autoSat };
    // A one-tap post zap has no card: it resolves and pays off-screen, so a
    // second tap — the same post again, or another — never evicts the one
    // already in the air. Everything else takes the send screen's zap slot.
    const instant = !!(autoSat && eventId);
    if (!instant) {
      ui.arkZap = z;
      ui.zap = null; // a stale Lightning-zap card must not resurface behind ours
      ui.sendError = '';
      render();
    }
    const live = () => instant || ui.arkZap === z;
    // The tap already put a pulsing chip on the note being zapped: whichever
    // way this goes, say so, so the chip settles instead of pulsing until it
    // times out. (A handover to the Lightning flow doesn't report — that flow
    // is still carrying the same zap, and reports for itself.)
    const bail = (error) => {
      if (!z.autoSat) return; // a form zap: the card keeps the screen and its own status
      ctx.hook('zapSettled', z.eventId, false);
      z.autoSat = 0;
      if (z.eventId) {
        if (ui.arkZap === z) ui.arkZap = null;
        toast('⚡ ' + (error || t('arkZapNoArk')), 4000);
        return true;
      } else ctx.showSend();
    };
    // an instant zap: resolution succeeded — pay the default amount now, no
    // form. Post zaps settle in place; other payments retain their form.
    const auto = async (label) => {
      try {
        await performArkZap(z, z.autoSat);
        if (ui.arkZap === z) ui.arkZap = null;
        ctx.hook('zapSettled', z.eventId, true, z.autoSat);
        if (!z.eventId) toast('⚡ ' + t('zapSentShort', { n: fmtAmount(z.autoSat) + ' ' + unitLabel() }));
        render();
      } catch (e) {
        if (!bail(e.message)) ui.sendError = e.message;
        render();
      }
    };
    (async () => {
      connectArk().catch(() => {});
      // 1a. ark advert
      const adv = await lookupArkZapTarget(pk).catch(() => ({ status: 'noark' }));
      if (!live()) return;
      if (adv.status === 'ready') { Object.assign(z, adv); if (z.autoSat) return auto(); render(); return; }
      if (adv.status === 'wrongnet') { Object.assign(z, adv); bail(t('arkGiftWrongNet', { net: adv.net })); render(); return; }
      // 1b. BIP-353 with an ark instruction; remember on-chain as last resort
      const uris = [];
      try {
        const j = await (await fetch(`${NAMES_REGISTRAR}/pubkey/${pk}`)).json();
        if (j && j.uri) uris.push(j.uri);
      } catch {}
      const profile = wallet.nostrProfile ? await wallet.nostrProfile(pk).catch(() => null) : null;
      if (!live()) return;
      if (profile && typeof profile.nip05 === 'string' && profile.nip05.trim()) {
        const nip05 = profile.nip05.trim().toLowerCase();
        const parsed = parsePaymentName(nip05.includes('@') ? nip05 : '_@' + nip05);
        if (parsed) {
          try { const uri = await resolveBip353(parsed.name, parsed.domain); if (uri) uris.push(uri); } catch {}
        }
      }
      if (!live()) return;
      let onchain = null;
      for (const uri of uris) {
        const dec = parseBip21Uri(uri);
        if (!dec) continue;
        const arkAddr = dec.params && dec.params.ark;
        if (arkAddr && isArkAddress(arkAddr)) {
          Object.assign(z, { status: 'ready', address: arkAddr });
          if (z.autoSat) return auto();
          render();
          return;
        }
        if (dec.onchain && !onchain) onchain = dec.onchain;
      }
      // 2. lightning via the zap flow (connect first — canLnPay needs it)
      if (profile && (profile.lud16 || profile.lud06)) {
        await connectArk().catch(() => {});
        if (!live()) return;
        if (ctx.hook('canLnZap')) { if (ui.arkZap === z) ui.arkZap = null; ctx.hook('lnZapNpub', pk, npub, z.eventId, z.autoSat); return; }
      }
      // 3. on-chain fallback
      if (onchain) {
        if (z.autoSat && z.eventId) { bail(); render(); return; }
        ui.arkZap = null;
        ui.send.recipients[0].address = onchain;
        bail();
        render();
        return;
      }
      if (live()) { z.status = 'noark'; bail(); render(); }
    })().catch((e) => { if (live()) { z.status = 'noark'; if (!bail(e.message)) ui.sendError = e.message; render(); } });
  }

  // shared by the ark and lightning zap flows (see zaps.js for the twin)
  function zapSkeleton(pk, fallback) {
    return h('div', { class: 'card col', style: 'gap:12px' },
      h('h3', {}, '⚡ ' + t('zapTitle')),
      (pk && ctx.hook('profileChip', pk, 'lg'))
        || h('div', { class: 'small muted break' }, fallback || ''),
      h('div', { class: 'row gap6', style: 'align-items:center;padding:6px 0' },
        h('span', { class: 'spinner sm' }),
        h('span', { class: 'small muted' }, t('zapFinding'))),
      h('button', { class: 'btn-ghost btn-block', onClick: () => {
        ui.arkZap = null; ui.zap = null; ui.sendError = ''; ui.send = blankSend(); render();
      } }, t('back')));
  }

  async function lookupArkZapTarget(pk) {
    const events = await wallet.nostrFetch({ kinds: [ARK_INFO_KIND], authors: [pk] }, 6000);
    const ev = (events || []).sort((a, b) => b.created_at - a.created_at)[0];
    if (!ev) return { status: 'noark' };
    const addr = (ev.tags.find((t) => t[0] === 'ark') || [])[1];
    const net = (ev.tags.find((t) => t[0] === 'network') || [])[1];
    if (!addr) return { status: 'noark' };
    if (net && net !== getNetwork()) return { status: 'wrongnet', net };
    return { status: 'ready', address: addr };
  }

  // The zap itself, shared by the form and the one-tap default-amount path.
  async function performArkZap(z, sats) {
    const mgr = await connectArk();
    const actionId = await mgr.send(z.address, sats);
    const action = mgr.state.actions.find((a) => a.id === actionId);
    if (!action || action.step === 'failed') throw new Error(action?.error || t('claimFailed'));
    const vtxoId = decodeVtxo(hex.decode((action.destBytesList || [action.destBytes])[0])).id;
    noteZap('to:' + z.address, z.pk);
    // the receipt is best-effort: the sats are already delivered via mailbox
    await wallet.nostrPublish({
      kind: ARK_ZAP_KIND,
      content: (z.comment || '').slice(0, 280),
      tags: [['p', z.pk], ...(z.eventId ? [['e', z.eventId]] : []),
        ['amount', String(sats)], ['vtxo', vtxoId], ['network', getNetwork()], ...zapSenderTag()],
    }).catch(() => {});
  }

  async function doArkZap() {
    const z = ui.arkZap;
    const sats = ctx.parseAmount(z.amount, ctx.getUnit());
    if (!sats || sats <= 0) { ui.sendError = t('enterValidAmtForN', { n: 1 }); render(); return; }
    ui.busy = true; ui.sendError = ''; render();
    try {
      await performArkZap(z, sats);
      ctx.hook('zapSettled', z.eventId, true, sats); // the tally shows it now, not when the receipt lands
      ui.arkZapped = { amountSat: sats, npub: z.npub };
      ui.arkZap = null;
    } catch (e) {
      ui.sendError = e.message;
    }
    ui.busy = false; render();
  }

  // No ark address published: the zap leaves anyway, as an ark gift locked to
  // their nostr key. The sats move into a bearer vtxo now; the public link is
  // safe to put in the receipt because only the recipient's key — or the
  // claim code we DM them — opens it. Unclaimed, it stays revocable from the
  // gift card like any other ark gift.
  async function doArkZapGift() {
    const z = ui.arkZap;
    const sats = ctx.parseAmount(z.amount, ctx.getUnit());
    if (!sats || sats <= 0) { ui.sendError = t('enterValidAmtForN', { n: 1 }); render(); return; }
    if (sats > (arkBalance()?.spendableSat || 0)) { ui.sendError = t('giftExceedsBalance'); render(); return; }
    ui.busy = true; ui.sendError = ''; render();
    try {
      const g = await createArkGift(sats, z.pk);
      const locked = ctx.hook('lockArkGift', g.code, sats, z.pk);
      if (!locked) throw new Error(t('claimFailed')); // no gifts feature in this build
      noteZap('to:' + g.address, z.pk);
      const done = (ui.arkZapped = { amountSat: sats, npub: z.npub, gift: { url: locked.url, claimCode: locked.claimCode, dm: 'sending' } });
      ui.arkZap = null;
      // best-effort receipt; carries the locked link so the recipient can
      // discover the gift from the note even if the DM never lands
      await wallet.nostrPublish({
        kind: ARK_ZAP_KIND,
        content: (z.comment || '').slice(0, 280),
        tags: [['p', z.pk], ...(z.eventId ? [['e', z.eventId]] : []),
          ['amount', String(sats)], ['network', getNetwork()], ['gift', locked.url], ...zapSenderTag()],
      }).catch(() => {});
      const dmText = t('giftDmText', { amount: fmtAmount(sats) + ' ' + unitLabel(), link: locked.url, code: locked.claimCode });
      if (wallet.sendNostrDM) {
        wallet.sendNostrDM(z.pk, dmText)
          .then((ok) => { done.gift.dm = ok ? 'sent' : 'failed'; render(); })
          .catch(() => { done.gift.dm = 'failed'; render(); });
      } else done.gift.dm = 'failed';
    } catch (e) {
      ui.sendError = e.message;
    }
    ui.busy = false; render();
  }

  function arkZapView() {
    // While resolving, show the SHAPE of the card that's coming — same
    // title, same recipient chip, a spinner where the form will be. The
    // screen fills in rather than being replaced.
    if (ui.arkZap && ui.arkZap.status === 'lookup') return zapSkeleton(ui.arkZap.pk, ui.arkZap.npub);
    if (ui.arkZapped) {
      const gift = ui.arkZapped.gift;
      const finish = () => { ui.arkZapped = null; ui.send = blankSend(); render(); };
      if (!gift) {
        return h('div', {
          class: 'card col',
          style: 'align-items:center;text-align:center;gap:14px;cursor:pointer;padding:48px 20px',
          onClick: finish,
        },
          h('div', { class: 'check-badge' }, '⚡'),
          h('h2', { style: 'margin:0' }, t('arkZapSentTitle')),
          h('div', { class: 'amount-neg', style: 'font-size:18px' }, '-' + fmtAmount(ui.arkZapped.amountSat) + ' ' + unitLabel()),
          h('div', { class: 'small muted' }, t('tapToProceed')));
      }
      // A locked-gift zap has aftercare: the DM's fate, and the link + claim
      // code to pass along by hand when the DM couldn't be delivered.
      return h('div', { class: 'card col', style: 'align-items:center;text-align:center;gap:12px;padding:28px 16px' },
        h('div', { class: 'check-badge' }, '🎁'),
        h('h2', { style: 'margin:0' }, t('arkZapGiftSentTitle')),
        h('div', { class: 'amount-neg', style: 'font-size:18px' }, '-' + fmtAmount(ui.arkZapped.amountSat) + ' ' + unitLabel()),
        gift.dm === 'sending'
          ? h('div', { class: 'row gap6', style: 'align-items:center' }, h('span', { class: 'spinner sm' }), h('span', { class: 'small muted' }, t('giftDmSending')))
          : gift.dm === 'sent'
            ? h('div', { class: 'small', style: 'color:var(--green)' }, t('giftDmSent'))
            : h('div', { class: 'notice info', style: 'text-align:left' }, t('giftDmFailed')),
        h('div', { class: 'addr-box break', style: 'width:100%;font-size:11px' }, gift.url),
        h('div', { class: 'row gap6 wrap', style: 'justify-content:center' },
          copyBtn(gift.url, t('copyLink')),
          gift.dm !== 'sent' ? copyBtn(gift.claimCode, t('giftCopyCode')) : null),
        h('button', { class: 'btn-primary btn-block', onClick: finish }, t('done')));
    }
    const z = ui.arkZap;
    if (!z) return null;
    const spendable = arkBalance()?.spendableSat || 0;
    // No ark address found — but a zap can still leave as an ark gift locked
    // to their nostr key, when this build carries the gifts feature.
    const giftOk = z.status === 'noark' && !wallet.watchOnly && spendable >= 1 && !!ctx.hook('canLockGift');
    const amountInputs = (hint) => h('div', { class: 'col gap6' },
      h('div', { class: 'input-group' },
        h('input', { type: 'number', min: '0', inputmode: 'decimal', placeholder: t('lnPayAmount'), value: z.amount,
          onInput: (e) => { z.amount = e.target.value; } }),
        h('button', { type: 'button', onClick: () => { z.amount = amountFill(lnMaxSat()); render(); } }, t('max')),
        h('div', { style: 'display:flex;align-items:center' }, unitTag())),
      h('input', { type: 'text', class: 'mono-input', placeholder: t('arkZapCommentPh'), value: z.comment,
        onInput: (e) => { z.comment = e.target.value; } }),
      h('div', { class: 'small faint' }, hint));
    return h('div', { class: 'card col', style: 'gap:12px' },
      h('h3', {}, '⚡ ' + t('zapTitle')),
      ctx.hook('profileChip', z.pk, 'lg') || h('div', { class: 'small muted', style: 'word-break:break-all' }, z.npub),
      z.status === 'lookup' ? h('div', { class: 'row gap6', style: 'align-items:center' }, h('span', { class: 'spinner sm' }), h('span', { class: 'small muted' }, t('arkZapLookup'))) : null,
      z.status === 'noark' && !giftOk ? h('div', { class: 'notice err' }, t('arkZapNoArk')) : null,
      giftOk ? h('div', { class: 'notice info' }, t('arkZapNoArkGift')) : null,
      giftOk ? amountInputs(t('arkZapGiftHint')) : null,
      giftOk
        ? (ui.busy
            ? h('button', { class: 'btn-primary btn-block', disabled: true }, h('span', { class: 'spinner' }))
            : h('button', { class: 'btn-primary btn-block', onClick: doArkZapGift }, '🎁 ' + t('arkZapGiftBtn')))
        : null,
      z.status === 'wrongnet' ? h('div', { class: 'notice err' }, t('arkGiftWrongNet', { net: z.net })) : null,
      // No Ark address, but they may still take a Lightning zap — hand off to
      // the zaps feature (present alongside swaps).
      (z.status === 'noark' || z.status === 'wrongnet') && ctx.hook('canLnZap')
        ? h('button', { class: (giftOk ? '' : 'btn-primary ') + 'btn-block', disabled: !!ui.busy, onClick: () => { ctx.hook('lnZapNpub', z.pk, z.npub, z.eventId); } }, '⚡ ' + t('lnZapFallback'))
        : null,
      z.status === 'ready' && spendable < 330
        ? h('div', { class: 'notice info' }, t('zapNoBalance'))
        : z.status === 'ready'
        ? amountInputs(t('arkZapHint'))
        : null,
      ui.sendError ? h('div', { class: 'notice err' }, ui.sendError) : null,
      h('div', { class: 'row gap6' },
        h('button', { class: 'btn-ghost', onClick: () => { ui.arkZap = null; ui.sendError = ''; ui.send = blankSend(); render(); } }, t('back')),
        z.status === 'ready' && spendable >= 330
          ? (ui.busy
              ? h('button', { class: 'btn-primary grow', disabled: true }, h('span', { class: 'spinner' }))
              : h('button', { class: 'btn-primary grow', onClick: doArkZap }, t('arkZapBtn')))
          : null));
  }

  // ---- auto-withdraw --------------------------------------------------------
  // Forward Spending onward once it crosses a threshold. Same destinations the
  // send form takes — an ark address, a payment name, a lightning address, an
  // npub, or an on-chain address — resolved through the same paths, just
  // without a human present. Deliberately conservative: one transfer at a
  // time, never while another action is in flight, and a failure backs off
  // instead of retrying in a loop.

  const awState = () => wallet.loadFeatureState('autowithdraw', {});
  const awSave = (v) => wallet.saveFeatureState('autowithdraw', v);

  // What kind of destination is this, and can we pay it at all? Returns
  // { kind, address } or null. Resolution that needs the network (BIP-353,
  // LNURL, npub profiles) happens at send time, not here.
  function awClassify(dest) {
    const d = (dest || '').trim();
    if (!d) return null;
    if (isArkAddress(d)) return { kind: 'ark', address: d };
    if (parsePaymentName(d)) return { kind: 'name', address: d };
    if (npubToHex(d)) return { kind: 'npub', address: d };
    if (/^lnurl1[ac-hj-np-z02-9]+$/i.test(d)) return { kind: 'lnurl', address: d };
    try {
      btc.Address(wallet.netCfg.net).decode(d);
      return { kind: 'onchain', address: d };
    } catch {}
    return null;
  }

  // Turn any destination into something payable right now.
  async function awResolve(dest) {
    const c = awClassify(dest);
    if (!c) throw new Error(t('awBadDest'));
    if (c.kind === 'ark' || c.kind === 'onchain') return c;
    // a payment name may carry an ark instruction (free) or fall back to LNURL
    if (c.kind === 'name') {
      const p = parsePaymentName(c.address);
      const uri = await resolveBip353(p.name, p.domain).catch(() => null);
      const dec = uri ? parseBip21Uri(uri) : null;
      const arkAddr = dec && dec.params && dec.params.ark;
      if (arkAddr && isArkAddress(arkAddr)) return { kind: 'ark', address: arkAddr };
      if (dec && dec.onchain) return { kind: 'onchain', address: dec.onchain };
      return { kind: 'lnaddr', address: c.address };
    }
    if (c.kind === 'npub') {
      const pk = npubToHex(c.address);
      const adv = await lookupArkZapTarget(pk).catch(() => null);
      if (adv && adv.status === 'ready') return { kind: 'ark', address: adv.address };
      const profile = wallet.nostrProfile ? await wallet.nostrProfile(pk).catch(() => null) : null;
      if (profile && profile.lud16) return { kind: 'lnaddr', address: profile.lud16 };
      throw new Error(t('awBadDest'));
    }
    return { kind: c.kind === 'lnurl' ? 'lnurl' : 'lnaddr', address: c.address };
  }

  async function awPay(target, amountSat) {
    const mgr = await connectArk();
    if (target.kind === 'ark') {
      await mgr.send(target.address, amountSat);
      return;
    }
    if (target.kind === 'onchain') {
      const spk = btc.OutScript.encode(btc.Address(wallet.netCfg.net).decode(target.address));
      // Offboarding moves whole vtxos, so carve out the exact amount first
      // when we're not sending everything.
      const spendables = () => mgr.state.vtxos.filter((v) => v.state === 'spendable');
      const total = spendables().reduce((n, v) => n + v.amountSat, 0);
      let ids;
      if (amountSat < total) {
        let exact = spendables().find((v) => v.amountSat === amountSat);
        if (!exact) {
          const before = new Set(spendables().map((v) => v.id));
          await mgr.send(mgr.address(), amountSat);
          for (let i = 0; i < 30 && !exact; i++) {
            await new Promise((r) => setTimeout(r, 2000));
            await mgr.sync().catch(() => {});
            exact = spendables().find((v) => v.amountSat === amountSat && !before.has(v.id));
          }
          if (!exact) throw new Error(t('arkSplitTimeout'));
        }
        ids = [exact.id];
      }
      await mgr.startOffboard(spk, target.address, ids);
      return;
    }
    // lightning: ask their server for an invoice, pay it over ark
    const zt = parseZapTarget(target.address);
    if (!zt || !zt.url) throw new Error(t('awBadDest'));
    const params = await fetchPayParams(zt.url);
    const msat = amountSat * 1000;
    if (msat < params.minSendable || msat > params.maxSendable) throw new Error(t('awOutOfRange'));
    const invoice = await requestInvoice(params, { amountMsat: msat, lnurlBech32: zt.lnurlBech32 });
    await mgr.payLnInvoice(invoice, { amountSat });
  }

  // What the service worker gets: the setting plus a destination it can pay
  // without a relay. Resolution can fail (DNS down, profile missing) — then we
  // keep whatever we mirrored last rather than dropping the feature.
  async function awMirror(prev) {
    const st = awState();
    if (!st.on || !st.dest) return null;
    const prevAw = prev && prev.autowithdraw;
    let target = prevAw && prevAw.dest === st.dest ? prevAw.target : null;
    try {
      const r = await awResolve(st.dest);
      target = { kind: r.kind, address: r.address };
      if (r.kind === 'lnaddr' || r.kind === 'lnurl') {
        const zt = parseZapTarget(r.address);
        if (zt && zt.url) target.url = zt.url; else target = null;
      } else if (r.kind === 'onchain') {
        target.spkHex = hex.encode(btc.OutScript.encode(btc.Address(wallet.netCfg.net).decode(r.address)));
      }
    } catch {}
    if (!target) return null;
    return {
      on: true, dest: st.dest, target,
      threshold: Number(st.threshold) || 0,
      keep: Math.max(0, Number(st.keep) || 0),
      failedAt: st.failedAt || 0,
    };
  }

  // What the worker did while we were closed becomes the app's state again.
  function absorbBgAutoWithdraw(rec) {
    const bg = rec && rec.autowithdraw;
    if (!bg) return;
    const st = awState();
    if (!st.on) return;
    if ((bg.lastAt || 0) > (st.lastAt || 0)) awSave({ ...st, lastAt: bg.lastAt, lastSat: bg.lastSat, failedAt: 0, error: '' });
    else if ((bg.failedAt || 0) > (st.failedAt || 0)) awSave({ ...st, failedAt: bg.failedAt, error: bg.error || '' });
  }

  let awBusy = false;
  async function maybeAutoWithdraw(mgr) {
    const st = awState();
    if (!st.on || !st.dest || wallet.watchOnly || awBusy) return;
    if (Date.now() - (st.failedAt || 0) < 15 * 60_000) return; // backing off
    if ((mgr.state.actions || []).some((a) => !['done', 'failed'].includes(a.step))) return;
    const spendable = (mgr.state.vtxos || [])
      .filter((v) => v.state === 'spendable').reduce((n, v) => n + v.amountSat, 0);
    const threshold = Number(st.threshold) || 0;
    const keep = Math.max(0, Number(st.keep) || 0);
    if (!threshold || spendable < threshold) return;
    const amount = spendable - keep;
    if (amount < 330) return;
    awBusy = true;
    try {
      const target = await awResolve(st.dest);
      await awPay(target, amount);
      const s2 = awState();
      awSave({ ...s2, lastAt: Date.now(), lastSat: amount, failedAt: 0, error: '' });
      toast(t('awSent', { n: fmtAmount(amount) + ' ' + unitLabel() }));
      render();
    } catch (e) {
      const s2 = awState();
      awSave({ ...s2, failedAt: Date.now(), error: e.message || String(e) });
      console.warn('auto-withdraw failed:', e.message);
    } finally {
      awBusy = false;
    }
  }

  // The exit-cost tradeoff, surfaced only when it's real: every off-chain
  // hop a coin accumulates makes its trustless exit one on-chain transaction
  // more expensive; a renewal flattens the history back to a single hop.
  // Most users never need to think about this — the card only appears once
  // coins run deep enough for the difference to matter.
  const EXIT_DEPTH_ADVISORY = 4;
  // Pricing the advisory is EC-heavy: it decodes every spendable coin (for its
  // genesis depth) and builds the exit transactions (estimateExitFeeSat). Doing
  // that synchronously in the render path was the cold cost behind a carousel
  // drag stutter right after a refresh. So the render only READS the cached
  // answer, and the recompute runs in idle time — never competing with input.
  let _depthKey = null, _depthComputing = false;
  function computeDepthAdvisory() {
    if (!ark || !ark.state) return;
    const spend = (ark.state.vtxos || []).filter((v) => v.state === 'spendable');
    const feeRate = Math.max(1, (wallet.feeRates && wallet.feeRates.halfHourFee) || 2);
    const key = feeRate + '|' + spend.map((v) => v.id).join(',');
    if (key === _depthKey || _depthComputing) return; // already priced this exact set
    _depthComputing = true;
    const run = () => {
      try {
        let depth = 0;
        for (const v of spend) { try { depth = Math.max(depth, ark._decoded(v).genesis.length); } catch {} }
        let show = false, exitFee = 0;
        if (spend.length && depth >= EXIT_DEPTH_ADVISORY) {
          try { exitFee = estimateExitFeeSat(ark); } catch {}
          const afterFee = Math.ceil(530 * feeRate); // one coin, one hop post-renewal
          show = afterFee < exitFee; // renewing has to actually help
        }
        _depthKey = key;
        const cached = wallet.loadFeatureState('arkDepth', null);
        if (!cached || cached.show !== show || cached.exitFee !== exitFee) {
          wallet.saveFeatureState('arkDepth', { show, exitFee });
          render();
        }
      } finally { _depthComputing = false; }
    };
    if (typeof requestIdleCallback === 'function') requestIdleCallback(run, { timeout: 2000 });
    else setTimeout(run, 200);
  }
  function exitDepthNotice() {
    if (!arkAvailable() || wallet.watchOnly) return null;
    // Render is cheap: paint the last computed answer immediately (so the line
    // doesn't pop in and shove layout), and kick an idle recompute if the coin
    // set changed. The heavy EC never runs in the render/interaction path.
    if (ark && ark.state) computeDepthAdvisory();
    const cached = wallet.loadFeatureState('arkDepth', null);
    return cached && cached.show ? t('arkDepthNotice', { fee: fmtSats(cached.exitFee) }) : null;
  }

  // The screen behind that notice's Manage link: every spendable coin with
  // its expiry and arkoor depth, what an uncooperative exit costs today, and
  // what a renewal costs and buys.
  function arkCoinsPage() {
    const mgr = ark;
    const spend = ((mgr && mgr.state && mgr.state.vtxos) || []).filter((v) => v.state === 'spendable');
    const tip = (mgr && mgr._tipH) || 0;
    const back = () => { ui.arkCoinsPage = null; ui.arkCoinsSel = null; render(); };
    if (!spend.length) { ui.arkCoinsPage = null; return null; } // nothing left to manage
    const totalSat = spend.reduce((n, v) => n + v.amountSat, 0);
    let exitFee = 0; try { exitFee = estimateExitFeeSat(mgr); } catch {}
    const feeRate = Math.max(1, (wallet.feeRates && wallet.feeRates.halfHourFee) || 2);
    const afterFee = Math.ceil(530 * feeRate);
    // relative and terse — "14d" / "13h" beside the hourglass — a date says
    // less than a countdown, and a coin past its height says so plainly
    // instead of the shifty "0h" (the server still honors it; the wallet's
    // next renewal round sweeps it up).
    const expiresOf = (v) => {
      if (!v.expiryHeight || !tip) return '—';
      const blocks = v.expiryHeight - tip;
      if (blocks <= 0) return t('arkCoinsExpired');
      return blocks >= 144 ? Math.round(blocks / 144) + 'd' : Math.max(1, Math.round(blocks / 6)) + 'h';
    };
    // what pulling THIS coin on-chain alone would cost: every hop's fee
    // child plus the claim, at today's rate (the whole-balance figure below
    // is the same sum over all coins)
    const exitFeeOf = (v) => {
      try {
        let f = Math.ceil(150 * feeRate);
        for (const vsize of exitTxVsizes(mgr._decoded(v), mgr.serverPub)) f += Math.ceil((vsize + 130) * feeRate);
        return f;
      } catch { return null; }
    };
    // The server prices a renewal by how much lifetime each coin still
    // carries (its ppm bracket) — waiting IS cheaper, and inside the final
    // bracket it's free, where the wallet renews on its own anyway.
    const table = ((mgr.info || {}).refreshFees || {}).ppmExpiryTable || [];
    const roundMins = Math.max(1, Math.round(((mgr.info || {}).roundIntervalSecs || 120) / 60));
    const roundEvery = roundMins === 1 ? t('arkCoinsRoundEveryOne') : t('arkCoinsRoundEvery', { n: roundMins });
    const ppmFor = (blocks) => (table.filter((e) => e.thresholdBlocks <= blocks).pop()?.ppm) ?? 0;
    // A coin's SHARE of the renewal fee, fractional: the server totals the
    // ppm across every coin in the round and rounds up once (refreshFee), so
    // a 1-sat coin costs a few thousandths of a sat, not the 1 sat a
    // per-coin ceiling used to print — nine such chips summing past the
    // real total made it look as if the page were skipping them.
    const feeNowOf = (v) => (v.amountSat * ppmFor((v.expiryHeight || 0) - tip)) / 1_000_000;
    const renewChip = (share) => share <= 0 ? t('arkDepthFree')
      : share < 1 ? t('arkCoinsChipRenewTiny')
      : fmtAmount(Math.round(share)) + ' ' + unitLabel();
    const span = (blocks) => {
      if (blocks >= 144) {
        const d = Math.round(blocks / 144);
        return d === 1 ? t('arkCoinsSpanDay') : t('arkCoinsSpanDays', { n: d });
      }
      const hs = Math.max(1, Math.round(blocks / 6));
      return hs === 1 ? t('arkCoinsSpanHour') : t('arkCoinsSpanHours', { n: hs });
    };
    const schedule = [...table].sort((a, b) => b.thresholdBlocks - a.thresholdBlocks).map((e, i, arr) => ({
      label: e.ppm === 0
        ? t('arkCoinsSchedFinal', { span: span(arr[i - 1] ? arr[i - 1].thresholdBlocks : 144) })
        : i === 0
          ? t('arkCoinsSchedOver', { span: span(e.thresholdBlocks) })
          : t('arkCoinsSchedBetween', { a: span(e.thresholdBlocks), b: span(arr[i - 1].thresholdBlocks) }),
      cost: e.ppm === 0 ? t('arkDepthFree') : (e.ppm / 10000).toLocaleString(undefined, { maximumFractionDigits: 3 }) + '%',
      free: e.ppm === 0,
    }));
    // Which coins ride the renewal: all by default (the one-button behavior),
    // any subset by unticking. Selection is per-visit; ids that vanished
    // (spent meanwhile) drop out silently.
    const ids = new Set(spend.map((v) => v.id));
    if (!(ui.arkCoinsSel instanceof Set)) ui.arkCoinsSel = new Set(ids);
    for (const id of ui.arkCoinsSel) if (!ids.has(id)) ui.arkCoinsSel.delete(id);
    const sel = ui.arkCoinsSel;
    const selCoins = spend.filter((v) => sel.has(v.id));
    let selFee = 0; try { selFee = mgr.refreshFee(selCoins, tip); } catch {}
    const renew = () => {
      if (!selCoins.length) return;
      // fire and let the round machinery carry it — rounds can be an hour out
      mgr.refresh(selCoins.map((v) => v.id)).catch((e) => toast(e.message));
      toast(t('arkDepthRenewed'));
      ui.arkCoinsSel = null;
      back();
    };
    const tick = (checked, onChange, title) => h('input', {
      type: 'checkbox', checked, title, style: 'flex:0 0 auto;margin:0', onChange,
    });
    return h('div', { class: 'col', style: 'gap:16px' },
      h('div', { class: 'card col', style: 'gap:8px' },
        h('h3', { style: 'margin:0' }, t('arkCoinsTitle')),
        h('p', { class: 'small muted', style: 'margin:0' },
          spend.length === 1
            ? t('arkCoinsIntroOne', { total: fmtAmount(totalSat) + ' ' + unitLabel() })
            : t('arkCoinsIntro', { n: spend.length, total: fmtAmount(totalSat) + ' ' + unitLabel() })),
        // One coin per row, two lines: the amount (with its renewal price on
        // the right — the number this page's action spends), then a faint
        // meta line. Five flexed columns fit a laptop but wrapped into
        // confetti on a phone; labels riding inline with each value need no
        // header row and no horizontal budget at all. `.coin` brings the
        // on-chain coin-control look — hairlines between rows, big accent
        // checkboxes — so the two coin pages read as siblings.
        // One coin per row in a headed table — the labels live in the header
        // once instead of on every row as chips. It scrolls sideways on a
        // narrow screen (the wrapper, not the page) rather than wrapping.
        // A tap anywhere on a row toggles it.
        h('div', { class: 'coin-scroll' },
          h('table', { class: 'coin-table' },
            h('thead', {}, h('tr', {},
              h('th', {}, tick(sel.size === ids.size, (e) => {
                ui.arkCoinsSel = e.target.checked ? new Set(ids) : new Set();
                render();
              }, t('arkCoinsSelectAll'))),
              h('th', { class: 'num' }, t('arkCoinsColAmount')),
              h('th', { class: 'num', title: t('arkCoinsChipExpTitle') }, t('arkCoinsColExpiry')),
              h('th', { class: 'num', title: t('arkCoinsChipExitTitle') }, t('arkCoinsColExit')),
              h('th', { class: 'num', title: t('arkCoinsChipRenewTitle') }, t('arkCoinsColRenew')))),
            h('tbody', {}, ...spend.map((v) => {
              const f = feeNowOf(v);
              const xf = exitFeeOf(v);
              const due = !!(v.expiryHeight && tip && v.expiryHeight - tip <= 0);
              const toggle = () => { sel.has(v.id) ? sel.delete(v.id) : sel.add(v.id); render(); };
              return h('tr', {
                class: 'clickable',
                onClick: (e) => { if (e.target.tagName !== 'INPUT') toggle(); },
              },
                h('td', {}, tick(sel.has(v.id), toggle)),
                h('td', { class: 'num' }, fmtAmount(v.amountSat), h('span', { class: 'small faint' }, ' ' + unitLabel())),
                h('td', { class: 'num' + (due ? ' warn' : '') }, expiresOf(v)),
                h('td', { class: 'num' }, xf == null ? '—' : fmtAmount(xf), xf == null ? null : h('span', { class: 'small faint' }, ' ' + unitLabel())),
                h('td', { class: 'num' }, renewChip(f)));
            }))))),
      h('div', { class: 'card col', style: 'gap:8px' },
        h('h4', { style: 'margin:0' }, t('arkCoinsExitTitle')),
        h('p', { class: 'small muted', style: 'margin:0' },
          t('arkCoinsExitDesc', { fee: fmtSats(exitFee), after: fmtSats(afterFee) }))),
      h('div', { class: 'card col', style: 'gap:8px' },
        h('h4', { style: 'margin:0' }, t('arkCoinsRenewTitle')),
        // the round cadence comes from the server (it has been an hour and
        // is two minutes as of September 2026) — never a number baked in here
        h('p', { class: 'small muted', style: 'margin:0' }, t('arkCoinsRenewDesc', { every: roundEvery })),
        schedule.length ? h('div', { class: 'col', style: 'gap:2px;margin:2px 0' },
          ...schedule.map((r) => h('div', { class: 'row between' },
            h('span', { class: 'small muted' }, r.label),
            h('span', { class: 'small' + (r.free ? ' faint' : '') }, r.cost)))) : null,
        h('button', { class: 'btn-primary btn-block', disabled: !!ui.arkBusy || !selCoins.length, onClick: renew },
          !selCoins.length ? t('arkCoinsRenewNone')
            : selCoins.length < spend.length
              ? t('arkCoinsRenewSome', { n: selCoins.length, fee: selFee > 0 ? fmtAmount(selFee) + ' ' + unitLabel() : t('arkDepthFree') })
              : selFee > 0 ? t('arkCoinsRenewNowFee', { fee: fmtAmount(selFee) + ' ' + unitLabel() }) : t('arkDepthRenewBtn'))),
      h('button', { class: 'btn-ghost btn-block', onClick: back }, t('back')));
  }

  function autoWithdrawCard() {
    if (!arkAvailable() || wallet.watchOnly) return null;
    const st = awState();
    const draft = ui.awDraft || (ui.awDraft = { dest: st.dest || '', threshold: String(st.threshold || ''), keep: String(st.keep || '') });
    const save = (on) => {
      const dest = (draft.dest || '').trim();
      const threshold = parseInt(String(draft.threshold).replace(/[^0-9]/g, ''), 10) || 0;
      const keep = parseInt(String(draft.keep).replace(/[^0-9]/g, ''), 10) || 0;
      if (on) {
        if (!awClassify(dest)) { ui.awError = t('awBadDest'); render(); return; }
        if (threshold < 1000) { ui.awError = t('awLowThreshold'); render(); return; }
        if (keep >= threshold) { ui.awError = t('awKeepTooHigh'); render(); return; }
      }
      ui.awError = '';
      awSave({ ...st, on, dest, threshold, keep, failedAt: 0, error: '' });
      writeBgMirror().catch(() => {}); // the worker needs the new destination
      toast(on ? t('awOn') : t('awOff'));
      render();
    };
    return h('div', { class: 'card col' },
      h('h3', {}, t('awTitle')),
      h('p', { class: 'small muted', style: 'margin:0' }, t('awDesc')),
      h('label', { class: 'field' },
        h('span', { class: 'lab' }, t('awDest')),
        h('input', {
          type: 'text', class: 'mono-input', placeholder: t('awDestPh'),
          autocapitalize: 'none', autocomplete: 'off', spellcheck: 'false',
          value: draft.dest,
          onInput: (e) => { draft.dest = e.target.value; },
        })),
      h('div', { class: 'row gap6' },
        h('label', { class: 'field grow' },
          h('span', { class: 'lab' }, t('awThreshold')),
          h('input', {
            type: 'number', inputmode: 'numeric', min: '0', placeholder: '100000',
            value: draft.threshold, onInput: (e) => { draft.threshold = e.target.value; },
          })),
        h('label', { class: 'field grow' },
          h('span', { class: 'lab' }, t('awKeep')),
          h('input', {
            type: 'number', inputmode: 'numeric', min: '0', placeholder: '0',
            value: draft.keep, onInput: (e) => { draft.keep = e.target.value; },
          }))),
      ui.awError ? h('div', { class: 'notice err small' }, ui.awError) : null,
      st.on && st.error ? h('div', { class: 'notice err small' }, t('awLastError', { why: st.error })) : null,
      st.lastAt
        ? h('div', { class: 'small faint' }, t('awLast', { n: fmtAmount(st.lastSat || 0) + ' ' + unitLabel(), when: new Date(st.lastAt).toLocaleString() }))
        : null,
      st.on
        ? h('div', { class: 'row gap6' },
            h('button', { class: 'grow', onClick: () => save(true) }, t('save')),
            h('button', { class: 'btn-ghost', onClick: () => save(false) }, t('awTurnOff')))
        : h('button', { class: 'btn-primary btn-block', onClick: () => save(true) }, t('awTurnOn')));
  }

  // ---- NWC bridge funding (PoC) --------------------------------------------
  // An external NWC wallet service (e.g. coinos) can bridge ark -> lightning:
  // a nostr client asks IT to pay_invoice, it asks US (kind 23196, funding
  // request) to cover the amount over ark, we auto-pay within a user-set
  // allowance and ack (kind 23197). Custody window = seconds in flight.
  // PoC config in localStorage 'btc-wallet-arknwc': { bridgePk, budgetSat }.
  const NWC_FUND_KIND = 23196;
  const NWC_FUND_ACK_KIND = 23197;
  let nwcUnsub = null;
  let nwcSpent = 0;

  function stopNwcFunding() {
    if (nwcUnsub) { try { nwcUnsub(); } catch {} nwcUnsub = null; }
  }

  function startNwcFunding(mgr) {
    if (nwcUnsub || !wallet.nostrSubscribe || !wallet.nostrPubkey || !wallet.nostrPubkey()) return;
    let cfg = null;
    try { cfg = JSON.parse(localStorage.getItem('btc-wallet-arknwc') || 'null'); } catch {}
    if (!cfg || !cfg.bridgePk || !(cfg.budgetSat > 0)) return;
    const seen = new Set();
    nwcUnsub = wallet.nostrSubscribe(
      { kinds: [NWC_FUND_KIND], authors: [cfg.bridgePk], '#p': [wallet.nostrPubkey()] },
      async (ev) => {
        if (seen.has(ev.id)) return;
        seen.add(ev.id);
        let req;
        try { req = JSON.parse(ev.content); } catch { return; }
        const sats = Math.round(req.amountSat || 0);
        if (!sats || !req.address || nwcSpent + sats > cfg.budgetSat) return; // over allowance: bridge times out
        try {
          const actionId = await mgr.send(req.address, sats);
          const action = mgr.state.actions.find((a) => a.id === actionId);
          if (!action || action.step === 'failed') return;
          nwcSpent += sats;
          await wallet.nostrPublish({
            kind: NWC_FUND_ACK_KIND,
            tags: [['p', cfg.bridgePk], ['e', ev.id]],
            content: JSON.stringify({ id: req.id }),
          });
        } catch {}
      });
  }

  // ---- unilateral exit (trustless: no server cooperation) ------------------
  const addrScript = (address) => btc.OutScript.encode(btc.Address(wallet.netCfg.net).decode(address));

  // Smallest confirmed, unreserved coin that can fund a CPFP bump.
  function pickFeeCoin(minSat) {
    return wallet.utxos
      .filter((u) => u.confirmed && !wallet.isReserved(utxoId(u)) && u.value >= minSat)
      .sort((a, b) => a.value - b.value)[0] || null;
  }

  // What a unilateral exit will need from Savings, BEFORE it starts: every
  // chain hop is a zero-fee tx bumped by a ~130 vB CPFP child, plus the
  // final claim. Priced at today's feerate — the driver reprices per hop.
  // Sizes only (exitTxVsizes): building the real signed chain costs several
  // secp256k1 multiplies per hop, and across 27 coins of depth ~13 that was
  // 5+ seconds of main-thread work on every boot (idle callback or not).
  // Fee = size × rate needs none of it. Still memoized on the coin set +
  // feerate, since the advisory asks on every wallet render.
  let _exitFeeMemo = { key: null, val: 0 };
  function estimateExitFeeSat(mgr) {
    const feeRate = Math.max(1, (wallet.feeRates && wallet.feeRates.halfHourFee) || 2);
    const coins = mgr.vtxos().filter((x) => x.state === 'spendable');
    const key = feeRate + '|' + coins.map((v) => v.id).join(',');
    if (_exitFeeMemo.key === key) return _exitFeeMemo.val;
    let total = 0;
    for (const v of coins) {
      try {
        for (const vsize of exitTxVsizes(mgr._decoded(v), mgr.serverPub))
          total += Math.ceil((vsize + 130) * feeRate);
        total += Math.ceil(150 * feeRate); // the claim tx
      } catch {}
    }
    _exitFeeMemo = { key, val: total };
    return total;
  }

  async function doArkExit() {
    ui.arkBusy = 'exit'; ui.arkError = ''; render();
    try {
      const mgr = await connectArk();
      const spendables = mgr.vtxos().filter((v) => v.state === 'spendable');
      if (!spendables.length) throw new Error(t('arkNotConnected'));
      // Fees are paid hop by hop from Savings as the exit unrolls — an exit
      // that can't fund its hops just stalls at step zero. Refuse to start
      // one Savings can't carry, with the number on the table.
      const feeEst = estimateExitFeeSat(mgr);
      if ((wallet.spendable || 0) < feeEst) {
        throw new Error(t('arkExitFeeShort', { need: fmtSats(feeEst), have: fmtSats(wallet.spendable || 0) }));
      }
      for (const v of spendables) mgr.startExit(v.id);
      toast(t('arkExitStarted', { n: spendables.length }));
      driveExits(mgr).catch(() => {});
    } catch (e) {
      ui.arkError = e.message;
    }
    ui.arkBusy = null; render();
  }

  async function driveExits(mgr) {
    const open = mgr.state.actions.filter((a) => a.type === 'exit' && !['done', 'failed'].includes(a.step));
    for (const a of open) {
      try {
        await driveExit(mgr, a);
        if (a.lastError) { delete a.lastError; delete a.actionable; mgr._save(); } // resolved
      } catch (e) {
        a.lastError = e.message;
        a.actionable = !!e.actionable; // user must act (e.g. fund fees) vs. plain retry
        mgr._save();
      }
    }
  }

  // One tick of an exit's state machine: broadcast the next unconfirmed hop
  // (with its fee child) as a package, then wait out the CSV, then claim.
  async function driveExit(mgr, action) {
    const rec = mgr._vtxo(action.vtxoId);
    const decoded = mgr._decoded(rec);
    if (action.step === 'chain') {
      const txs = signedExitTxs(decoded, mgr.serverPub);
      let lastConfirmedHeight = 0;
      let hopsDone = 0;
      for (const txi of txs) {
        const st = await mgr.chain.getTxStatus(txi.txid);
        if (st?.confirmed) { lastConfirmedHeight = st.block_height; hopsDone++; if (action.hopsDone !== hopsDone) { action.hopsDone = hopsDone; mgr._save(); } continue; }
        // /tx/:txid/status answers {confirmed:false} even for UNKNOWN txids
        // (electrs + mempool.space) — only /tx/:txid 404s definitively
        if (await mgr.chain.getTxHex(txi.txid)) return; // in mempool — wait
        // unknown to the chain: submit this hop + CPFP child as a package
        const feeRate = Math.max(1, (wallet.feeRates && wallet.feeRates.halfHourFee) || 2);
        // the child pays for the whole package (the parent is zero-fee)
        const feeSat = Math.ceil((txi.vsize + 130) * feeRate); // child ≈ 130 vB
        const coin = pickFeeCoin(Math.max(294, feeSat - txi.anchorValue + 294));
        if (!coin) {
          // No on-chain coin for the fee child. Try the hop bare — a node
          // that relays zero-fee txs (regtest with minrelaytxfee=0) needs no
          // bump. If it refuses, this is a PRECONDITION the user must fix,
          // not a transient to retry behind a vague message.
          try {
            await submitPackage(mgr.esploraUrl, [txi.hex]);
            mgr._save();
            return;
          } catch {
            const e = new Error(t('arkExitNoFeeCoin', { need: fmtSats(Math.max(294, feeSat)) }));
            e.actionable = true;
            throw e;
          }
        }
        const changeAddr = wallet.freshChange().address;
        const child = buildBumpChild({
          parentTxidInternal: txi.txidInternal, anchorVout: txi.anchorVout, anchorValue: txi.anchorValue,
          coin: {
            txid: coin.txid, vout: coin.vout, value: coin.value,
            pubkey: wallet.derive(coin.chain, coin.index).pubkey,
            privkey: wallet.node(coin.chain, coin.index).privateKey,
          },
          changeScript: addrScript(changeAddr), feeSat,
        });
        await submitPackage(mgr.esploraUrl, [txi.hex, child.hex]);
        // reflect the spent fee coin locally so nothing double-spends it
        wallet.utxos = wallet.utxos.filter((u) => !(u.txid === coin.txid && u.vout === coin.vout));
        const ce = wallet.addrMap.get(changeAddr);
        if (ce) wallet.utxos.push({ txid: child.txid, vout: 0, value: child.changeSat, address: changeAddr, chain: ce.chain, index: ce.index, confirmed: false });
        wallet._recomputeBalanceFromUtxos();
        wallet.saveCache();
        action.bumpTxid = child.txid;
        mgr._save();
        return; // one hop per tick (TRUC: single unconfirmed parent)
      }
      // whole chain confirmed — start the CSV clock from the vtxo tx's height
      action.claimableAt = lastConfirmedHeight + decoded.exitDelta;
      action.step = 'timelock';
      mgr._save();
    }
    if (action.step === 'timelock') {
      const tip = await mgr.chain.tipHeight();
      if (action.tipSeen !== tip) { action.tipSeen = tip; mgr._save(); } // for the blocks-left display
      if (tip < action.claimableAt) return;
      const keys = mgr._keyForVtxo(rec);
      const feeRate = Math.max(1, (wallet.feeRates && wallet.feeRates.halfHourFee) || 2);
      const claim = buildExitClaim({
        vtxo: decoded, keys, serverPub: mgr.serverPub,
        destScript: addrScript(wallet.freshReceive().address), feeRate,
      });
      await mgr.chain.broadcastTx(claim.hex);
      rec.state = 'spent';
      action.claimTxid = claim.txid;
      action.step = 'claiming';
      mgr._movement({ type: 'exit', amountSat: claim.amountSat, status: 'complete', txid: claim.txid, detail: `fee ${claim.feeSat} sat` });
      mgr._save();
      wallet.scan().catch(() => {});
    }
    if (action.step === 'claiming') {
      const st = await mgr.chain.getTxStatus(action.claimTxid);
      if (!st?.confirmed) return;
      action.step = 'done';
      mgr._save();
    }
  }

  // ---- ark gifts: bearer-key vtxos ----------------------------------------
  // Ark can't presign a bearer spend (every arkoor needs a live server cosign),
  // so an ark gift is a vtxo sent to an ephemeral ark identity whose seed IS
  // the link. The claimer rebuilds the identity from the code, reads the
  // gift's mailbox for the vtxo, and sweeps it to their own ark address —
  // instant and free. The sender keeps the secret too, which is what makes
  // revoke possible (sweep it back before it's claimed; first cosign wins).
  const AG_MAGIC = 0x11;
  const AG_NET = { mainnet: 0, testnet: 1, signet: 2, mutinynet: 3, regtest: 4 };
  const AG_NET_BY = Object.fromEntries(Object.entries(AG_NET).map(([k, v]) => [v, k]));

  function encodeArkGiftCode(net, amountSat, secret) {
    const b = new Uint8Array(42);
    b[0] = AG_MAGIC;
    b[1] = AG_NET[net] ?? 0;
    new DataView(b.buffer).setBigUint64(2, BigInt(amountSat), true);
    b.set(secret, 10);
    return base32nopad.encode(b);
  }

  function decodeArkGiftCode(code) {
    try {
      const b = base32nopad.decode(String(code || '').toUpperCase());
      if (b.length !== 42 || b[0] !== AG_MAGIC || !(b[1] in AG_NET_BY)) return null;
      return {
        net: AG_NET_BY[b[1]],
        amountSat: Number(new DataView(b.buffer, b.byteOffset).getBigUint64(2, true)),
        secretHex: hex.encode(b.slice(10)),
      };
    } catch { return null; }
  }

  // A manager over the gift identity. State persists per device (keyed by the
  // secret's hash) so a claim interrupted mid-sweep resumes checkpointed.
  async function giftManager(secretHex) {
    const cfg = getArkConfig();
    if (!cfg) throw new Error(t('arkNotConnected'));
    const key = 'btc-wallet-arkgift:' + hex.encode(sha256(hex.decode(secretHex))).slice(0, 24);
    const mgr = new ArkManager({
      account: HDKey.fromMasterSeed(hex.decode(secretHex)),
      storage: {
        load: () => { try { return JSON.parse(localStorage.getItem(key) || 'null'); } catch { return null; } },
        save: (s) => { try { localStorage.setItem(key, JSON.stringify(s)); } catch {} },
      },
      arkUrl: cfg.ark, esploraUrl: cfg.esplora, network: getNetwork(),
    });
    await mgr.init();
    return mgr;
  }

  // The gift vtxo's key/outpoint for direct status checks (receive key 0).
  const giftKey0 = (secretHex) => {
    const n = HDKey.fromMasterSeed(hex.decode(secretHex)).deriveChild(3).deriveChild(0);
    return n.privateKey;
  };
  const pointRawFromId = (id) => {
    const [txid, vout] = id.split(':');
    const raw = new Uint8Array(36);
    raw.set(hex.decode(txid).reverse(), 0);
    new DataView(raw.buffer).setUint32(32, Number(vout), true);
    return raw;
  };

  function arkGiftRecords() {
    if (!ark || !ark.state) return [];
    return (ark.state.gifts = ark.state.gifts || []);
  }

  // A gift's record id IS the destination vtxo of the send that funded it, so
  // the history row and detail view can recognise their own gift sends.
  const giftForMovement = (m) => (m && m.type === 'send' && m.vtxoId
    ? arkGiftRecords().find((g) => g.id === m.vtxoId) : null);

  // Lazily mark records whose vtxo the server reports spent (claimed — or our
  // own revoke). Throttled: this is called from the gift card's render path.
  let arkGiftsCheckedAt = 0;
  function refreshArkGiftRecords() {
    if (!ark || Date.now() - arkGiftsCheckedAt < 30_000) return;
    arkGiftsCheckedAt = Date.now();
    const open = arkGiftRecords().filter((g) => !g.revoked && !g.claimed);
    Promise.all(open.map(async (g) => {
      try {
        const st = await getVtxoStatus(ark.arkUrl, pointRawFromId(g.id), giftKey0(g.secretHex));
        if (st === VTXO_STATE_SPENT) { g.claimed = true; return true; }
      } catch {}
      return false;
    })).then((flags) => { if (flags.some(Boolean)) ark._save(); });
  }

  // Fund a fresh bearer gift identity. Shared by the gifts feature's hook and
  // the zap flow's locked-gift fallback; `lockedTo` records who a locked gift
  // was for (the sender can still revoke either kind while unclaimed).
  async function createArkGift(amountSat, lockedTo = null) {
    const mgr = await connectArk();
    const secret = crypto.getRandomValues(new Uint8Array(32));
    const secretHex = hex.encode(secret);
    const gm = await giftManager(secretHex);
    const address = gm.address();
    const actionId = await mgr.send(address, amountSat);
    const action = mgr.state.actions.find((a) => a.id === actionId);
    if (!action || action.step === 'failed') throw new Error(action?.error || t('claimFailed'));
    const vtxoId = decodeVtxo(hex.decode((action.destBytesList || [action.destBytes])[0])).id;
    arkGiftRecords().push({ id: vtxoId, amountSat, secretHex, created: Date.now(), revoked: false, claimed: false, ...(lockedTo ? { lockedTo } : {}) });
    mgr._save();
    return { code: encodeArkGiftCode(getNetwork(), amountSat, secret), amount: amountSat, address };
  }

  // Sweep the gift identity's balance to `destAddress`. Shared by claim
  // (recipient's address) and revoke (sender's own address).
  async function sweepArkGift(code, destAddress) {
    const g = decodeArkGiftCode(code);
    if (!g) throw new Error('not an ark gift');
    if (g.net !== getNetwork()) throw new Error(t('arkGiftWrongNet', { net: g.net }));
    const gm = await giftManager(g.secretHex);
    await gm.sync();
    await gm.reconcile().catch(() => {});
    const amount = gm.balance().spendableSat;
    if (!amount) throw Object.assign(new Error(t('giftTakenTitle')), { giftTaken: true });
    await gm.send(destAddress, amount);
    return amount;
  }

  // Offboard the whole ark balance back into this wallet's own on-chain
  // receive address — the mirror image of boarding.
  // Offboard `amountSat` (or everything when omitted). An offboard moves
  // whole vtxos — no change — so a partial amount first mints an exact-amount
  // vtxo via a self-send (regtest-verified: the mailbox delivers self-sends),
  // then exits just that one. The number the user typed is the number that
  // leaves Spending; fees come off what arrives in Savings.
  // Send-to-on-chain from Spending: amount in, exit out — an offboard whose
  // destination is whatever address was pasted.
  function arkOffboardSendView() {
    const o = ui.arkOffboardSend;
    const spendable = arkBalance()?.spendableSat || 0;
    return h('div', { class: 'card col', style: 'gap:12px' },
      h('h3', {}, t('arkExitSendTitle')),
      h('div', { class: 'small muted break' }, o.address),
      h('div', { class: 'small faint' }, t('arkExitSendNote')),
      h('div', { class: 'input-group' },
        h('input', { type: 'number', min: '1', placeholder: String(spendable), value: o.amount,
          onInput: (e) => { o.amount = e.target.value; } }),
        h('button', { type: 'button', onClick: () => { o.amount = String(spendable); render(); } }, t('max'))),
      ui.arkError ? h('div', { class: 'notice err' }, ui.arkError) : null,
      h('div', { class: 'row gap6' },
        h('button', { class: 'btn-ghost grow', onClick: () => { ui.arkOffboardSend = null; ui.arkError = ''; ui.send = blankSend(); render(); } }, t('back')),
        ui.arkBusy === 'offboard'
          ? h('button', { class: 'btn-primary grow', disabled: true }, h('span', { class: 'spinner sm' }))
          : h('button', { class: 'btn-primary grow', onClick: () => {
              const sats = parseInt(o.amount, 10) || spendable;
              if (!sats || sats <= 0 || sats > spendable) { ui.arkError = t('enterValidAmtForN', { n: 1 }); render(); return; }
              doArkOffboard(sats >= spendable ? 0 : sats, o.address);
            } }, t('send'))),
      // This send IS the cooperative exit. The trustless fallback only
      // appears when cooperation actually failed — and it states, before
      // anything is confirmed, exactly what it does and what the mining
      // fees from Savings will be.
      (() => {
        if (!ui.arkError || ui.arkBusy === 'offboard' || !ark) return null;
        let feeEst = 0;
        try { feeEst = estimateExitFeeSat(ark); } catch {}
        const balance = arkBalance()?.spendableSat || 0;
        // A trustless exit that costs more than it moves isn't an option,
        // it's a trap — say so, and point at the road that actually fits a
        // small balance: Lightning carries no mining fees at all.
        if (feeEst >= balance) {
          return h('div', { class: 'col', style: 'gap:8px;border-top:1px solid var(--border,rgba(128,128,128,.2));padding-top:10px' },
            h('div', { class: 'small muted' }, t('arkUniUneconomical', { fee: fmtSats(feeEst), n: fmtSats(balance) })));
        }
        const savings = wallet.spendable || 0;
        const short = savings < feeEst;
        return h('div', { class: 'col', style: 'gap:8px;border-top:1px solid var(--border,rgba(128,128,128,.2));padding-top:10px' },
          h('div', { class: 'small muted' }, t('arkUniFallbackBody', { fee: fmtSats(feeEst) })),
          short ? h('div', { class: 'small err' }, t('arkUniFallbackShort', { need: fmtSats(feeEst), have: fmtSats(savings) })) : null,
          h('button', {
            class: 'btn-block', disabled: !!ui.arkBusy || short,
            onClick: () => {
              ui.arkOffboardSend = null; ui.arkError = ''; ui.send = blankSend();
              doArkExit();
              ui.tab = 'history'; // the exit lives as a pending record there
              render();
            },
          }, t('arkUniFallbackBtn', { fee: fmtSats(feeEst) })));
      })());
  }

  async function doArkOffboard(amountSat, destAddress = null) {
    ui.arkBusy = 'offboard'; ui.arkError = ''; render();
    try {
      const mgr = await connectArk();
      const spendables = () => mgr.state.vtxos.filter((v) => v.state === 'spendable');
      const total = spendables().reduce((n, v) => n + v.amountSat, 0);
      let ids; // undefined = all spendable vtxos
      if (amountSat && amountSat < total) {
        let target = spendables().find((v) => v.amountSat === amountSat);
        if (!target) {
          const before = new Set(spendables().map((v) => v.id));
          await mgr.send(mgr.address(), amountSat);
          for (let i = 0; i < 30 && !target; i++) {
            await new Promise((r) => setTimeout(r, 2000));
            await mgr.sync().catch(() => {});
            target = spendables().find((v) => v.amountSat === amountSat && !before.has(v.id));
          }
          if (!target) throw new Error(t('arkSplitTimeout'));
        }
        ids = [target.id];
      }
      const address = destAddress || wallet.freshReceive().address;
      const spk = btc.OutScript.encode(btc.Address(wallet.netCfg.net).decode(address));
      const action = await mgr.startOffboard(spk, address, ids);
      ui.arkOffboardAmt = '';
      ui.arkMoveOpen = false;
      ui.arkOffboardSend = null;
      ui.arkOffboarded = { txid: action.txid, netSat: action.netSat, feeSat: action.feeSat };
      wallet.scan().catch(() => {}); // surface the incoming pending tx promptly
    } catch (e) {
      ui.arkError = e.message;
    }
    ui.arkBusy = null; render();
  }

  // VTXO upkeep, invisibly: a send needs a single vtxo covering the amount
  // (fragmentation breaks coin selection) and every vtxo expires at
  // expiryHeight (unrenewed, the ASP can eventually sweep it). Rather than
  // exposing a refresh button, consolidate-and-renew automatically when a
  // vtxo is inside the renewal window or fragmentation builds up. The round
  // fee this spends is the cost of keeping the money spendable at all.
  // The ASP's refresh fee brackets reward renewing LATE — under 96 blocks of
  // remaining life a renewal is free, and this ASP keeps honoring (and freely
  // rescuing) a coin even past its expiry, so aiming inside the free window
  // risks nothing. ~16 hours of margin on mainnet.
  const renewWindow = () => (getNetwork() === 'regtest' ? 24 : 96);
  // How close to expiry the SERVER's own backstop renewal is aimed. The
  // window above only helps a wallet someone opens inside it; this one is a
  // participation registered far in advance that the ASP runs on its own,
  // whether or not anybody is looking. It sits well inside renewWindow so an
  // app that IS open still renews first (and the untouched backstop is
  // dropped), and far enough from expiry — 36 blocks, six hourly rounds — for
  // the round to actually run in time. Both are in the free fee bracket.
  const backstopWindow = () => (getNetwork() === 'regtest' ? 6 : 36);
  let arkAutoRefreshAt = 0;
  let arkBackstopAt = 0;
  // Set when the balance is too small to renew itself (total minus round fee
  // under the server's 330-sat output minimum) AND a vtxo is inside the
  // renewal window: { deadlineMs, sat }. The wallet-screen notice reads this.
  let arkRenewWarn = null;
  // Pasting your OWN ark address — or a coinos name that resolves to it —
  // is never a payment: it means "top up Spending". Route to the board
  // panel, funded from on-chain Savings; prefill an amount when the caller
  // has one (the review path carries the typed amount, paste-time has none
  // and the panel's own field takes over).
  async function boardOwnAddress(addr, { connect = false, amountSat = 0 } = {}) {
    if (!arkAvailable() || wallet.watchOnly) return false;
    let mgr = ark;
    if (!mgr) {
      if (!connect) return false;
      try { mgr = await connectArk(); } catch { return false; }
    }
    try { if (addr !== mgr.address()) return false; } catch { return false; }
    ctx.goHome();
    ui.arkMoveOpen = true;
    ui.arkMoveDir = 'toSpending';
    ui.arkBoardAmt = amountSat > 0 ? String(amountSat) : '';
    ui.send = blankSend();
    ui.sendError = '';
    toast(t('arkOwnAddrBoard'));
    render();
    return true;
  }

  async function maybeAutoRefresh(mgr) {
    if (wallet.watchOnly || !mgr || !mgr.state) return;
    if (Date.now() - arkAutoRefreshAt < 30 * 60_000) return;
    // NOT filtered by expiryRejected. A coin the server refused as expired
    // can still be REFRESHED — that is the one thing an expired vtxo can
    // still do — and excluding it here meant a wallet holding nothing else
    // did nothing at all: no renewal attempt, and no warning either.
    const spendables = (mgr.state.vtxos || []).filter((v) => v.state === 'spendable');
    if (!spendables.length) { arkRenewWarn = null; return; }
    // Register the server-side backstop for anything not covered yet. Ahead
    // of the in-flight guard below on purpose: a standing order takes no coin
    // and starts no round, so a send in progress is no reason to skip the one
    // renewal that survives the app never being opened again. Stamped on its
    // own clock — the guard below can return before the refresh throttle is
    // stamped, and this must not then run on every five-second sync.
    if (Date.now() - arkBackstopAt > 30 * 60_000) {
      arkBackstopAt = Date.now();
      await mgr.ensureScheduledRefreshes(backstopWindow()).catch(() => {});
    }
    // never start a round while any other action is still in flight
    if ((mgr.state.actions || []).some((a) => !['done', 'failed'].includes(a.step))) return;
    arkAutoRefreshAt = Date.now();
    try {
      const tip = await mgr.chain.tipHeight();
      const RENEW_BLOCKS = renewWindow();
      const expiringCoins = spendables.filter((v) => v.expiryHeight && v.expiryHeight - tip < RENEW_BLOCKS);
      const expiring = expiringCoins.length > 0;
      // Fragmentation alone is no longer worth paying for: multi-input sends
      // handle up to 24 coins, and consolidating FRESH coins bills the round
      // fee's top ppm bracket (a burst of refund coins after failed payments
      // once cost a user ~1% overnight). Consolidate only when the coin count
      // itself approaches the 24-input send ceiling.
      const fragmented = spendables.length >= 20;
      const totalSat = spendables.reduce((n, v) => n + v.amountSat, 0);
      const renewable = totalSat - mgr.refreshFee(spendables, tip) >= 330;
      if (expiring && !renewable) {
        // Can't save these coins ourselves — tell the user while receiving
        // any amount (or spending) can still beat the clock.
        const minExpiry = Math.min(...spendables.map((v) => v.expiryHeight || Infinity));
        const blockMs = getNetwork() === 'regtest' ? 10_000 : 600_000;
        arkRenewWarn = { deadlineMs: Date.now() + Math.max(0, minExpiry - tip) * blockMs, sat: totalSat };
        notifyRenewWarn();
        render();
        return;
      }
      arkRenewWarn = null;
      if (!expiring && !fragmented) return;
      // Renew ONLY the coins that need it: dragging far-from-expiry coins
      // into the round would bill their (higher) fee bracket for nothing.
      // The rare fragmentation consolidation still sweeps everything.
      //
      // But the subset must clear the server's 330-sat output floor BY
      // ITSELF — the renewable check above prices the whole balance. Two
      // dust coins at expiry (133 sats between them) failed their renewal
      // round silently every 30 minutes forever. Pull in the smallest
      // healthy coins until the renewed output is mintable.
      let renewSet = expiringCoins;
      if (!fragmented) {
        const extras = spendables
          .filter((v) => !expiringCoins.includes(v))
          .sort((a, b) => a.amountSat - b.amountSat);
        const netSat = (set) => set.reduce((n, v) => n + v.amountSat, 0) - mgr.refreshFee(set, tip);
        while (netSat(renewSet) < 330 && extras.length) renewSet = [...renewSet, extras.shift()];
        if (netSat(renewSet) < 330) return; // whole balance can't clear the floor — the warn above covers it
      }
      await mgr.refresh(fragmented ? undefined : renewSet.map((v) => v.id));
      render();
    } catch {} // transient — the next throttled attempt retries
  }

  // A local heads-up (at most one a day) for users who granted notifications —
  // the in-app notice alone can't reach someone who isn't looking.
  function notifyRenewWarn() {
    try {
      if (typeof Notification === 'undefined' || Notification.permission !== 'granted') return;
      const KEY = 'arkRenewNotifiedAt';
      if (Date.now() - (Number(localStorage.getItem(KEY)) || 0) < 24 * 3600_000) return;
      localStorage.setItem(KEY, String(Date.now()));
      const body = t('arkRenewWarnPush', {
        date: new Date(arkRenewWarn.deadlineMs).toLocaleDateString(),
      });
      navigator.serviceWorker?.ready
        .then((reg) => reg.showNotification('coinos', { body }))
        .catch(() => { try { new Notification('coinos', { body }); } catch {} });
    } catch {}
  }

  // Moving money between the two balances, in plain terms. This is the only
  // place the two rails meet, and it never names them: Saving is on-chain,
  // Spending is instant, and the wallet handles the rest.
  // Amount field with an inline Max — a text affordance inside the input's
  // right edge rather than a button eating a third of the row.
  function amountField({ value, onInput, maxSat, placeholder, onMax }) {
    return h('div', { class: 'amt-field' },
      h('input', {
        type: 'number', inputmode: 'numeric', min: '0', placeholder,
        value: value || '',
        onInput,
      }),
      maxSat > 0
        ? h('button', { type: 'button', class: 'amt-max', onClick: onMax }, t('max'))
        : null);
  }

  // Boarding drains an on-chain balance, so Max must leave room for the
  // mining fee: ask the tx builder what a sweep would actually deliver — TO
  // THE REAL OUTPUT SHAPE. The board funding address is P2TR, 12 vbytes
  // bigger than this wallet's P2WPKH change; drafting the sweep against
  // change priced Max a dozen sats past what the funding transaction could
  // carry, and tapping Max earned "insufficient funds". The manager's own
  // key stands in for the funding key — same size, always a valid point.
  function maxBoardSat() {
    try {
      return Math.max(0, previewBoardFunding(wallet, ark, 0, true).fundingSat);
    } catch {
      return 0;
    }
  }

  // The ASP decides how many confirmations a board needs — say that number,
  // not a hardcoded one that contradicts the n/need counter under the balance.
  const boardedNote = () => {
    const n = (ark && ark.info && ark.info.requiredBoardConfirmations) || 1;
    return n === 1 ? t('arkBoardedNoteOne') : t('arkBoardedNote', { n });
  };

  function boardForm() {
    const minBoard = (ark && ark.info && ark.info.minBoardAmountSat) || 0;
    const canBoard = wallet.spendable >= minBoard;
    return h('div', { class: 'col', style: 'width:100%;gap:8px' },
      h('div', { class: 'input-group' },
        amountField({
          value: ui.arkBoardAmt,
          placeholder: t('arkOffboardAmtPlaceholder'), // the minimum is stated below
          onInput: (e) => { ui.arkBoardAmt = e.target.value; render(); },
          maxSat: canBoard ? wallet.spendable : 0,
          onMax: () => { ui.arkBoardAmt = String(maxBoardSat()); render(); },
        }),
        h('button', { class: 'btn-primary', disabled: !!ui.arkBusy || !canBoard, onClick: doArkBoard },
          ui.arkBusy === 'board' ? h('span', { class: 'spinner sm' }) : t('arkBoardBtn'))),
      (() => {
        const sats = parseInt((ui.arkBoardAmt || '').trim(), 10);
        if (!sats || sats < minBoard || !ark) return null;
        try {
          const quote = previewBoardFunding(wallet, ark, sats);
          return h('div', { class: 'col small muted', style: 'text-align:center;gap:4px' },
            t('arkBoardFeeNote', { fee: quote.feeSat.toLocaleString(), net: quote.netSat.toLocaleString() }),
            h('div', { class: 'small faint' },
              t('arkFeeChain') + ': ' + fmtAmount(quote.chainFeeSat) + ' ' + unitLabel() + ' · '
              + t('arkFeeService') + ': ' + fmtAmount(quote.serviceFeeSat) + ' ' + unitLabel()));
        } catch (e) {
          return h('div', { class: 'notice err small' }, e.message);
        }
      })(),
      canBoard
        ? h('div', { class: 'small faint', style: 'text-align:center' },
            t('arkBoardAvailable', { n: fmtAmount(wallet.spendable) + ' ' + unitLabel() }))
        : h('div', { class: 'small faint', style: 'text-align:center' },
            t('arkBoardNoFunds', { n: minBoard.toLocaleString() })));
  }

  // Moving money between the two balances, inline on the balance card — the
  // one door between the rails opens right where the balances live.
  function movePanel() {
    if (!ark) connectArk().catch(() => {});
    const dir = ui.arkMoveDir || 'toSpending';
    const b = arkBalance();
    return h('div', { class: 'col balance-move' },
      h('div', { class: 'seg' },
        h('button', { class: dir === 'toSpending' ? 'active' : '', onClick: () => { ui.arkMoveDir = 'toSpending'; ui.arkError = ''; render(); } }, t('moveToSpending')),
        h('button', { class: dir === 'toSaving' ? 'active' : '', onClick: () => { ui.arkMoveDir = 'toSaving'; ui.arkError = ''; render(); } }, t('moveToSaving'))),
      dir === 'toSpending'
        ? h('div', { class: 'col', style: 'gap:8px' },
            h('p', { class: 'small muted', style: 'margin:0' }, t('moveToSpendingDesc')),
            ark ? boardForm() : h('div', { class: 'row gap6', style: 'align-items:center' },
              h('span', { class: 'spinner sm' }), h('span', { class: 'small muted' }, t('arkConnecting'))))
        : h('div', { class: 'col', style: 'gap:8px' },
            h('p', { class: 'small muted', style: 'margin:0' }, t('moveToSavingDesc')),
            // no "X sats in Spending" line — the balance sits right above on this card
            (() => {
              const spendable = b ? b.spendableSat : 0;
              const sats = parseInt((ui.arkOffboardAmt || '').trim(), 10) || 0;
              const valid = sats > 0 && sats <= spendable;
              return h('div', { class: 'col', style: 'gap:8px' },
                h('div', { class: 'input-group' },
                  amountField({
                    value: ui.arkOffboardAmt,
                    placeholder: t('arkOffboardAmtPlaceholder'),
                    onInput: (e) => { ui.arkOffboardAmt = e.target.value; render(); },
                    maxSat: spendable,
                    onMax: () => { ui.arkOffboardAmt = String(spendable); render(); },
                  }),
                  h('button', {
                    class: 'btn-primary', disabled: !!ui.arkBusy || !valid,
                    onClick: () => doArkOffboard(sats),
                  }, ui.arkBusy === 'offboard' ? h('span', { class: 'spinner sm' }) : t('moveToSavingBtn'))),
                ui.arkBusy === 'offboard' && sats < spendable
                  ? h('div', { class: 'small muted', style: 'text-align:center' }, t('arkSplitting'))
                  : null,
                h('button', {
                  class: 'linklike small', style: 'align-self:center',
                  onClick: () => { ui.arkMoveOpen = false; ui.arkExitPage = true; ui.arkError = ''; render(); },
                }, t('arkUniTitle')));
            })()),
      ui.arkError ? h('div', { class: 'notice err' }, ui.arkError) : null,
      // the panel unfolds on the balance card with no obvious way back out —
      // a dismiss returns you to the plain card
      h('button', {
        class: 'linklike small', style: 'align-self:center;margin-top:2px',
        onClick: () => { ui.arkMoveOpen = false; ui.arkError = ''; render(); },
      }, t('cancel')));
  }


  // "Payment received!" takeover for unseen Ark receives.
  function arkCelebration() {
    // An Ark payment landed — same celebration as an on-chain receive, dismissed
    // with a tap (the ack persists in the ark state so it shows exactly once).
    const arkUnseen = ark && ark.state ? ark.unseenReceives() : [];
    if (arkUnseen.length) {
      const amt = arkUnseen.reduce((n, m) => n + m.amountSat, 0);
      return h(
        'div',
        {
          class: 'card col',
          style: 'align-items:center;text-align:center;gap:14px;cursor:pointer;padding:48px 20px',
          onClick: () => { ark.ackReceives(); render(); },
        },
        h('div', { class: 'check-badge' }, '✓'),
        h('h2', { style: 'margin:0' }, t('paymentReceived')),
        amt ? h('div', { class: 'amount-pos', style: 'font-size:18px' }, '+' + fmtAmount(amt) + ' ' + unitLabel()) : null,
        h('div', { class: 'small muted' }, t('tapToProceed'))
      );
    }
    return null;
  }

  // Offboard success screen — mirror of the boarded screen.
  function arkOffboardedScreen() {
    if (!ui.arkOffboarded) return null;
    const o = ui.arkOffboarded;
    const url = wallet.api.explorerTx(o.txid);
    return h(
      'div',
      { class: 'card col', style: 'align-items:center;text-align:center;gap:14px;padding:40px 20px' },
      h('div', { class: 'check-badge' }, '✓'),
      h('h2', { style: 'margin:0' }, t('arkOffboardedTitle')),
      h('div', { class: 'amount-pos', style: 'font-size:18px' }, '+' + fmtAmount(o.netSat) + ' ' + unitLabel()),
      h('p', { class: 'small muted', style: 'margin:0' }, t('arkOffboardedNote')),
      o.feeSat ? h('div', { class: 'small faint' }, t('feeShort', { x: fmtAmount(o.feeSat) })) : null,
      h('div', { class: 'addr-box', style: 'width:100%' }, o.txid),
      h('div', { class: 'row gap6' },
        copyBtn(o.txid, t('copyTxid')),
        h('a', { class: 'btn btn-sm', href: url, target: '_blank', rel: 'noopener', onClick: (e) => { e.preventDefault(); openExternal(url); } }, t('viewOnMempool'))),
      h('button', { class: 'btn-primary btn-block', onClick: () => { ui.arkOffboarded = null; ui.arkExitPage = null; render(); } }, t('done'))
    );
  }

  // Boarding success screen (txid + explorer link) until dismissed.
  function arkBoardedScreen() {
    // A board just broadcast — show its success screen until dismissed.
    if (ui.arkBoarded) {
      const b = ui.arkBoarded;
      const url = wallet.api.explorerTx(b.txid);
      return h(
        'div',
        { class: 'card col', style: 'align-items:center;text-align:center;gap:14px;padding:40px 20px' },
        h('div', { class: 'check-badge' }, '✓'),
        h('h2', { style: 'margin:0' }, t('arkBoardedTitle')),
        h('div', { class: 'amount-pos', style: 'font-size:18px' }, '+' + fmtAmount(b.netSat) + ' ' + unitLabel()),
        h('p', { class: 'small muted', style: 'margin:0' }, boardedNote()),
        h('div', { class: 'addr-box', style: 'width:100%' }, b.txid),
        h('div', { class: 'row gap6' },
          copyBtn(b.txid, t('copyTxid')),
          h('a', { class: 'btn btn-sm', href: url, target: '_blank', rel: 'noopener', onClick: (e) => { e.preventDefault(); openExternal(url); } }, t('viewOnMempool'))),
        h('button', { class: 'btn-primary btn-block', onClick: () => { ui.arkBoarded = null; render(); } }, t('done'))
      );
    }
    return null;
  }

  // Per-exit progress lines (chain hops / timelock countdown / claiming), with
  // a cancel for an exit that never published. Shown on the exit page.
  function arkExitStatusLines() {
    const s = arkStateNow();
    const acts = ((s && s.actions) || []).filter((a) => a.type === 'exit' && !['done', 'failed'].includes(a.step));
    if (!acts.length) return [];
    const exitDelta = (ark && ark.info && ark.info.vtxoExitDelta) || 144;
    const totalSat = acts.reduce((n, a) => n + a.amountSat, 0);
    // One story for the whole batch: each coin's chain unrolls a confirmed
    // hop per block, then waits out the CSV timelock, then the claim itself
    // confirms. Coins run in parallel, so the slowest one sets the ETA.
    const blocksFor = (a) =>
      a.step === 'chain' ? ((a.txids || []).length - (a.hopsDone || 0)) + exitDelta + 1
        : a.step === 'timelock' ? Math.max(0, a.claimableAt - (a.tipSeen || 0)) + 1
        : 1;
    const mins = Math.max(...acts.map(blocksFor)) * 10;
    const eta = getNetwork() === 'regtest' ? t('arkExitSoon')
      : mins >= 2880 ? `${Math.round(mins / 1440)} days`
      : mins >= 120 ? `${Math.round(mins / 60)} hours`
      : `${mins} minutes`;
    // The most advanced tx that's actually out there — the one worth watching.
    // A chain hop that errored before broadcast has nothing to link yet.
    let watch = null, watchScore = -1;
    for (const a of acts) {
      const score = a.step === 'claiming' ? 3 : a.step === 'timelock' ? 2 : a.hopsDone > 0 ? 1 : 0;
      const txid = exitWatchTxid(a);
      if (score > 0 && txid && score > watchScore) { watch = txid; watchScore = score; }
    }
    const err = acts.find((a) => a.lastError && a.actionable);
    const softErr = !err && acts.some((a) => a.lastError);
    // Cancelling is only real while nothing has touched the chain AND the
    // driver is parked waiting on the user (a needs-fee stall) — a healthy
    // exit may be mid-broadcast this very second. One button for the whole
    // batch, gone the moment it would be a lie.
    const cancellable = acts.every((a) => a.actionable && !(a.hopsDone > 0) && a.step === 'chain');
    return [h('div', { class: 'small muted', style: 'margin-top:4px' },
      t('arkExitSummary', { n: fmtSats(totalSat), eta }),
      err ? h('div', { class: 'small err' }, err.lastError)
        : softErr ? h('div', { class: 'small faint' }, t('arkExitRetrying')) : null,
      watch ? h('div', { style: 'margin-top:4px' },
        h('a', { class: 'linklike small', href: wallet.api.explorerTx(watch), target: '_blank', rel: 'noopener' }, t('arkExitViewTx'))) : null,
      cancellable
        ? h('button', { class: 'linklike small', style: 'display:block;margin-top:4px', onClick: () => {
            for (const a of acts) {
              a.step = 'failed';
              const v = ark && ark._vtxo(a.vtxoId);
              if (v && v.state === 'pending') v.state = 'spendable';
            }
            if (ark) ark._save();
            render();
          } }, t('arkExitCancel'))
        : null)];
  }

  // The exit page: cooperative offboard vs unilateral exit, with explanation.
  // Reached from the "Exit" link on the Ark balance line.
  function arkExitPage() {
    if (ui.arkOffboarded) return arkOffboardedScreen(); // cooperative success takeover
    const b = arkBalance() || { spendableSat: 0, pendingSat: 0 };
    const spendable = b.spendableSat;
    const total = b.spendableSat + b.pendingSat;
    const nSpend = ((arkStateNow() && arkStateNow().vtxos) || []).filter((v) => v.state === 'spendable').length;
    const exitingSat = ((arkStateNow() && arkStateNow().actions) || [])
      .filter((a) => a.type === 'exit' && !['done', 'failed'].includes(a.step))
      .reduce((n, a) => n + a.amountSat, 0);
    const exits = arkExitStatusLines();
    const back = () => { ui.arkExitPage = null; ui.arkError = ''; render(); };
    return h('div', { class: 'col', style: 'gap:16px' },
      h('div', { class: 'card col', style: 'gap:8px' },
        h('h3', { class: 'row gap6', style: 'align-items:center;margin:0' }, h('span', { html: ARK_ICON(18) }), t('arkExitPageTitle')),
        h('p', { class: 'small muted', style: 'margin:0' }, t('arkExitPageIntro')),
        total > 0 ? h('div', { class: 'row between', style: 'margin-top:4px' },
          h('span', { class: 'small muted' }, t('arkBalance')),
          h('span', { class: 'small' }, fmtAmount(total) + ' ' + unitLabel())) : null,
        null),
      // cooperative
      h('div', { class: 'card col', style: 'gap:8px' },
        h('h4', { style: 'margin:0' }, t('arkCoopTitle')),
        h('p', { class: 'small muted', style: 'margin:0' }, t('arkCoopDesc')),
        spendable > 0
          ? h('button', { class: 'btn-primary btn-block', disabled: !!ui.arkBusy, onClick: () => doArkOffboard() },
              ui.arkBusy === 'offboard' ? h('span', { class: 'spinner sm' }) : t('arkOffboardBtn', { n: fmtAmount(spendable) + ' ' + unitLabel() }))
          : h('div', { class: 'small faint' }, exitingSat > 0 ? t('arkExitCoopHeld') : t('arkExitNoBalance'))),
      // unilateral
      h('div', { class: 'card col', style: 'gap:8px' },
        h('h4', { style: 'margin:0' }, t('arkUniTitle')),
        h('p', { class: 'small muted', style: 'margin:0' }, t('arkUniDesc')),
        nSpend > 0
          ? h('button', { class: 'btn-ghost btn-block', disabled: !!ui.arkBusy, onClick: doArkExit },
              ui.arkBusy === 'exit' ? h('span', { class: 'spinner sm' }) : t('arkExitBtn'))
          : null,
        ...exits),
      ui.arkError ? h('div', { class: 'notice err' }, ui.arkError) : null,
      h('button', { class: 'btn-ghost btn-block', onClick: back }, t('back'))
    );
  }

  return {
    id: 'ark',
    init() { _autoSelected = false; ui.accountUserChosen = false; initArk(); },
    stop() { stopArk(); },
    // Boot waits on this before opening a wallet: the Spending balance and
    // its history live in the ark store, which is IndexedDB and therefore
    // opens asynchronously. Painting first meant painting an empty Spending
    // wallet and filling it in a beat later — a 0 that counted itself up,
    // green, as if money had just arrived. Capped, because a store that
    // won't open must not hold the whole app hostage; the retry in initArk
    // catches up if it lands after the cap.
    arkStoreReady() {
      const store = wallet._arkStore;
      if (!store || store.ready) return null;
      return Promise.race([
        store.open().catch(() => {}),
        new Promise((r) => setTimeout(r, 800)),
      ]);
    },
    screenView() { return ui.arkCoinsPage ? arkCoinsPage() : ui.arkExitPage ? arkExitPage() : null; },
    receiveTakeover() {
      const offboarded = arkOffboardedScreen();
      if (offboarded) return offboarded;
      const boarded = arkBoardedScreen();
      if (boarded) return boarded;
      return arkCelebration();
    },
    isSendDest(a) { return isArkAddress(a) && arkAvailable(); },
    hideSendControls(a) { return isArkAddress(a); },
    // Max for an ark recipient: arkoor sends are free, so the whole
    // spendable Spending balance is the honest maximum — WHEN Spending is
    // the selected rail. From Savings this destination is either a board
    // (your own address — review routes it to the board panel) or a
    // wrong-rail send review will bounce; either way the honest maximum is
    // what Savings can actually fund. Filling Spending's number here handed
    // the board panel an amount Savings couldn't cover, and the user read
    // the resulting 'insufficient funds' as a fee miscalculation.
    sendMaxFill(a) {
      if (!isArkAddress(a)) return null;
      const sat = ctx.getAccount() === 'spending'
        ? (arkBalance()?.spendableSat || 0)
        : maxBoardSat();
      if (!sat) return null;
      return ctx.getUnit() === 'sats' ? String(sat) : (sat / 1e8).toFixed(8);
    },
    sendFormNote(a) {
      if (!isArkAddress(a)) return null;
      maybeReconcile();
      return h('div', { class: 'small faint' }, t('arkSendHint'));
    },
    interceptReview(s) {
      if (s.recipients.length === 1) {
        const inv = (s.recipients[0].address || '').trim().replace(/^lightning:/i, '');
        if (maybeLnInvoice(inv) && startArkLnPay(inv)) return true;
      }
      if (s.recipients.length === 1 && isArkAddress(s.recipients[0].address)) {
        if (!arkAvailable()) throw new Error(t('arkNotConnected'));
        const sats = ctx.parseAmount(s.recipients[0].amount, ctx.getUnit());
        if (!sats || sats <= 0) throw new Error(t('enterValidAmtForN', { n: 1 }));
        const dest = s.recipients[0].address.trim();
        const fromSavings = ctx.getAccount() !== 'spending';
        (async () => {
          // Whose address is this? The manager may still be connecting, so
          // resolve async before painting a review. Our own address routes
          // to the board panel with the typed amount riding along.
          try { await connectArk(); }
          catch (e) { ui.sendError = e.message; render(); return; }
          if (await boardOwnAddress(dest, { amountSat: sats })) return;
          if (fromSavings) {
            // An ark payment spends the Spending balance — never silently
            // spend a different balance than the one selected.
            ui.sendError = t('arkPayFromSpending');
          } else {
            ui.arkSend = { address: dest, amountSat: sats };
          }
          render();
        })();
        return true;
      }
      return false;
    },
    sendView() {
      if (ui.arkOffboardSend) return arkOffboardSendView();
      if (ui.arkLnPaid || ui.arkLnPay) return arkLnPayView();
      if (ui.arkZapped || ui.arkZap) return arkZapView();
      if (ui.arkSent || ui.arkSend) return arkSendReview();
      return null;
    },
    // A bolt11 pays from the ark balance when it can cover it. Reached via the
    // swaps feature's delegation (its matcher runs first) or directly in
    // builds without the swaps feature.
    startArkLnPay(invoice, meta) { return startArkLnPay(invoice, meta); },
    // The zaps feature's generic Lightning seams (once served by the retired
    // swaps feature): the ASP pays invoices natively over ark.
    canLnPay() { return arkAvailable() && !wallet.watchOnly && !!(ark && ark.info); },
    // Fetch + verify a bolt12 invoice for an offer (the ASP's CLN speaks the
    // onion messages) — resolves { invoice (lni), amountSat, paymentHash }.
    async arkFetchBolt12Invoice(offerStr, amountSat) {
      const mgr = await connectArk();
      return mgr.fetchBolt12(offerStr, amountSat);
    },
    lnSpendableSat() { const b = arkBalance(); return b ? b.spendableSat : 0; },
    // Max for any Lightning amount form: spendable minus estimated fees.
    lnMaxSendSat() { return lnMaxSat(); },
    settingsCards() { return [autoWithdrawCard()]; },
    // a wallet signing out takes its ark state with it, wherever it lives
    wipeCache(prefixes) { for (const p of prefixes) wallet._arkStore.removePrefix(p); },
    // The onboarding wizard's top-up step borrows the board form wholesale.
    arkBoardForm() {
      if (!arkAvailable() || wallet.watchOnly) return null;
      if (!ark) { connectArk().catch(() => {}); return null; }
      return boardForm();
    },
    // A payment wants more Spending than exists: open the board panel with a
    // prefill that nets out to the need (gross of the board fee, with a bit
    // of routing headroom) — editable, so boarding extra is one keystroke.
    arkOfferBoard(needSat) {
      if (!arkAvailable() || wallet.watchOnly) return false;
      const b = arkBalance();
      const have = b ? b.spendableSat : 0;
      const short = Math.max(0, Math.ceil(needSat * 1.01) + 2 - have);
      let gross = short;
      try { for (let i = 0; i < 4; i++) gross = short + boardFee(gross, ark.info.boardFees); } catch {}
      const minBoard = (ark && ark.info && ark.info.minBoardAmountSat) || 0;
      ctx.goHome();
      ui.arkMoveOpen = true;
      ui.arkMoveDir = 'toSpending';
      ui.arkBoardAmt = String(Math.max(gross, minBoard));
      render();
      return true;
    },
    startLnPay(invoice, meta) { return startArkLnPay(invoice, meta); },
    // ---- headless seam for the NWC wallet service ----
    arkPayInvoice(invoice, opts) { return payInvoiceHeadless(invoice, opts); },
    // The settled outcome of a payment another device of this wallet
    // started (the ASP refuses a second HTLC for the same invoice).
    async arkLnOutcome(paymentHash, timeoutMs) {
      const mgr = await connectArk();
      return mgr.lnOutcome(paymentHash, timeoutMs);
    },
    arkSpendableSat() { const b = arkBalance(); return b ? b.spendableSat : 0; },
    arkReady() { return arkAvailable(); },
    // A Lightning invoice for another feature to watch (point of sale):
    // the action id is the handle, the poller tells it when it settles.
    async arkLnInvoice(amountSat, description) {
      const mgr = await connectArk();
      const a = await mgr.createLnInvoice(amountSat, description);
      return { id: a.id, invoice: a.invoice, paymentHash: a.paymentHash, amountSat, expiresAt: a.expiresAt };
    },
    arkLnWatch(id, onSettle) { pollArkLn(id, onSettle); return true; },
    arkLnUnwatch(id) { stopArkLnPoll(id); return true; },
    async arkLnCancel(id) { const mgr = await connectArk(); await mgr.cancelLnInvoice(id); return true; },
    async arkMakeInvoice(amountSat, description) {
      const mgr = await connectArk();
      const a = await mgr.createLnInvoice(amountSat, description);
      return { invoice: a.invoice, paymentHash: a.paymentHash, amountSat };
    },
    arkMovements() { const s = arkStateNow(); return s ? (s.movements || []) : []; },
    // The wallet's reusable ark receive address (BIP-353 names publish it).
    async arkStaticAddress() {
      const mgr = await connectArk();
      return mgr.address();
    },
    // Whether background answering can mirror right now.
    arkBgReady() { return !!(ark && ark.info && ark.state); },
    // nwc.js calls this (with its connections) whenever the mirror should
    // refresh: on enable, on connection changes, after payments, on a timer.
    async arkBgWrite(connections, offer, prefs) { return writeBgMirror(connections, offer, prefs); },
    async arkBgSpendableSat() {
      const rec = await loadBg(wallet._cacheKey());
      return ((rec && rec.mgr && rec.mgr.vtxos) || [])
        .filter((v) => v.state === 'spendable').reduce((n, v) => n + (v.amountSat || 0), 0);
    },
    // Worker payments become ordinary history lines once the app opens.
    async arkBgNoteSpends(spends) {
      const mgr = await connectArk();
      for (const sp of spends) {
        mgr._movement({
          type: 'ln-send', amountSat: sp.amountSat, status: 'complete',
          detail: `while closed · fee ${sp.feeSat || 0} sat`, invoice: sp.invoice || '', preimage: sp.preimage || '',
        });
      }
      mgr._save();
    },
    // A name that resolved to OUR OWN ark address: the names feature asks
    // before filling the send form, so the board panel opens at paste time —
    // nobody should have to type an amount into a payment form just to be
    // told they were topping themselves up.
    arkBoardIfOwn(addr) { return boardOwnAddress(addr, { connect: true }); },
    // An npub pasted into Send becomes an ark zap (needs the nostr seam from
    // the sync feature and a connected-able ark). A bolt11 is handled here
    // only in builds without the swaps feature (whose matcher runs first and
    // delegates back via the startArkLnPay hook).
    matchSendText(text) {
      const inv = (text || '').trim().replace(/^lightning:/i, '');
      // A raw paste of our own ark address means the same thing — start the
      // check now (the manager may need to connect); if it's ours the board
      // panel replaces the filled form a beat later.
      if (isArkAddress(inv) && arkAvailable()) boardOwnAddress(inv, { connect: true }).catch(() => {});
      // In a Spending wallet an on-chain address means "exit ark to there":
      // the offboard happens right in the send flow, no Move money ceremony.
      if (ctx.getAccount() === 'spending' && wallet.isOnchainAddress(inv) && arkAvailable()) {
        const b = arkBalance() || {};
        if ((b.spendableSat || 0) > 0) {
          ui.arkOffboardSend = { address: inv, amount: '' };
          ui.sendError = '';
          render();
          return true;
        }
        // Every coin is mid-exit: the send page is for CREATING payments,
        // so stay right here with an honest error — the in-flight exit is a
        // history record now, and sendFormExtras links straight to it.
        if ((b.pendingSat || 0) > 0
            && (arkStateNow()?.actions || []).some((a) => a.type === 'exit' && !['done', 'failed'].includes(a.step))) {
          ui.sendError = t('arkNoSpendableMidExit');
          render();
          return true;
        }
      }
      if (maybeLnInvoice(inv)) {
        if (startArkLnPay(inv)) return true;
        if (arkAvailable() && !wallet.watchOnly) {
          // An invoice Spending can't cover used to fall through SILENTLY —
          // the bolt11 landed in the address field looking like a dead
          // paste. Own it: offer to board the shortfall from Savings when
          // there is one, else say plainly what's short.
          const need = (maybeLnInvoice(inv) || {}).amountSat || 0;
          if (need && wallet.spendable > 1000 && ctx.hook('arkOfferBoard', need)) return true;
          ui.sendError = t('arkLnExceedsSpending', {
            need: fmtAmount(need) + ' ' + unitLabel(),
            have: fmtAmount(arkBalance()?.spendableSat || 0) + ' ' + unitLabel(),
          });
          render();
          return true;
        }
        return false;
      }
      const pk = npubToHex(text);
      if (!pk || !arkAvailable() || !wallet.nostrFetch) return false;
      startNpubPay(pk, String(text).trim());
      return true;
    },
    // Zap a person — optionally a specific note of theirs (the profile feed's
    // ⚡ button) — through the same resolution ladder as a pasted npub. The
    // event id rides into the receipt's e tag; callers fall back to the
    // lnZapNpub hook when ark can't serve this build/wallet.
    zapNpub(pk, npub, eventId, autoSat) {
      if (!arkAvailable() || !wallet.nostrFetch) return false;
      startNpubPay(pk, npub, eventId || null, autoSat || 0);
      return true;
    },
    sendFormExtras() {
      if (ctx.getAccount() !== 'spending') return null;
      const acts = ((arkStateNow() && arkStateNow().actions) || []).filter((a) => a.type === 'exit' && !['done', 'failed'].includes(a.step));
      if (!acts.length) return null;
      return h('button', { class: 'linklike small', style: 'align-self:center', onClick: () => {
        ui.tab = 'history';
        ui.sendError = '';
        ui.arkExitDetail = acts[0].id;
        render();
      } }, t('arkExitInFlightLink', { n: fmtAmount(acts.reduce((s2, a) => s2 + a.amountSat, 0)) }));
    },
    historyEntries(_txs, sel) {
      if (sel && sel !== 'spending') return []; // ark movements are the Spending timeline
      const s = arkStateNow();
      if (!s) return [];
      // Memoized on the state's REVISION, not a timer. This rebuild sorts and
      // dedupes every movement, resolves gifts, and touches secp256k1 — ~60ms
      // cold. A 1.5s TTL used to re-cool it between unhurried flicks, so every
      // account switch paid the rebuild and stuttered the slide; keyed on _rev
      // it's reused until the data actually changes (each _save bumps _rev),
      // and stays warm no matter how slowly the user flicks back and forth.
      const key = `${s._rev || 0}:${(s.movements || []).length}:${(s.actions || []).length}`;
      if (this._histMemo && this._histMemo.key === key) return this._histMemo.val;
      const val = this._histBuild(s);
      this._histMemo = { key, val };
      return val;
    },
    _histBuild(s) {
      // In-flight exits are payments the user made — they belong in history
      // as pending records, not on a monitoring page nobody thinks to visit.
      const exits = (s.actions || [])
        .filter((a) => a.type === 'exit' && !['done', 'failed'].includes(a.step))
        .map((a) => ({ time: exitStartedTs(a), render: () => arkExitActionItem(a) }));
      // Same-payment duplicates (the old settle race, or a snapshot adopted
      // whole before the merge learned to dedupe) fold at display time too —
      // the earliest telling wins, everywhere, however the state got here.
      // Renewals fold on their unlock hash (two devices can adopt the same
      // participation), and only ones that COST something get a row — a free
      // renewal is net zero, invisible money movement, noise.
      const seenPay = new Set();
      const moves = (s.movements || [])
        .filter((m) => ['receive', 'send', 'board', 'offboard', 'exit', 'ln-send', 'ln-receive', 'refresh', 'reconcile'].includes(m.type)
          && (m.status === 'complete' || (m.type === 'send' && m.status === 'failed')))
        .filter((m) => m.type !== 'refresh' || m.feeSat > 0)
        .sort((m, n) => (m.ts || 0) - (n.ts || 0))
        .filter((m) => {
          if (!m.type.startsWith('ln-') && !(m.type === 'refresh' && m.unlockHash)) return true;
          const key = m.type + ':' + (m.unlockHash || m.paymentHash || m.preimage || m.invoice || m.id);
          if (seenPay.has(key)) return false;
          seenPay.add(key);
          return true;
        });
      // Coins the server reported spent elsewhere: without a row for them the
      // history stops summing to the balance (cooney's looked 29k sats rich).
      // One reconcile pass marks many coins in the same instant — fold each
      // pass (and re-imported duplicates, deduped by coin) into one row.
      // A coin whose spend is ACCOUNTED FOR is excluded outright — a
      // renewal's inputs (the renewed coin balances the books invisibly),
      // and equally a send's, an offboard's, an exit's: those movements and
      // actions sync, so painting the vanished input beside the real Sent
      // row showed one spend twice, at input magnitude the second time.
      // The red row survives only for spends nothing anywhere explains.
      const accounted = new Set();
      for (const a of s.actions || []) {
        for (const id of a.inputIds || []) accounted.add(id);
        for (const part of a.parts || []) if (part.inputId) accounted.add(part.inputId);
      }
      for (const m of s.movements || []) for (const id of m.inputIds || []) accounted.add(id);
      const out = [];
      const seenCoin = new Set();
      for (const m of moves) {
        if (m.type !== 'reconcile') { out.push(m); continue; }
        if (m.vtxoId && (seenCoin.has(m.vtxoId) || accounted.has(m.vtxoId))) continue;
        if (m.vtxoId) seenCoin.add(m.vtxoId);
        const last = out[out.length - 1];
        if (last && last.type === 'reconcile' && last.ts === m.ts) {
          last.amountSat += m.amountSat;
          last.count += 1;
          if (m.vtxoId) last.vtxoIds.push(m.vtxoId);
        } else {
          out.push({ ...m, count: 1, vtxoIds: m.vtxoId ? [m.vtxoId] : [] });
        }
      }
      return exits.concat(out.map((m) => ({ time: m.ts, render: () => arkHistoryItem(m) })));
    },
    historyDetail() {
      if (ui.arkExitDetail) {
        const a = ((arkStateNow() && arkStateNow().actions) || []).find((x) => x.id === ui.arkExitDetail);
        if (a && !['done', 'failed'].includes(a.step)) return arkExitActionDetail(a);
        ui.arkExitDetail = null;
      }
      // the folded reconcile row isn't a stored movement — its detail rides
      // the ui state the row's tap put there (and nav history restores)
      if (ui.arkReconDetail && typeof ui.arkReconDetail === 'object') return arkReconDetailView(ui.arkReconDetail);
      if (!ui.arkMoveDetail) return null;
      const s = arkStateNow();
      const m = s ? (s.movements || []).find((x) => x.id === ui.arkMoveDetail) : null;
      if (m) return arkMoveDetailView(m);
      ui.arkMoveDetail = null;
      return null;
    },
    // The spendable off-chain balance IS the wallet's "Spending" — the balance
    // card shows it by name, so this feature only reports the number.
    // "Move money" under the balance — the one door between the two balances.
    balanceActions() { return []; }, // Move money retired: exits ride the Send field now
    balanceExtra() {
      if (!ui.arkMoveOpen || wallet.watchOnly || !arkAvailable()) return null;
      return movePanel();
    },
    // Sats mid-board (the on-chain tx awaiting its confirmation) — Spending
    // doesn't count them yet, but a top-up PROMPT must: nagging someone to
    // top up again while their top-up confirms is noise.
    spendingBoardingSat() {
      const b = arkBalance();
      return b ? b.boardingSat || 0 : 0;
    },
    spendingSat() {
      const b = arkBalance();
      return b ? b.spendableSat + b.pendingSat : 0;
    },
    balanceLines() {
      const b = arkBalance();
      if (!b) return [];
      // Money mid-move: it has left Saving but hasn't landed in Spending, so
      // say where it went rather than letting it vanish for a confirmation —
      // with the confirmation count, so the wait has a visible reason.
      if (!(b.boardingSat > 0)) return [];
      const a = ((arkStateNow() || {}).actions || []).find(
        (x) => x.type === 'board' && x.fundingTxid && !['done', 'failed'].includes(x.step) && x.needConfs);
      const prog = a ? ` · ${Math.min(a.confs || 0, a.needConfs)}/${a.needConfs}` : '';
      return [{ label: t('movingLabel') + prog, sat: b.boardingSat, side: 'spending' }];
    },
    walletNotices() {
      // Everything the balance needs to say, said once. These used to be a
      // stack of separate boxes — two red cards and a grey line, three
      // Manage links between them, all pointing at the same page. One card
      // now: red if anything in it is a warning, plain otherwise, and one
      // Manage at the bottom.
      const lines = []; // { text, err, manage }
      // A pending move that keeps erroring would otherwise wait in silence.
      for (const a of ((arkStateNow() || {}).actions || [])) {
        if (a.type === 'board' && a.lastError && !['done', 'failed'].includes(a.step))
          lines.push({ text: t('arkBoardStuck', { error: a.lastError }), err: true });
      }
      if (arkRenewWarn && !wallet.watchOnly) lines.push({
        text: t('arkRenewWarn', {
          amount: fmtAmount(arkRenewWarn.sat) + ' ' + unitLabel(),
          date: new Date(arkRenewWarn.deadlineMs).toLocaleDateString(),
        }), err: true,
      });
      // Coins past their expiry. The balance already leaves these out, and
      // until now it did so in silence — money apparently gone, with the one
      // page that could bring it back reachable only through an advisory
      // that most wallets never see (it wants four hops of depth) or a
      // renewal forecast that only appears when the renewal COSTS something,
      // which is no longer the normal case.
      //
      // An expired vtxo can still be renewed — that is the whole of the fix,
      // and it is one tap away on the Manage page. What it cannot do is be
      // spent over Ark or exited unilaterally, so saying nothing is the one
      // option that isn't honest.
      if (!wallet.watchOnly && ark && ark.balance) {
        let expiredSat = 0;
        try { expiredSat = ark.balance().expiredSat || 0; } catch {}
        if (expiredSat > 0) lines.push({
          text: t('arkExpiredNotice', { amount: fmtAmount(expiredSat) + ' ' + unitLabel() }), err: true, manage: true,
        });
      }
      const depthNotice = exitDepthNotice();
      if (depthNotice) lines.push({ text: depthNotice, manage: true });
      // An upcoming renewal that will COST something — stated before it
      // happens. Ark is new to nearly everyone, and a fee nobody announced
      // reads as money gone missing (it did, once). Free renewals — the
      // normal case now — pass without comment, and one line under the
      // balance is enough: the depth advisory outranks this forecast, and
      // Manage carries the full story either way.
      if (!depthNotice && ark && ark.state && ark._tipH && !wallet.watchOnly) {
        const spend = (ark.state.vtxos || []).filter((v) => v.state === 'spendable' && v.expiryHeight && !v.expiryRejected);
        if (spend.length) {
          const tip = ark._tipH;
          const RENEW = renewWindow();
          const minExpiry = Math.min(...spend.map((v) => v.expiryHeight));
          const blocksUntil = Math.max(0, minExpiry - RENEW - tip);
          // price it at the moment it will actually run: only the coins then
          // inside the window ride along, billed at that moment's bracket
          const simTip = minExpiry - RENEW + 1;
          const batch = spend.filter((v) => v.expiryHeight - simTip < RENEW);
          let feeSat = 0;
          try { feeSat = ark.refreshFee(batch, simTip); } catch {}
          const days = Math.max(1, Math.round(blocksUntil / 144));
          if (feeSat > 0) lines.push({
            text: t(blocksUntil <= 0 ? 'arkRenewForecastNow' : 'arkRenewForecast', {
              when: days === 1 ? t('arkCoinsSpanDay') : t('arkCoinsSpanDays', { n: days }),
              fee: fmtAmount(feeSat) + ' ' + unitLabel(),
            }), manage: true,
          });
        }
      }
      if (!lines.length) return [];
      const err = lines.some((l) => l.err);
      const manage = lines.some((l) => l.manage)
        ? h('button', { class: 'linklike small', style: 'align-self:flex-end', onClick: () => { ui.arkCoinsPage = true; render(); } }, t('arkDepthBtn'))
        : null;
      // one plain advisory keeps its quiet centred line; anything more, or
      // anything urgent, is a card
      if (!err && lines.length === 1) {
        return [h('div', { class: 'small muted', style: 'margin:10px 0 0;text-align:center' }, lines[0].text, manage ? ' ' : null, manage)];
      }
      return [h('div', { class: 'notice' + (err ? ' err' : ' info') + ' col', style: 'margin:12px 0 0;gap:8px' },
        ...lines.map((l) => h('div', { style: l.err || !err ? '' : 'opacity:.8' }, l.text)),
        manage)];
    },
    decorateTxRow(tx) {
      const s = arkStateNow();
      if (!s) return null;
      const acts = s.actions || [];
      if (tx.net < 0) {
        const a = acts.find((x) => x.type === 'board' && x.fundingTxid === tx.txid);
        return a ? { icon: h('span', { html: ARK_MARK(16) }), label: h('span', {}, t('arkBoardHistory')) } : null;
      }
      const o = acts.find((x) => x.type === 'offboard' && x.txid === tx.txid);
      if (o) return { icon: h('span', { html: ARK_MARK(16) }), label: h('span', {}, t('arkOffboardHistory')) };
      const e = acts.find((x) => x.type === 'exit' && x.claimTxid === tx.txid);
      return e ? { icon: h('span', { html: ARK_MARK(16) }), label: h('span', {}, t('arkExitHistory')) } : null;
    },
    txDetailSection(tx) {
      const s = arkStateNow();
      if (!s) return null;
      const a = (s.actions || []).find((x) => x.type === 'board' && x.fundingTxid === tx.txid);
      if (!a) return null;
      const done = a.step === 'done';
      return h('div', { class: 'summary col', style: 'gap:0' },
        h('div', { class: 'row gap6', style: 'font-weight:600;margin:12px 0 2px;align-items:center' }, h('span', { html: ARK_ICON(16) }), t('arkBoardHistory')),
        h('div', { class: 'line' },
          h('span', { class: 'k' }, t('arkBalance')),
          h('span', { class: 'v' }, '+' + fmtAmount(a.amountSat - a.feeSat) + ' ' + unitLabel())),
        a.feeSat > 0
          ? h('div', { class: 'line' },
              h('span', { class: 'k' }, t('arkBoardFeeLabel')),
              h('span', { class: 'v' }, fmtAmount(a.feeSat) + ' ' + unitLabel()))
          : null,
        done ? null : h('div', { class: 'small muted', style: 'margin-top:2px' }, boardedNote()));
    },

    // ---- ark-gift hooks (called by the gifts feature via ctx.hook) ----
    arkGiftInfo() {
      // Persisted state, not the live manager: the gift form renders before
      // connectArk() has run, and a null here silently flips the gift to the
      // on-chain source — "more than your balance" against Savings while the
      // header shows a healthy Spending balance. Creation connects on demand.
      const b = arkAvailable() ? arkBalance() : null;
      if (!b) return null;
      maybeReconcile(); // the gift form is a send-intent signal too (throttled)
      return { spendableSat: b.spendableSat, pendingSat: b.pendingSat };
    },
    arkGiftDecode(code) { return decodeArkGiftCode(code); },
    // A fresh visitor (no wallets) opening a gift link lands on the gift's
    // network automatically instead of being told to change Settings.
    arkGiftAdoptNetwork(code) {
      const g = decodeArkGiftCode(code);
      if (!g || g.net === getNetwork()) return false;
      setNetwork(g.net);
      return true;
    },
    arkGiftCreate(amountSat) { return createArkGift(amountSat); },
    // Claim-side status: claimable (with the live amount), taken, wrongnet, or
    // unknown (not visible here — wrong server or not yet delivered).
    async arkGiftStatus(code) {
      const g = decodeArkGiftCode(code);
      if (!g) return null;
      if (g.net !== getNetwork()) return { state: 'wrongnet', net: g.net, amountSat: g.amountSat };
      const gm = await giftManager(g.secretHex);
      await gm.sync().catch(() => {});
      await gm.reconcile().catch(() => {});
      const amt = gm.balance().spendableSat;
      if (amt > 0) return { state: 'claimable', amountSat: amt };
      const seen = gm.state.vtxos.length > 0;
      return { state: seen ? 'taken' : 'unknown', amountSat: g.amountSat };
    },
    async arkGiftClaim(code) {
      if (wallet.watchOnly) throw new Error(t('arkWatchOnly'));
      const mine = await connectArk();
      const amount = await sweepArkGift(code, mine.address());
      await mine.sync().catch(() => {}); // pull the swept vtxo in right away
      mine.ackReceives(); // the gift UI celebrates; don't double-celebrate here
      return amount;
    },
    arkGiftOutstanding() {
      refreshArkGiftRecords();
      return arkGiftRecords().filter((g) => !g.revoked && !g.claimed)
        .map((g) => ({ id: g.id, amountSat: g.amountSat, created: g.created }));
    },
    async arkGiftRevoke(id) { return doArkGiftRevoke(id); },
  };

  async function doArkGiftRevoke(id) {
    const g = arkGiftRecords().find((x) => x.id === id);
    if (!g) throw new Error('unknown gift');
    const mine = await connectArk();
    const code = encodeArkGiftCode(getNetwork(), g.amountSat, hex.decode(g.secretHex));
    let amount;
    try {
      amount = await sweepArkGift(code, mine.address());
    } catch (e) {
      // beaten by the claimer — record it so the row self-heals immediately
      if (e && e.giftTaken) { g.claimed = true; mine._save(); }
      throw e;
    }
    g.revoked = true;
    mine._save();
    await mine.sync().catch(() => {});
    mine.ackReceives(); // our own sweep-back isn't a "payment received"
    return amount;
  }
}