@forgesworn/moneyer 0.1.2 → 0.2.0

package/dist/backends/fake.d.ts

@@ -1,5 +1,8 @@
 import { type LightningBackend } from './types.ts';
 export type FakePayMode = 'succeed' | 'fail-clean' | 'fail-then-paid' | 'ambiguous-paid' | 'ambiguous-unpaid' | 'ambiguous-pending';
+export type FakeBackendOptions = {
+    autoSettle?: boolean;
+};
 export type FakeBackend = LightningBackend & {
     control: {
         settleInvoice(paymentHashHex: string): void;
@@ -12,6 +15,9 @@ export type FakeBackend = LightningBackend & {
             amountMsat: number;
             settled: boolean;
         } | undefined;
+        sentAmountMsat(paymentHashHex: string): number | null | undefined;
+        setLocalBalanceMsat(msat: number | undefined): void;
     };
 };
-export declare const createFakeBackend: () => FakeBackend;
+export declare const FAKE_LOCAL_BALANCE_MSAT = 100000000000;
+export declare const createFakeBackend: (options?: FakeBackendOptions) => FakeBackend;

package/dist/backends/fake.js

@@ -4,20 +4,24 @@ import { hexToBytes } from '@noble/hashes/utils.js';
 import { bolt11PaymentHash } from 'farrier-kit/bolt11';
 import { fakeBolt11 } from "./fake-bolt11.js";
 import { PaymentAlreadyKnownError, PaymentFailedError, PaymentPendingError } from "./types.js";
-export const createFakeBackend = () => {
+// One bitcoin, so a development mint covers anything it is likely to mint.
+export const FAKE_LOCAL_BALANCE_MSAT = 100_000_000_000;
+export const createFakeBackend = (options = {}) => {
+    const autoSettle = options.autoSettle === true;
     const invoices = new Map();
     const payments = new Map();
     const knownPreimages = new Map();
+    let localBalanceMsat = FAKE_LOCAL_BALANCE_MSAT;
     let payMode = 'succeed';
     return {
         name: 'fake',
         async createInvoice({ amountMsat, preimageHex, memo }) {
             const paymentHashHex = bytesToHex(sha256(hexToBytes(preimageHex)));
             const pr = fakeBolt11({ amountMsat, paymentHashHex, memo });
-            invoices.set(paymentHashHex, { preimageHex, amountMsat, settled: false });
+            invoices.set(paymentHashHex, { preimageHex, amountMsat, settled: autoSettle });
             return { pr };
         },
-        async payInvoice({ pr }) {
+        async payInvoice({ pr, amountMsat }) {
             const paymentHashHex = bolt11PaymentHash(pr);
             if (!paymentHashHex)
                 throw new PaymentFailedError('That is not a decodable invoice.');
@@ -27,24 +31,25 @@ export const createFakeBackend = () => {
                 throw new PaymentAlreadyKnownError('this node already has a payment for that hash');
             }
             const preimageHex = knownPreimages.get(paymentHashHex) ?? null;
+            const sentMsat = amountMsat ?? null;
             switch (payMode) {
                 case 'succeed':
-                    payments.set(paymentHashHex, { status: 'complete', preimageHex });
+                    payments.set(paymentHashHex, { status: 'complete', preimageHex, amountMsat: sentMsat });
                     return { preimageHex, feeMsat: 0 };
                 case 'fail-clean':
-                    payments.set(paymentHashHex, { status: 'failed', preimageHex: null });
+                    payments.set(paymentHashHex, { status: 'failed', preimageHex: null, amountMsat: sentMsat });
                     throw new PaymentFailedError('Could not find a route to pay this invoice.');
                 case 'fail-then-paid':
-                    payments.set(paymentHashHex, { status: 'complete', preimageHex });
+                    payments.set(paymentHashHex, { status: 'complete', preimageHex, amountMsat: sentMsat });
                     throw new PaymentFailedError('Timed out trying to find a route to pay this invoice.');
                 case 'ambiguous-paid':
-                    payments.set(paymentHashHex, { status: 'complete', preimageHex });
+                    payments.set(paymentHashHex, { status: 'complete', preimageHex, amountMsat: sentMsat });
                     throw new Error('connection reset mid-payment');
                 case 'ambiguous-unpaid':
-                    payments.set(paymentHashHex, { status: 'failed', preimageHex: null });
+                    payments.set(paymentHashHex, { status: 'failed', preimageHex: null, amountMsat: sentMsat });
                     throw new Error('connection reset mid-payment');
                 case 'ambiguous-pending':
-                    payments.set(paymentHashHex, { status: 'pending', preimageHex });
+                    payments.set(paymentHashHex, { status: 'pending', preimageHex, amountMsat: sentMsat });
                     throw new Error('connection reset mid-payment');
             }
         },
@@ -69,7 +74,11 @@ export const createFakeBackend = () => {
             return payment?.status === 'complete' ? payment.preimageHex : null;
         },
         async nodeInfo() {
-            return { alias: 'moneyer (fake funding source)', color: '#c9ced8' };
+            return {
+                alias: 'moneyer (fake funding source)',
+                color: '#c9ced8',
+                ...(localBalanceMsat !== undefined ? { localBalanceMsat } : {})
+            };
         },
         control: {
             settleInvoice(paymentHashHex) {
@@ -94,7 +103,14 @@ export const createFakeBackend = () => {
                     payment.preimageHex = preimageHex;
             },
             seedForeignPayment(paymentHashHex, status = 'complete') {
-                payments.set(paymentHashHex, { status, preimageHex: null });
+                payments.set(paymentHashHex, { status, preimageHex: null, amountMsat: null });
+            },
+            sentAmountMsat(paymentHashHex) {
+                const payment = payments.get(paymentHashHex);
+                return payment ? payment.amountMsat : undefined;
+            },
+            setLocalBalanceMsat(msat) {
+                localBalanceMsat = msat;
             },
             invoiceByHash(paymentHashHex) {
                 return invoices.get(paymentHashHex);

package/dist/backends/lnd.js

@@ -1,4 +1,5 @@
-import { hexToBytes } from '@noble/hashes/utils.js';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+import { sha256 } from '@noble/hashes/sha2.js';
 import { verifyPreimage } from 'farrier-kit/preimage';
 import { PaymentAlreadyKnownError, PaymentFailedError, PaymentPendingError } from "./types.js";
 // lnd over its REST proxy. AddInvoice never returns a preimage but accepts
@@ -81,20 +82,33 @@ export const createLndBackend = (config) => {
     };
     return {
         name: 'lnd',
-        async createInvoice({ amountMsat, preimageHex, memo }) {
+        async createInvoice({ amountMsat, preimageHex, memo, descriptionForHash }) {
             const res = await json('/v1/invoices', {
                 method: 'POST',
-                body: { value_msat: String(amountMsat), memo, r_preimage: hexToBase64(preimageHex) }
+                body: {
+                    value_msat: String(amountMsat),
+                    r_preimage: hexToBase64(preimageHex),
+                    ...(descriptionForHash === undefined
+                        ? { memo }
+                        : { description_hash: hexToBase64(bytesToHex(sha256(utf8ToBytes(descriptionForHash)))) })
+                }
             });
             if (!res.ok || typeof res.json?.payment_request !== 'string') {
                 throw new Error(`lnd did not return a payment_request (${res.status}).`);
             }
             return { pr: res.json.payment_request };
         },
-        async payInvoice({ pr, feeLimitMsat }) {
+        async payInvoice({ pr, feeLimitMsat, amountMsat }) {
             const { result, error } = await streamUntil('/v2/router/send', {
                 method: 'POST',
-                body: { payment_request: pr, timeout_seconds: 60, fee_limit_msat: String(feeLimitMsat) },
+                body: {
+                    payment_request: pr,
+                    timeout_seconds: 60,
+                    fee_limit_msat: String(feeLimitMsat),
+                    // Only for an invoice that states no amount: lnd refuses
+                    // amt_msat alongside one that does.
+                    ...(amountMsat !== undefined ? { amt_msat: String(amountMsat) } : {})
+                },
                 timeoutMs: 90_000
             }, payment => (payment?.status === 'SUCCEEDED' || payment?.status === 'FAILED' ? payment : undefined));
             if (!result) {
@@ -176,6 +190,15 @@ export const createLndBackend = (config) => {
             if (channels.ok && Array.isArray(channels.json?.channels)) {
                 capacityMsat = channels.json.channels.reduce((sum, channel) => sum + Number(channel.capacity ?? 0) * 1000, 0);
             }
+            // Outbound liquidity, best-effort for the same reason as capacity:
+            // the macaroon may not carry offchain:read.
+            let localBalanceMsat;
+            const balance = await json('/v1/balance/channels');
+            if (balance.ok) {
+                const msat = Number(balance.json?.local_balance?.msat);
+                if (Number.isSafeInteger(msat))
+                    localBalanceMsat = msat;
+            }
             return {
                 ...(res.json?.alias ? { alias: res.json.alias } : {}),
                 ...(uris[0] || res.json?.identity_pubkey ? { uri: uris[0] ?? res.json.identity_pubkey } : {}),
@@ -184,7 +207,8 @@ export const createLndBackend = (config) => {
                 // half keeps a NaN from an unparseable channel capacity out.
                 ...(capacityMsat !== undefined && Number.isFinite(capacityMsat) ? { capacityMsat } : {}),
                 ...(Number.isSafeInteger(numChannels) ? { numChannels } : {}),
-                ...(Number.isSafeInteger(numPeers) ? { numPeers } : {})
+                ...(Number.isSafeInteger(numPeers) ? { numPeers } : {}),
+                ...(localBalanceMsat !== undefined ? { localBalanceMsat } : {})
             };
         }
     };

package/dist/backends/types.d.ts

@@ -5,6 +5,7 @@ export type NodeInfo = {
     capacityMsat?: number;
     numChannels?: number;
     numPeers?: number;
+    localBalanceMsat?: number;
 };
 export type PaymentOutcome = {
     preimageHex: string | null;
@@ -22,12 +23,14 @@ export interface LightningBackend {
         amountMsat: number;
         preimageHex: string;
         memo: string;
+        descriptionForHash?: string;
     }): Promise<{
         pr: string;
     }>;
     payInvoice(args: {
         pr: string;
         feeLimitMsat: number;
+        amountMsat?: number;
     }): Promise<PaymentOutcome>;
     isPaymentComplete(paymentHashHex: string): Promise<boolean>;
     isInvoiceSettled(paymentHashHex: string): Promise<boolean>;

package/dist/cli.js

@@ -10,21 +10,35 @@ import { createMoneyer } from "./server.js";
 //   moneyer --dev      in-memory fake funding source, an ephemeral signing
 //                      key, and one funded 21-sat note printed for a wallet
 //                      to play with. Nothing here is payable.
-const { values } = parseArgs({
+//   moneyer admin ...  operate a running mint - see admin.ts
+const { values, positionals } = parseArgs({
     options: {
         dev: { type: 'boolean', default: false },
         help: { type: 'boolean', default: false }
-    }
+    },
+    allowPositionals: true,
+    // The admin subcommand carries flags of its own (--state, --limit,
+    // --pending), parsed there rather than declared here.
+    strict: false
 });
+if (positionals[0] === 'admin') {
+    const args = process.argv.slice(2);
+    const { runAdmin } = await import("./admin.js");
+    process.exit(await runAdmin(args.slice(args.indexOf('admin') + 1)));
+}
 if (values.help) {
     console.log([
         'moneyer - an LNURLcash (LUD-25) mint',
         '',
         'Usage: moneyer [--dev]',
+        '       moneyer admin <command>',
         '',
         '  --dev   fake funding source, in-memory store, ephemeral signing key,',
         '          and a funded 21 sat note printed at startup. Unpayable, for',
         '          wallets to develop against.',
+        '  admin   operate a running mint: status, notes, melts, reconcile,',
+        '          sweep, snapshot, names, keys, verify-note.',
+        '          `moneyer admin help` lists them.',
         '',
         'Configuration is MONEYER_* environment variables - see README.md.'
     ].join('\n'));
@@ -41,6 +55,14 @@ if (config.backend.kind === 'fake' && !values.dev) {
     console.error('The fake funding source mints unpayable invoices - refusing to run it outside --dev.');
     process.exit(1);
 }
+// --dev means a mint a wallet can actually use. Without settling invoices
+// the fake source hands out quotes nobody can pay, so a wallet pointed at
+// it mints nothing and has no note to split, merge, melt or send - the
+// mint looks alive and every flow that needs money dead-ends. Only ever
+// reachable here, on the one backend that moves nothing.
+if (config.backend.kind === 'fake' && values.dev) {
+    config.backend = { ...config.backend, autoSettle: true };
+}
 const log = (message) => console.error(`[moneyer] ${message}`);
 const moneyer = await createMoneyer(config, { log });
 console.log(`moneyer listening on ${moneyer.url}`);
@@ -52,7 +74,7 @@ if (values.dev) {
     const k1 = bytesToHex(randomBytes(32));
     moneyer.store.creditNote(hashK1(k1), 21_000);
     console.log(`  a 21 sat note:     ${buildNoteUrl(`${moneyer.url}/w`, k1, 21_000)}`);
-    console.log('\nnothing here is payable - the fake funding source invents its invoices');
+    console.log('\nDEV MINT - the fake funding source invents its invoices and treats every one\nof them as paid the moment it is issued, so minting here costs nothing and\nthe notes it hands out are worth nothing. Melts always succeed and send no\nsats anywhere. Never point a wallet holding real money at this.');
 }
 const shutdown = () => {
     moneyer.close().then(() => process.exit(0), () => process.exit(1));

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 import type { MintFee } from 'lnurlcash-kit';
 export type BackendConfig = {
     kind: 'fake';
+    autoSettle?: boolean;
 } | {
     kind: 'cln';
     url: string;
@@ -10,24 +11,46 @@ export type BackendConfig = {
     url: string;
     macaroon: string;
 };
+export type MintContact = {
+    nostr?: string;
+    email?: string;
+    url?: string;
+};
 export type MoneyerConfig = {
     host: string;
     port: number;
     publicOrigin?: string;
     username: string;
     description: string;
+    name?: string;
+    contact?: MintContact;
+    tosUrl?: string;
+    motd?: string;
     minSendableMsat: number;
     maxSendableMsat: number;
     minMintMsat: number;
     mintFee: MintFee | null;
     roundFeeToSat?: boolean;
     signingKey?: string;
+    previousSigningPubkeys?: string[];
     dbPath: string;
     backend: BackendConfig;
     verify: boolean;
     walletUrl?: string;
     maxK1s: number;
+    stats?: boolean;
+    statsRatioOnly?: boolean;
+    statsPublish?: boolean;
+    announce?: boolean;
+    metrics?: boolean;
     sunset: boolean;
+    zap?: ZapConfig;
+    namePriceMsat?: number;
+};
+export type ZapConfig = {
+    nostrKey: string;
+    relays: string[];
+    names: Record<string, string>;
 };
 export declare const DEFAULTS: {
     readonly host: "127.0.0.1";
@@ -42,5 +65,11 @@ export declare const DEFAULTS: {
     readonly maxK1s: 21;
     readonly sunset: false;
     readonly roundFeeToSat: false;
+    readonly stats: true;
+    readonly statsRatioOnly: false;
+    readonly statsPublish: false;
+    readonly announce: false;
+    readonly metrics: false;
 };
 export declare const configFromEnv: (env?: NodeJS.ProcessEnv) => MoneyerConfig;
+export declare const pubkeyHex: (value: string) => string;

package/dist/config.js

@@ -1,3 +1,7 @@
+import { getPublicKey } from 'nostr-tools/pure';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
+import { decode as decodeNip19, npubEncode } from 'nostr-tools/nip19';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
 export const DEFAULTS = {
     host: '127.0.0.1',
     port: 3737,
@@ -10,7 +14,12 @@ export const DEFAULTS = {
     verify: true,
     maxK1s: 21,
     sunset: false,
-    roundFeeToSat: false
+    roundFeeToSat: false,
+    stats: true,
+    statsRatioOnly: false,
+    statsPublish: false,
+    announce: false,
+    metrics: false
 };
 const int = (value, fallback) => {
     if (value === undefined || value === '')
@@ -27,6 +36,50 @@ const flag = (value, fallback) => {
     return value !== '0' && value.toLowerCase() !== 'false';
 };
 const HEX32 = /^[0-9a-f]{64}$/i;
+// Trimmed, or absent. An empty variable is the operator not setting it,
+// which is not the same as setting it to nothing.
+const text = (value) => {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+};
+const webUrl = (name, value) => {
+    const trimmed = text(value);
+    if (trimmed === undefined)
+        return undefined;
+    let protocol;
+    try {
+        protocol = new URL(trimmed).protocol;
+    }
+    catch {
+        throw new Error(`${name} is not a URL: ${JSON.stringify(value)}.`);
+    }
+    if (protocol !== 'https:' && protocol !== 'http:') {
+        throw new Error(`${name} must be http or https, got ${JSON.stringify(value)}.`);
+    }
+    return trimmed;
+};
+// The MOTD is a line on a mint card, not a blog. A runaway one would push
+// every other field off a wallet's screen, so it is refused at startup
+// rather than truncated behind the operator's back.
+const MOTD_MAX = 280;
+const contactFromEnv = (env) => {
+    const rawNostr = text(env.MONEYER_CONTACT_NOSTR);
+    // Normalised to npub on the wire whichever form the operator set: a
+    // wallet showing a contact wants the form a person can paste back.
+    const nostr = rawNostr === undefined ? undefined : npubEncode(pubkeyHex(rawNostr));
+    const email = text(env.MONEYER_CONTACT_EMAIL);
+    if (email !== undefined && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+        throw new Error(`MONEYER_CONTACT_EMAIL is not an email address: ${JSON.stringify(email)}.`);
+    }
+    const url = webUrl('MONEYER_CONTACT_URL', env.MONEYER_CONTACT_URL);
+    if (nostr === undefined && email === undefined && url === undefined)
+        return undefined;
+    return {
+        ...(nostr ? { nostr } : {}),
+        ...(email ? { email } : {}),
+        ...(url ? { url } : {})
+    };
+};
 // Reads MONEYER_* from the environment. Throws rather than guessing: a mint
 // that starts with a half-understood configuration is holding other
 // people's money on a misunderstanding.
@@ -40,10 +93,16 @@ export const configFromEnv = (env = process.env) => {
     if (signingKey !== undefined && !HEX32.test(signingKey)) {
         throw new Error('MONEYER_SIGNING_KEY must be 32 bytes of hex.');
     }
+    const previousSigningPubkeys = previousPubkeysFromEnv(env, signingKey);
     const kind = env.MONEYER_BACKEND ?? 'fake';
     let backend;
     if (kind === 'fake') {
-        backend = { kind: 'fake' };
+        // A development-only shortcut, and only reachable on the backend that
+        // moves no money: every invoice this mint issues is treated as paid
+        // the instant it is issued. It is what makes a local mint usable to a
+        // wallet, and it would be a licence to print sats on any other
+        // backend, which is why it is read here and nowhere else.
+        backend = { kind: 'fake', autoSettle: env.MONEYER_FAKE_AUTOSETTLE === 'true' };
     }
     else if (kind === 'cln') {
         if (!env.MONEYER_BACKEND_URL || !env.MONEYER_BACKEND_RUNE) {
@@ -80,23 +139,155 @@ export const configFromEnv = (env = process.env) => {
             throw new Error(`MONEYER_PUBLIC_ORIGIN must be http or https, got ${JSON.stringify(publicOrigin)}.`);
         }
     }
+    const motd = text(env.MONEYER_MOTD);
+    if (motd !== undefined && motd.length > MOTD_MAX) {
+        throw new Error(`MONEYER_MOTD must be at most ${MOTD_MAX} characters - it is a banner, not a page.`);
+    }
+    const contact = contactFromEnv(env);
+    const tosUrl = webUrl('MONEYER_TOS_URL', env.MONEYER_TOS_URL);
+    const name = text(env.MONEYER_NAME);
+    const zap = zapFromEnv(env);
+    // Unset is not the same as zero here: unset means registration is
+    // closed, zero means free.
+    const rawPrice = env.MONEYER_NAME_PRICE_MSAT?.trim();
+    const namePriceMsat = rawPrice === undefined || rawPrice === '' ? undefined : int(rawPrice, 0);
+    if (namePriceMsat !== undefined && !zap) {
+        // A registered name that cannot be wrapped to its owner is a name
+        // that takes payments nobody can collect.
+        throw new Error('MONEYER_NAME_PRICE_MSAT needs zap-to-note configured - a name pays out as a gift-wrapped note.');
+    }
+    if (zap && zap.names[env.MONEYER_USERNAME ?? DEFAULTS.username]) {
+        throw new Error('MONEYER_ZAP_NAMES must not reuse the mint username.');
+    }
+    if (flag(env.MONEYER_ANNOUNCE, DEFAULTS.announce) && !zap) {
+        // An announcement is a Nostr event, and the mint's Nostr identity is
+        // the zap one. Turning this on without it would be a mint that thinks
+        // it is listed and is not.
+        throw new Error('MONEYER_ANNOUNCE needs the mint Nostr identity - set MONEYER_NOSTR_KEY and MONEYER_NOSTR_RELAYS.');
+    }
+    if (zap && !publicOrigin) {
+        // A settled zap is minted by a timer, with no request to read a Host
+        // header from, and the note URL it wraps must be right first time.
+        throw new Error('Zap-to-note needs MONEYER_PUBLIC_ORIGIN.');
+    }
     return {
         host: env.MONEYER_HOST ?? DEFAULTS.host,
         port: int(env.MONEYER_PORT, DEFAULTS.port),
         ...(publicOrigin ? { publicOrigin } : {}),
         username: env.MONEYER_USERNAME ?? DEFAULTS.username,
         description: env.MONEYER_DESCRIPTION ?? DEFAULTS.description,
+        ...(name ? { name } : {}),
+        ...(contact ? { contact } : {}),
+        ...(tosUrl ? { tosUrl } : {}),
+        ...(motd ? { motd } : {}),
         minSendableMsat,
         maxSendableMsat,
         minMintMsat: int(env.MONEYER_MIN_MINT_MSAT, DEFAULTS.minMintMsat),
         mintFee: baseFeeMsat === 0 && feePpm === 0 ? null : { baseFeeMsat, feePpm },
         roundFeeToSat: flag(env.MONEYER_ROUND_FEE_TO_SAT, DEFAULTS.roundFeeToSat),
         ...(signingKey ? { signingKey: signingKey.toLowerCase() } : {}),
+        ...(previousSigningPubkeys.length ? { previousSigningPubkeys } : {}),
         dbPath: env.MONEYER_DB ?? DEFAULTS.dbPath,
         backend,
         verify: flag(env.MONEYER_VERIFY, DEFAULTS.verify),
+        stats: flag(env.MONEYER_STATS, DEFAULTS.stats),
+        statsRatioOnly: flag(env.MONEYER_STATS_RATIO_ONLY, DEFAULTS.statsRatioOnly),
+        statsPublish: flag(env.MONEYER_STATS_PUBLISH, DEFAULTS.statsPublish),
+        announce: flag(env.MONEYER_ANNOUNCE, DEFAULTS.announce),
+        metrics: flag(env.MONEYER_METRICS, DEFAULTS.metrics),
         ...(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)
+        sunset: flag(env.MONEYER_SUNSET, DEFAULTS.sunset),
+        ...(zap ? { zap } : {}),
+        ...(namePriceMsat !== undefined ? { namePriceMsat } : {})
     };
 };
+// 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
+// a key that verifies nothing, and it must not be the current key, which
+// would say the mint had rotated to itself.
+const previousPubkeysFromEnv = (env, signingKey) => {
+    const raw = env.MONEYER_PREVIOUS_SIGNING_PUBKEYS?.trim();
+    if (!raw)
+        return [];
+    const current = signingKey ? bytesToHex(secp256k1.getPublicKey(hexToBytes(signingKey.toLowerCase()), true)) : null;
+    const pubkeys = [];
+    for (const entry of raw.split(',')) {
+        const pubkey = entry.trim().toLowerCase();
+        if (!pubkey)
+            continue;
+        if (!/^0[23][0-9a-f]{64}$/.test(pubkey)) {
+            throw new Error(`MONEYER_PREVIOUS_SIGNING_PUBKEYS entry is not a compressed secp256k1 pubkey: ${JSON.stringify(entry)}.`);
+        }
+        try {
+            secp256k1.Point.fromHex(pubkey);
+        }
+        catch {
+            throw new Error(`MONEYER_PREVIOUS_SIGNING_PUBKEYS entry is not a point on the curve: ${JSON.stringify(entry)}.`);
+        }
+        if (pubkey === current) {
+            throw new Error('MONEYER_PREVIOUS_SIGNING_PUBKEYS must not repeat the current signing key - a mint has not rotated to itself.');
+        }
+        if (!pubkeys.includes(pubkey))
+            pubkeys.push(pubkey);
+    }
+    return pubkeys;
+};
+const NAME = /^[a-z0-9._-]{1,64}$/;
+// An npub or 32-byte hex, to hex. Throws on anything else.
+export const pubkeyHex = (value) => {
+    const trimmed = value.trim();
+    if (HEX32.test(trimmed))
+        return trimmed.toLowerCase();
+    if (/^npub1/i.test(trimmed)) {
+        try {
+            const decoded = decodeNip19(trimmed.toLowerCase());
+            if (decoded.type === 'npub')
+                return decoded.data;
+        }
+        catch {
+            // fall through to the one error below
+        }
+    }
+    throw new Error(`Not a Nostr pubkey: ${JSON.stringify(value)}.`);
+};
+// MONEYER_ZAP_NAMES="alice=npub1...,bob=<hex>" with MONEYER_NOSTR_KEY and
+// MONEYER_NOSTR_RELAYS. The key and the relays go together: a name
+// without a key cannot wrap. The names themselves are now optional, since
+// a mint can open registration and start with none of its own.
+const zapFromEnv = (env) => {
+    const rawNames = env.MONEYER_ZAP_NAMES?.trim();
+    const nostrKey = env.MONEYER_NOSTR_KEY?.trim();
+    const rawRelays = env.MONEYER_NOSTR_RELAYS?.trim();
+    if (!rawNames && !nostrKey && !rawRelays)
+        return undefined;
+    if (!nostrKey || !rawRelays) {
+        throw new Error('Zap-to-note needs MONEYER_NOSTR_KEY and MONEYER_NOSTR_RELAYS.');
+    }
+    if (!HEX32.test(nostrKey))
+        throw new Error('MONEYER_NOSTR_KEY must be 32 bytes of hex.');
+    // Refuse a key the curve refuses, at startup rather than on the first zap.
+    getPublicKey(hexToBytes(nostrKey));
+    const relays = rawRelays
+        .split(',')
+        .map(r => r.trim())
+        .filter(Boolean);
+    if (!relays.length || relays.some(r => !/^wss?:\/\//.test(r))) {
+        throw new Error('MONEYER_NOSTR_RELAYS must be a comma-separated list of ws:// or wss:// URLs.');
+    }
+    const names = {};
+    for (const entry of (rawNames ?? '').split(',').filter(Boolean)) {
+        const [name, pubkey, ...rest] = entry.split('=').map(s => s.trim());
+        if (!name || !pubkey || rest.length) {
+            throw new Error(`MONEYER_ZAP_NAMES entry is not name=pubkey: ${JSON.stringify(entry)}.`);
+        }
+        const lowered = name.toLowerCase();
+        if (!NAME.test(lowered))
+            throw new Error(`MONEYER_ZAP_NAMES name is not a lightning-address local part: ${JSON.stringify(name)}.`);
+        if (lowered === '_')
+            throw new Error('MONEYER_ZAP_NAMES must not claim the bare-domain name "_".');
+        names[lowered] = pubkeyHex(pubkey);
+    }
+    return { nostrKey: nostrKey.toLowerCase(), relays, names };
+};

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 export { configFromEnv, DEFAULTS, type MoneyerConfig, type BackendConfig } from './config.ts';
 export { createMoneyer, type Moneyer, type MoneyerDeps } from './server.ts';
-export { NoteStore, NotePendingError, NoteUnavailableError, OutputCollisionError, type NoteRow, type NoteState, type MeltRow, type MintInvoiceRow } from './store.ts';
-export { createNoteSigner, noteIdSignatureDigest, type NoteSigner } from './signing.ts';
+export { NoteStore, NotePendingError, NoteUnavailableError, OutputCollisionError, type NoteRow, type NoteState, type MeltRow, type MintInvoiceRow, type Liabilities } from './store.ts';
+export { createNoteSigner, noteIdSignatureDigest, recoversToPubkey, signDigestRecoverable, type NoteSigner } from './signing.ts';
+export { STATS_D_TAG, STATS_KIND, buildStats, canonicalJson, signStats, statsDigest, statsSnapshotContent, verifyStatsSignature, verifyStatsSnapshot, type MintStats } from './stats.ts';
+export { ANNOUNCE_D_TAG, ANNOUNCE_KIND, ANNOUNCE_MESSAGE_PREFIX, announcementContent, announcementDigest, canonicalise, signAnnouncement, verifyAnnouncement, type MintAddressDocument } from './announce.ts';
 export { PaymentAlreadyKnownError, PaymentFailedError, PaymentPendingError, type LightningBackend, type NodeInfo, type PaymentOutcome } from './backends/types.ts';
 export { createFakeBackend, type FakeBackend, type FakePayMode } from './backends/fake.ts';
 export { createClnBackend } from './backends/cln.ts';
 export { createLndBackend } from './backends/lnd.ts';
 export { fakeBolt11 } from './backends/fake-bolt11.ts';
 export { runMelt, reconcilePendingMelts, type MeltJob, type MeltDeps } from './melt.ts';
+export { runAdmin, adminHelp, type AdminDeps } from './admin.ts';

package/dist/index.js

@@ -14,10 +14,13 @@
 export { configFromEnv, DEFAULTS } from "./config.js";
 export { createMoneyer } from "./server.js";
 export { NoteStore, NotePendingError, NoteUnavailableError, OutputCollisionError } from "./store.js";
-export { createNoteSigner, noteIdSignatureDigest } from "./signing.js";
+export { createNoteSigner, noteIdSignatureDigest, recoversToPubkey, signDigestRecoverable } from "./signing.js";
+export { STATS_D_TAG, STATS_KIND, buildStats, canonicalJson, signStats, statsDigest, statsSnapshotContent, verifyStatsSignature, verifyStatsSnapshot } from "./stats.js";
+export { ANNOUNCE_D_TAG, ANNOUNCE_KIND, ANNOUNCE_MESSAGE_PREFIX, announcementContent, announcementDigest, canonicalise, signAnnouncement, verifyAnnouncement } from "./announce.js";
 export { PaymentAlreadyKnownError, PaymentFailedError, PaymentPendingError } from "./backends/types.js";
 export { createFakeBackend } from "./backends/fake.js";
 export { createClnBackend } from "./backends/cln.js";
 export { createLndBackend } from "./backends/lnd.js";
 export { fakeBolt11 } from "./backends/fake-bolt11.js";
 export { runMelt, reconcilePendingMelts } from "./melt.js";
+export { runAdmin, adminHelp } from "./admin.js";

package/dist/landing.d.ts

@@ -1,8 +1,10 @@
 import type { MoneyerConfig } from './config.ts';
 import type { NodeInfo } from './backends/types.ts';
+import type { MintStats } from './stats.ts';
 export declare const landingPage: (args: {
     config: MoneyerConfig;
     host: string;
     mintPubkey: string | null;
     nodeInfo: NodeInfo;
+    stats?: MintStats | null;
 }) => string;