@forgesworn/moneyer 0.16.2 → 0.17.1

package/dist/kernel.js

@@ -0,0 +1,105 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { encodeCw1 } from "./spend.js";
+// A ScriptVerifier backed by a long-lived child process speaking one JSON
+// request and one JSON reply per line: scripts/kernel-verifier.py, which
+// runs Bitcoin Core's own interpreter through lnurlcash-kernel.
+//
+// LUD-25 has a mint accept any consensus-valid tapscript, and moneyer is
+// not a tapscript interpreter. Rather than write one, it borrows the one
+// the reference mint uses, so the two mints accept and refuse exactly the
+// same spends.
+//
+// Anything short of a verdict - the process missing, crashing, answering
+// with an error, or too slowly - refuses the spend. The note is untouched
+// and the wallet can try again; accepting on a broken verifier would be
+// the one unrecoverable answer.
+export const UNAVAILABLE = 'script verification is unavailable - try again later';
+export const createKernelVerifier = (options) => {
+    const [program, ...args] = options.command;
+    if (!program)
+        throw new Error('The script verifier needs a command.');
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const log = options.log ?? (() => { });
+    let child = null;
+    let nextId = 1;
+    const pending = new Map();
+    const settle = (id, reason) => {
+        const waiting = pending.get(id);
+        if (!waiting)
+            return;
+        clearTimeout(waiting.timer);
+        pending.delete(id);
+        waiting.resolve(reason);
+    };
+    const refuseAll = () => {
+        for (const id of [...pending.keys()])
+            settle(id, UNAVAILABLE);
+    };
+    const running = () => {
+        if (child)
+            return child;
+        const started = spawn(program, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+        started.on('error', err => {
+            log(`script verifier failed to start: ${err.message}`);
+            if (child === started)
+                child = null;
+            refuseAll();
+        });
+        started.on('exit', code => {
+            log(`script verifier exited (${code ?? 'signal'})`);
+            if (child === started)
+                child = null;
+            refuseAll();
+        });
+        // A write to a process that has just died fails asynchronously; the
+        // exit handler above has already refused whatever was waiting.
+        started.stdin.on('error', err => log(`script verifier stdin: ${err.message}`));
+        started.stderr.on('data', chunk => log(`script verifier: ${String(chunk).trim()}`));
+        createInterface({ input: started.stdout }).on('line', line => {
+            let reply;
+            try {
+                reply = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (typeof reply.id !== 'number')
+                return;
+            if (reply.ok === true)
+                settle(reply.id, null);
+            else if (typeof reply.reason === 'string')
+                settle(reply.id, reply.reason);
+            else {
+                log(`script verifier error: ${String(reply.error)}`);
+                settle(reply.id, UNAVAILABLE);
+            }
+        });
+        child = started;
+        return started;
+    };
+    const verify = ({ outputKey, domain, spend, now, lockedAt }) => new Promise(resolve => {
+        const id = nextId++;
+        const timer = setTimeout(() => {
+            log('script verifier timed out');
+            settle(id, UNAVAILABLE);
+        }, timeoutMs);
+        pending.set(id, { resolve, timer });
+        const request = { id, q: bytesToHex(outputKey), domain, cw1: encodeCw1(spend), now, locked_at: lockedAt };
+        try {
+            running().stdin.write(`${JSON.stringify(request)}\n`);
+        }
+        catch (err) {
+            log(`script verifier unreachable: ${err.message}`);
+            settle(id, UNAVAILABLE);
+        }
+    });
+    return Object.assign(verify, {
+        close: () => {
+            refuseAll();
+            child?.kill();
+            child = null;
+        }
+    });
+};

package/dist/names.d.ts

@@ -1,4 +1,4 @@
-import { NoteStore } from './store.ts';
+import { NoteStore, type NoteRow } from './store.ts';
 export declare const NIP98_KIND = 27235;
 export declare const NIP98_WINDOW_SECS = 60;
 export declare const NAME_RULE: RegExp;
@@ -16,6 +16,13 @@ export declare const validateNip98: (authorization: string | undefined, request:
     body: string;
     nowSecs?: number;
 }) => Nip98Success | Nip98Failure;
+export declare const addressProofVerifies: (args: {
+    cx1: string;
+    action: "register" | "unregister";
+    name: string;
+    domains: string[];
+    sig: unknown;
+}) => boolean;
 export type NameRefusal = {
     reason: string;
     status: number;
@@ -35,8 +42,11 @@ export declare const registerName: (args: {
         name?: unknown;
         note?: unknown;
         cx1?: unknown;
+        sig?: unknown;
     };
     priceMsat: number | undefined;
     reserved: string[];
     host: string;
-}) => NameGranted | NameRefusal;
+    domains: string[];
+    openNote: (k1: string) => Promise<NoteRow | null>;
+}) => Promise<NameGranted | NameRefusal>;

package/dist/names.js

@@ -1,8 +1,10 @@
 import { sha256 } from '@noble/hashes/sha2.js';
-import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+import { schnorr } from '@noble/curves/secp256k1.js';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils.js';
 import { verifyEvent } from 'nostr-tools/pure';
-import { decodeCx1, hashK1, noteK1 } from '@lnurlcash/kit';
+import { decodeCx1, noteK1 } from '@lnurlcash/kit';
 import { NotePendingError, NoteStore, NoteUnavailableError } from "./store.js";
+import { NOTE_PURPOSE_WALLET, decodeSpend, deriveNotePubkey } from "./spend.js";
 // Self-service lightning addresses.
 //
 // A name here is a lightning address whose payouts are bearer notes
@@ -85,6 +87,35 @@ export const validateNip98 = (authorization, request) => {
     }
     return { pubkey: event.pubkey };
 };
+// LUD-25's address proof. A cx1 is public, so pointing a name at one, or
+// away from one, has to be proven by the branch itself: a BIP-340
+// signature by its index-0 key over sha256("LNURLcash:<action>:<domain>:
+// <name>"). The domain is this mint's own, so a proof one mint has seen
+// cannot be replayed at another; the action and name are in it so a
+// register cannot be replayed as an unregister, or for another name.
+export const addressProofVerifies = (args) => {
+    if (typeof args.sig !== 'string' || !/^[0-9a-f]{128}$/i.test(args.sig))
+        return false;
+    const branch = decodeCx1(args.cx1);
+    if (!branch)
+        return false;
+    let firstKey;
+    try {
+        firstKey = deriveNotePubkey(branch.pubkeyXOnly, branch.chainCode, NOTE_PURPOSE_WALLET, 0);
+    }
+    catch {
+        return false;
+    }
+    const signature = hexToBytes(args.sig.toLowerCase());
+    return args.domains.some(domain => {
+        try {
+            return schnorr.verify(signature, sha256(utf8ToBytes(`LNURLcash:${args.action}:${domain}:${args.name}`)), firstKey);
+        }
+        catch {
+            return false;
+        }
+    });
+};
 const refuse = (reason, status) => ({ reason, status });
 export const isRefusal = (result) => 'reason' in result;
 // The whole registration, minus the transport. Burning the note and
@@ -92,7 +123,7 @@ export const isRefusal = (result) => 'reason' in result;
 // exists without payment is worse than a note burned without a name,
 // and the INSERT is what settles a race between two people asking for
 // the same name at once.
-export const registerName = (args) => {
+export const registerName = async (args) => {
     const { store, pubkey, priceMsat } = args;
     const raw = typeof args.body.name === 'string' ? args.body.name.trim().toLowerCase() : '';
     if (!NAME_RULE.test(raw)) {
@@ -113,10 +144,19 @@ export const registerName = (args) => {
             return refuse('That is not a cx1.', 400);
         cx1 = given;
     }
+    const proven = (branch, action) => addressProofVerifies({ cx1: branch, action, name: raw, domains: args.domains, sig: args.body.sig });
+    const unproven = refuse('Setting or clearing a cx1 needs "sig": the branch\'s index-0 key signing sha256("LNURLcash:register:<domain>:<name>"), or :unregister: to clear.', 403);
     const existing = store.zapName(raw);
     if (existing) {
-        // Its owner may set or clear the branch; nobody else may touch it.
+        // Its owner may set or clear the branch; nobody else may touch it. The
+        // NIP-98 key owns the name, and the branch on file must agree to any
+        // change of where it pays: LUD-25 has an overwrite proven by the
+        // branch currently registered, not the one being switched to.
         if (existing.pubkey === pubkey && cx1 !== undefined) {
+            if (cx1 === null && existing.cx1 && !proven(existing.cx1, 'unregister'))
+                return unproven;
+            if (cx1 !== null && !proven(existing.cx1 ?? cx1, 'register'))
+                return unproven;
             store.setZapNameCx1(raw, cx1);
             return { name: raw, pubkey, paidMsat: 0, cx1, updated: true };
         }
@@ -126,6 +166,9 @@ export const registerName = (args) => {
     // names, not a holder choosing where their own name pays.
     if (priceMsat === undefined)
         return refuse('This mint is not registering names.', 404);
+    // A fresh name pointed at a branch proves control of that branch.
+    if (typeof cx1 === 'string' && !proven(cx1, 'register'))
+        return unproven;
     let paidMsat = 0;
     let noteId;
     if (priceMsat === 0) {
@@ -145,8 +188,8 @@ export const registerName = (args) => {
         // plain-http service - correct for a wallet reaching a stranger, and
         // wrong for a mint reading a note it minted itself.
         let k1 = null;
-        if (/^[0-9a-f]{64}$/i.test(offered)) {
-            k1 = offered.toLowerCase();
+        if (decodeSpend(offered)) {
+            k1 = offered;
         }
         else {
             let url;
@@ -162,7 +205,7 @@ export const registerName = (args) => {
         }
         if (!k1)
             return refuse('That is not a note.', 400);
-        const note = store.noteById(hashK1(k1));
+        const note = await args.openNote(k1);
         if (!note || note.state === 'burned')
             return refuse('That note is spent or was never minted here.', 400);
         if (note.state === 'pending')

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import type { MoneyerConfig } from './config.ts';
 import { NoteStore } from './store.ts';
 import { type NoteSigner } from './signing.ts';
+import { type ScriptVerifier } from './spend.ts';
 import { type LightningBackend } from './backends/types.ts';
 import { type NostrTransport, type ZapBridge } from './zap.ts';
 import { type MintStats } from './stats.ts';
@@ -28,7 +29,11 @@ export type MoneyerDeps = {
     nostr?: NostrTransport;
     zapPollMs?: number;
     statsPublishMs?: number;
+    scriptVerifier?: ScriptVerifier;
 };
 export { describeFee } from './fee-words.ts';
 export declare const createMoneyer: (config: MoneyerConfig, deps?: MoneyerDeps) => Promise<Moneyer>;
-export declare const sweepExpiredMintInvoices: (store: NoteStore, nowMs?: number) => number;
+export declare const sweepExpiredMintInvoices: (store: NoteStore, backend: Pick<LightningBackend, "isInvoiceSettled">, nowMs?: number) => Promise<{
+    swept: number;
+    settled: number;
+}>;