@forgesworn/moneyer 0.10.0 → 0.11.1

package/CHANGELOG.md

@@ -1,6 +1,40 @@
 # Changelog
 
-## Unreleased
+## 0.11.1 - 2026-09-07
+
+- Hash lookups report `Note already spent.` for retained burned notes,
+  `Unknown note.` for unregistered hashes, and `pending` for unresolved
+  melts. This follows the proposed LUD-25 status revision and lets wallets
+  recognise a redeemed note without sending its bearer secret. Existing
+  burned rows are retained already; no database migration is required.
+- Test tooling uses an immutable conformance commit matching this response
+  contract. It is a development dependency, not a runtime dependency.
+
+## 0.11.0 - 2026-09-06
+
+**Three fields the reference mint publishes and moneyer did not.** Each
+answers a question a wallet had no way to ask.
+
+- `nodeUris` - every address the funding node announces, not just the first.
+  A node reachable over Tor as well as clearnet announces both, and `nodeUri`
+  alone told a peer about a door it may not be able to open. `nodeUri` is
+  unchanged and stays the first of the list. lnd already fetched all of them;
+  cln now builds the list the same way instead of taking `address[0]`.
+- `sunsetDate` - `MONEYER_SUNSET_DATE`, an ISO-8601 day, published so a wallet
+  can warn its holder while spending is still possible. Deliberately separate
+  from `MONEYER_SUNSET`, which stops minting: by the time that flag goes on,
+  a holder who was going to be told has already not been told. The value is
+  validated at boot, so a typo fails loudly rather than putting a wrong date
+  in front of a holder. It also shows on the mint's own landing page.
+- `outstandingNotesMsat` - what the mint owes, in msat. A fact about its own
+  database, so it survives an unreachable funding source, but it is the same
+  disclosure `/stats` makes and answers to the same two switches:
+  `MONEYER_STATS=false` or `MONEYER_STATS_RATIO_ONLY=true` leaves it off.
+
+- Graded against `lnurlcash-conformance` 0.7.0. Its one addition is
+  `cash-derivation.json`, LUD-25's own seed-recoverable note secrets, which is
+  a wallet-side vector - a mint never sees a derivation, only `sha256(k1)`. So
+  nothing here changes; the pin moves so the grade names the current suite.
 
 ## 0.10.0 - 2026-09-04
 

package/README.md

@@ -114,6 +114,7 @@ default, and a variable set to an empty string counts as unset.
 | `MONEYER_VERIFY` | `true` | the LUD-21 `verify` endpoint. Off means 404 |
 | `MONEYER_WALLET_URL` | | a companion web wallet the mint's site links notes into |
 | `MONEYER_SUNSET` | `false` | wind down: refuse anything that grows liabilities, keep every way out open |
+| `MONEYER_SUNSET_DATE` | | the day this mint plans to close, ISO-8601 (`2026-12-31`). Published so a wallet can warn its holder while spending is still possible |
 | `MONEYER_STATS` | `true` | the `/stats` endpoint. Off means 404 |
 | `MONEYER_STATS_RATIO_ONLY` | `false` | publish the coverage ratio alone, without the size of the book |
 | `MONEYER_STATS_PUBLISH` | `false` | publish a signed hourly snapshot of `/stats` to Nostr |
@@ -239,6 +240,13 @@ endpoint is public by design. `MONEYER_STATS=false` switches it off;
 `MONEYER_STATS_RATIO_ONLY=true` publishes the ratio without the size of
 the book.
 
+The discovery document carries the same number as `outstandingNotesMsat`,
+so a wallet reading a mint address learns what it owes without a second
+request. Both switches govern it: an operator who has turned `/stats` off,
+or down to the ratio, has already said not to publish the size of the
+book, and a second endpoint doing it anyway would make those switches a
+lie.
+
 ### Signed snapshots
 
 With `MONEYER_STATS_PUBLISH=true`, and the Nostr identity that

package/dist/backends/cln.js

@@ -126,8 +126,15 @@ export const createClnBackend = (config) => {
         async nodeInfo() {
             const info = await mustCall('/v1/getinfo', {});
             const id = info?.id;
-            const address = (info?.address ?? [])[0];
-            const uri = id && address?.address && address?.port ? `${id}@${address.address}:${address.port}` : id;
+            // Every announced address, not just the first: a node reachable over
+            // both Tor and clearnet announces both, and a peer that can only use
+            // one of them needs to be told about it.
+            const uris = id
+                ? (info?.address ?? [])
+                    .filter((entry) => entry?.address && entry?.port)
+                    .map((entry) => `${id}@${entry.address}:${entry.port}`)
+                : [];
+            const uri = uris[0] ?? id;
             const color = typeof info?.color === 'string' ? `#${info.color.replace(/^#/, '')}` : undefined;
             const numChannels = Number(info?.num_active_channels);
             const numPeers = Number(info?.num_peers);
@@ -146,6 +153,7 @@ export const createClnBackend = (config) => {
             return {
                 ...(info?.alias ? { alias: info.alias } : {}),
                 ...(uri ? { uri } : {}),
+                ...(uris.length ? { uris } : {}),
                 ...(color && /^#[0-9a-fA-F]{6}$/.test(color) ? { color } : {}),
                 ...(Number.isSafeInteger(numChannels) ? { numChannels } : {}),
                 ...(Number.isSafeInteger(numPeers) ? { numPeers } : {}),

package/dist/backends/lnd.js

@@ -224,6 +224,10 @@ export const createLndBackend = (config) => {
             return {
                 ...(res.json?.alias ? { alias: res.json.alias } : {}),
                 ...(uris[0] || res.json?.identity_pubkey ? { uri: uris[0] ?? res.json.identity_pubkey } : {}),
+                // getinfo already hands back every announced address; `uri` only
+                // ever carried the first. A node with nothing announced falls back
+                // to the bare pubkey above and has no list to publish.
+                ...(uris.length ? { uris } : {}),
                 ...(color && /^#[0-9a-fA-F]{6}$/.test(color) ? { color } : {}),
                 // !== undefined narrows for exactOptionalPropertyTypes; the isFinite
                 // half keeps a NaN from an unparseable channel capacity out.

package/dist/backends/types.d.ts

@@ -1,6 +1,7 @@
 export type NodeInfo = {
     alias?: string;
     uri?: string;
+    uris?: string[];
     color?: string;
     capacityMsat?: number;
     numChannels?: number;

package/dist/config.d.ts

@@ -46,6 +46,7 @@ export type MoneyerConfig = {
     announce?: boolean;
     metrics?: boolean;
     sunset: boolean;
+    sunsetDate?: string;
     zap?: ZapConfig;
     namePriceMsat?: number;
 };

package/dist/config.js

@@ -94,6 +94,7 @@ export const configFromEnv = (env = process.env) => {
         throw new Error('MONEYER_SIGNING_KEY must be 32 bytes of hex.');
     }
     const previousSigningPubkeys = previousPubkeysFromEnv(env, signingKey);
+    const sunsetDate = sunsetDateFromEnv(env);
     const kind = env.MONEYER_BACKEND ?? 'fake';
     let backend;
     if (kind === 'fake') {
@@ -225,10 +226,33 @@ export const configFromEnv = (env = process.env) => {
         ...(env.MONEYER_WALLET_URL ? { walletUrl: env.MONEYER_WALLET_URL.replace(/\/+$/, '') } : {}),
         maxK1s: int(env.MONEYER_MAX_K1S, DEFAULTS.maxK1s),
         sunset: flag(env.MONEYER_SUNSET, DEFAULTS.sunset),
+        ...(sunsetDate ? { sunsetDate } : {}),
         ...(zap ? { zap } : {}),
         ...(namePriceMsat !== undefined ? { namePriceMsat } : {})
     };
 };
+// MONEYER_SUNSET_DATE="2026-12-31" - the day this mint plans to stop.
+// Validated rather than passed through, because a wallet showing a holder
+// "this mint closes on 31/12/2026" off a string nobody checked is worse
+// than showing nothing: a typo that parses as a date in 2027 buys the
+// holder confidence they have not earned, and one that parses as nothing
+// silently disables the warning the operator thought they had switched on.
+// Whole days only - an hour of notice is not notice.
+const sunsetDateFromEnv = (env) => {
+    const raw = env.MONEYER_SUNSET_DATE?.trim();
+    if (!raw)
+        return undefined;
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        throw new Error('MONEYER_SUNSET_DATE must be an ISO-8601 date, e.g. 2026-12-31.');
+    }
+    // Round-tripped, so 2026-02-31 is caught: Date accepts it and rolls it
+    // forward to 3 March, which is not the day the operator typed.
+    const parsed = new Date(`${raw}T00:00:00Z`);
+    if (Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== raw) {
+        throw new Error(`MONEYER_SUNSET_DATE is not a real date: ${JSON.stringify(raw)}.`);
+    }
+    return raw;
+};
 // MONEYER_PREVIOUS_SIGNING_PUBKEYS="02ab...,03cd..." - the keys this mint
 // signed under before the current one. Every entry must be a point the
 // curve accepts, because a typo here would quietly tell wallets to accept

package/dist/landing.js

@@ -93,6 +93,7 @@ ${mintPubkey ? `<div class="kv"><span>notes signed by</span><code>${escapeHtml(m
 ${nodeInfo.uri ? `<div class="kv"><span>node</span><code>${escapeHtml(nodeInfo.uri)}</code></div>` : ''}
 ${coverageLine ? `<div class="kv"><span>coverage</span><b>${escapeHtml(coverageLine)}</b></div>` : ''}
 ${config.sunset ? '<div class="kv"><span>status</span><b>sunsetting - redeem only</b></div>' : ''}
+${!config.sunset && config.sunsetDate ? `<div class="kv"><span>closing</span><b>${escapeHtml(config.sunsetDate)} - spend or move notes before then</b></div>` : ''}
 ${contacts.map(entry => `<div class="kv"><span>${entry.label}</span><code>${escapeHtml(entry.value)}</code></div>`).join('\n')}
 ${config.tosUrl ? `<div class="kv"><span>terms</span><a href="${escapeHtml(config.tosUrl)}" rel="noopener noreferrer">${escapeHtml(config.tosUrl)}</a></div>` : ''}
 </div>

package/dist/server.js

@@ -249,7 +249,25 @@ export const createMoneyer = async (config, deps = {}) => {
             ? { nodeCapacity: nodeInfo.capacityMsat, nodeCapacityMsat: nodeInfo.capacityMsat }
             : {}),
         ...(nodeInfo.numChannels !== undefined ? { nodeNumChannels: nodeInfo.numChannels } : {}),
-        ...(nodeInfo.numPeers !== undefined ? { nodeNumPeers: nodeInfo.numPeers } : {})
+        ...(nodeInfo.numPeers !== undefined ? { nodeNumPeers: nodeInfo.numPeers } : {}),
+        // Every address the node announces. nodeUri stays, and stays the
+        // first of these: a wallet that only reads the singular field must
+        // keep working, and the reference mint publishes both for the same
+        // reason.
+        ...(nodeInfo.uris?.length ? { nodeUris: nodeInfo.uris } : {}),
+        // Advance warning of a planned shutdown, so a wallet can tell its
+        // holder while spending is still possible.
+        ...(config.sunsetDate ? { sunsetDate: config.sunsetDate } : {}),
+        // What this mint owes, in msat: the combined value of every note it
+        // has issued and not burned. A fact about its own database, so it
+        // survives an unreachable funding source - but it is the same
+        // disclosure /stats makes, so it answers to the same two switches. An
+        // operator who has turned stats off, or down to the coverage ratio
+        // alone, has already said not to put the size of the book on the
+        // internet, and this endpoint is not a way around that.
+        ...(config.stats !== false && config.statsRatioOnly !== true
+            ? { outstandingNotesMsat: store.liabilities().outstandingMsat }
+            : {})
     });
     // An hourly signed snapshot, so the coverage history can be checked
     // after the fact rather than taken on the operator's word for it today.
@@ -819,12 +837,10 @@ export const createMoneyer = async (config, deps = {}) => {
             const note = h ? await resolveNoteId(h) : await resolveNote(k1);
             if (!note)
                 return fail('Unknown note.');
-            // A hash-only lookup must not disclose whether a note id once existed:
-            // LUD-25 gives a never-registered and an already-spent h the same
-            // response as an unknown k1. A caller presenting the bearer k1 still
-            // receives the useful already-spent distinction.
+            // Hash lookups protect the secret, not the note's spent state.
+            // Retained burned rows let a wallet reconcile without revealing k1.
             if (note.state === 'burned')
-                return fail(h ? 'Unknown note.' : 'Note already spent.');
+                return fail('Note already spent.');
             // A note reserved by an in-flight melt is not withdrawable, and must
             // not be advertised as though it were. LUD-25 makes this GET the way
             // anyone checks what a note is worth, so answering "live, worth all

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgesworn/moneyer",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "An LNURLcash (LUD-25) mint - strikes Lightning bearer notes. Independent implementation, cln/lnd funding sources, SQLite, zero HTTP framework.",
   "author": "TheCryptoDonkey",
   "license": "MIT",
@@ -70,7 +70,7 @@
     "@types/node": "^24.0.0",
     "animejs": "^4.0.0",
     "happy-dom": "^20.0.0",
-    "lnurlcash-conformance": "^0.6.0",
+    "lnurlcash-conformance": "https://codeload.github.com/lnurlcash/lnurlcash-conformance/tar.gz/6c6aee66cf1b6cba72a03af976ecec113f470c9e",
     "playwright": "^1.62.1",
     "typescript": "^5.7.0",
     "uqr": "^0.1.2",