@forgesworn/moneyer 0.1.2 → 0.2.0

package/dist/store.js

@@ -1,4 +1,20 @@
 import { DatabaseSync } from 'node:sqlite';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+// What identifies one mutation request, so a retry of it can be answered
+// with the same reply instead of "already spent". Everything the WALLET
+// chose goes in: the notes it named (by id, never by secret - the store
+// holds no secrets), the output ids it asked for, and the split amount.
+// Anything else naming a burned input is a different request and is still
+// refused, so no oracle appears. Input order is not part of it: a
+// reordered retry is the same operation.
+export const swapFingerprint = (args) => bytesToHex(sha256(utf8ToBytes([[...args.inputIds].sort().join(','), args.h, args.h2 ?? '', args.amountMsat === undefined ? '' : String(args.amountMsat)].join('|'))));
+// A lightning address this mint pays out as a note. `source` is how it
+// got here: 'env' for one the operator set, 'self' for one somebody
+// registered and paid for.
+// How long a connection waits for a lock before giving up. Long enough
+// for a swap to commit, short enough that a wedged process is obvious.
+const BUSY_TIMEOUT_MS = 5_000;
 // A note named by the request is reserved by an in-flight melt. The wire
 // reply for this is the exact reason string "pending".
 export class NotePendingError extends Error {
@@ -15,9 +31,27 @@ export class OutputCollisionError extends Error {
 }
 export class NoteStore {
     db;
-    constructor(path) {
+    readOnly;
+    // `readOnly` is for the operator CLI: a command that only reads should
+    // not be able to write, and should not create a database file at a
+    // mistyped path either. It skips the schema statements for the same
+    // reason - there is nothing to migrate when nothing can be written.
+    constructor(path, options = {}) {
+        this.readOnly = options.readOnly === true;
+        if (this.readOnly) {
+            this.db = new DatabaseSync(path, { readOnly: true });
+            // A reader still meets a locked shared-memory index for a moment
+            // during WAL recovery, so it waits too rather than throwing.
+            this.db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+            return;
+        }
         this.db = new DatabaseSync(path);
         this.db.exec('PRAGMA journal_mode = WAL');
+        // node:sqlite opens with no busy timeout at all, so a second writer
+        // gets `database is locked` the instant it meets the first one. The
+        // operator CLI is that second writer while the mint is running, and
+        // the moments you reach for it are the busy ones. Wait, do not throw.
+        this.db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
         this.db.exec('PRAGMA foreign_keys = ON');
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS notes (
@@ -33,6 +67,35 @@ export class NoteStore {
         gross_msat INTEGER NOT NULL,
         net_msat INTEGER NOT NULL,
         settled INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        output_id TEXT
+      );
+      CREATE TABLE IF NOT EXISTS zap_invoices (
+        payment_hash TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        recipient TEXT NOT NULL,
+        pr TEXT NOT NULL,
+        gross_msat INTEGER NOT NULL,
+        net_msat INTEGER NOT NULL,
+        zap_request TEXT,
+        settled INTEGER NOT NULL DEFAULT 0,
+        note_id TEXT,
+        wrap_json TEXT,
+        receipt_json TEXT,
+        created_at INTEGER NOT NULL,
+        settled_at INTEGER,
+        published_at INTEGER
+      );
+      CREATE TABLE IF NOT EXISTS zap_names (
+        name TEXT PRIMARY KEY,
+        pubkey TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        paid_msat INTEGER NOT NULL DEFAULT 0,
+        source TEXT NOT NULL CHECK (source IN ('env','self'))
+      );
+      CREATE TABLE IF NOT EXISTS swaps (
+        fingerprint TEXT PRIMARY KEY,
+        outputs TEXT NOT NULL,
         created_at INTEGER NOT NULL
       );
       CREATE TABLE IF NOT EXISTS melts (
@@ -45,6 +108,15 @@ export class NoteStore {
         resolved_at INTEGER
       );
     `);
+        // `CREATE TABLE IF NOT EXISTS` leaves a database an earlier version
+        // made exactly as it found it, so a column added later is added here.
+        const invoiceColumns = this.db.prepare('PRAGMA table_info(mint_invoices)').all().map(column => column.name);
+        if (!invoiceColumns.includes('output_id')) {
+            this.db.exec('ALTER TABLE mint_invoices ADD COLUMN output_id TEXT');
+        }
+        // Two invoices may not name the same note. SQLite counts NULLs as
+        // distinct, so every unbound invoice still fits.
+        this.db.exec('CREATE UNIQUE INDEX IF NOT EXISTS mint_invoices_output_id ON mint_invoices (output_id)');
     }
     tx(fn) {
         this.db.exec('BEGIN IMMEDIATE');
@@ -73,16 +145,27 @@ export class NoteStore {
     setNoteState(id, state) {
         this.db.prepare('UPDATE notes SET state = ?, updated_at = ? WHERE id = ?').run(state, Date.now(), id);
     }
-    // An output id may not collide with any existing note OR any mint
-    // invoice's payment hash, settled or not. The invoice case is the subtle
-    // one: /verify hands out a settled mint invoice's preimage, and that
-    // preimage is the k1 of whatever note carries the invoice's payment hash
-    // as its id - so letting a mutation claim such an id would point a future
-    // payer's money at a stranger's note.
-    assertOutputIdFree(id) {
+    // An output id may not collide with any existing note, any mint
+    // invoice's payment hash, settled or not, or any note an unsettled
+    // invoice has already been told to credit. The invoice cases are the
+    // subtle ones: /verify hands out a settled mint invoice's preimage, and
+    // that preimage is the k1 of whatever note carries the invoice's payment
+    // hash as its id - so letting a mutation claim such an id would point a
+    // future payer's money at a stranger's note. A bound invoice's `h` is
+    // the same hazard one step earlier: the note does not exist yet, but it
+    // is already spoken for.
+    //
+    // Public because the pay callback has to answer this before it asks the
+    // funding source for an invoice: a wallet must never pay for a quote the
+    // mint was always going to refuse.
+    outputIdInUse(id) {
         const asNote = this.db.prepare('SELECT 1 FROM notes WHERE id = ?').get(id);
         const asInvoice = this.db.prepare('SELECT 1 FROM mint_invoices WHERE payment_hash = ?').get(id);
-        if (asNote || asInvoice)
+        const asBoundOutput = this.db.prepare('SELECT 1 FROM mint_invoices WHERE output_id = ?').get(id);
+        return Boolean(asNote || asInvoice || asBoundOutput);
+    }
+    assertOutputIdFree(id) {
+        if (this.outputIdInUse(id))
             throw new OutputCollisionError(`output id ${id} is already in use`);
     }
     assertOutstanding(id) {
@@ -97,7 +180,16 @@ export class NoteStore {
     }
     // The atomic mutation behind rotate, split and merge: burn every input,
     // mint every output, or do nothing at all.
-    swap(inputIds, outputs) {
+    //
+    // `fingerprint`, when given, records which request minted these outputs
+    // from those inputs. A GET is retried by transports that have no idea a
+    // rotate spends anything - Go's net/http retries one on a reused idle
+    // connection, the JDK's HttpClient retries idempotent methods with no
+    // switch to stop it - and the retry arrives byte-identical after the
+    // inputs are already burned. Without provenance the mint can only say
+    // "already spent", and a wallet that believes it drops the only copy of
+    // a secret the mint really did mint a note against.
+    swap(inputIds, outputs, fingerprint) {
         this.tx(() => {
             for (const id of inputIds)
                 this.assertOutstanding(id);
@@ -107,8 +199,24 @@ export class NoteStore {
                 this.setNoteState(id, 'burned');
             for (const output of outputs)
                 this.insertNote(output.id, output.amountMsat);
+            if (fingerprint !== undefined) {
+                this.db
+                    .prepare('INSERT OR REPLACE INTO swaps (fingerprint, outputs, created_at) VALUES (?, ?, ?)')
+                    .run(fingerprint, JSON.stringify(outputs.map(output => [output.id, output.amountMsat])), Date.now());
+            }
         });
     }
+    // What a previous request with this exact fingerprint minted, if any.
+    // Provenance is recorded rather than inferred on purpose: matching on
+    // "a note exists at h" alone would let anyone holding a burned k1 and
+    // any outstanding note id draw a success out of the mint.
+    swapByFingerprint(fingerprint) {
+        const row = this.db.prepare('SELECT outputs FROM swaps WHERE fingerprint = ?').get(fingerprint);
+        if (!row)
+            return null;
+        const parsed = JSON.parse(row.outputs);
+        return parsed.map(([id, amountMsat]) => ({ id, amountMsat }));
+    }
     // Reserves a note for a melt and records the melt, atomically. The melts
     // row is keyed by the invoice's payment hash; a duplicate hash means an
     // earlier melt already used this invoice and the INSERT itself refuses.
@@ -171,17 +279,22 @@ export class NoteStore {
             outcome: row.outcome
         }));
     }
-    recordMintInvoice(paymentHash, pr, grossMsat, netMsat) {
+    // `outputId` is the note id the payer's wallet asked for with `h`. Both
+    // ids are checked in the same transaction that inserts the row, so two
+    // requests racing for one id cannot both be told yes.
+    recordMintInvoice(paymentHash, pr, grossMsat, netMsat, outputId = null) {
         this.tx(() => {
             this.assertOutputIdFree(paymentHash);
+            if (outputId !== null)
+                this.assertOutputIdFree(outputId);
             this.db
-                .prepare('INSERT INTO mint_invoices (payment_hash, pr, gross_msat, net_msat, settled, created_at) VALUES (?, ?, ?, ?, 0, ?)')
-                .run(paymentHash, pr, grossMsat, netMsat, Date.now());
+                .prepare('INSERT INTO mint_invoices (payment_hash, pr, gross_msat, net_msat, settled, created_at, output_id) VALUES (?, ?, ?, ?, 0, ?, ?)')
+                .run(paymentHash, pr, grossMsat, netMsat, Date.now(), outputId);
         });
     }
     mintInvoiceByHash(paymentHash) {
         const row = this.db
-            .prepare('SELECT payment_hash, pr, gross_msat, net_msat, settled FROM mint_invoices WHERE payment_hash = ?')
+            .prepare('SELECT payment_hash, pr, gross_msat, net_msat, settled, output_id FROM mint_invoices WHERE payment_hash = ?')
             .get(paymentHash);
         if (!row)
             return null;
@@ -190,22 +303,32 @@ export class NoteStore {
             pr: row.pr,
             grossMsat: row.gross_msat,
             netMsat: row.net_msat,
-            settled: row.settled === 1
+            settled: row.settled === 1,
+            outputId: row.output_id
         };
     }
+    // The invoice a payer bound to this note id, if any. The lookup a claim
+    // makes when the wallet named the note it was buying: the note does not
+    // exist until the invoice settles, and the wallet knows nothing but the
+    // secret it chose.
+    mintInvoiceByOutputId(outputId) {
+        const row = this.db.prepare('SELECT payment_hash FROM mint_invoices WHERE output_id = ?').get(outputId);
+        return row ? this.mintInvoiceByHash(row.payment_hash) : null;
+    }
     // Every unsettled mint invoice, for the expiry sweep. An unsettled row
     // past its bolt11 expiry can never settle - the funding source refuses
     // expired invoices - so it is dead weight, and every /p/cb call adds one.
     unsettledMintInvoices() {
         const rows = this.db
-            .prepare('SELECT payment_hash, pr, gross_msat, net_msat, settled FROM mint_invoices WHERE settled = 0')
+            .prepare('SELECT payment_hash, pr, gross_msat, net_msat, settled, output_id FROM mint_invoices WHERE settled = 0')
             .all();
         return rows.map(row => ({
             paymentHash: row.payment_hash,
             pr: row.pr,
             grossMsat: row.gross_msat,
             netMsat: row.net_msat,
-            settled: false
+            settled: false,
+            outputId: row.output_id
         }));
     }
     // Conditional on STILL unsettled: a settle landing between the sweep's
@@ -215,16 +338,148 @@ export class NoteStore {
     }
     // Paying a mint invoice is what brings its note into existence. Safe to
     // call twice: the second settle finds the note already minted.
+    //
+    // The note lands at the id the payer's wallet named, when it named one.
+    // Otherwise it lands at the invoice's payment hash, which is the older
+    // arrangement where the payment preimage is the spend secret.
     settleMintInvoice(paymentHash) {
         this.tx(() => {
             const invoice = this.mintInvoiceByHash(paymentHash);
             if (!invoice)
                 return;
             this.db.prepare('UPDATE mint_invoices SET settled = 1 WHERE payment_hash = ?').run(paymentHash);
-            if (!this.noteById(paymentHash))
-                this.insertNote(paymentHash, invoice.netMsat);
+            const noteId = invoice.outputId ?? paymentHash;
+            if (!this.noteById(noteId))
+                this.insertNote(noteId, invoice.netMsat);
+        });
+    }
+    // ---- zap-to-note ----
+    recordZapInvoice(row) {
+        this.db
+            .prepare('INSERT INTO zap_invoices (payment_hash, name, recipient, pr, gross_msat, net_msat, zap_request, settled, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)')
+            .run(row.paymentHash, row.name, row.recipient, row.pr, row.grossMsat, row.netMsat, row.zapRequest, Date.now());
+    }
+    zapRow(row) {
+        return {
+            paymentHash: row.payment_hash,
+            name: row.name,
+            recipient: row.recipient,
+            pr: row.pr,
+            grossMsat: row.gross_msat,
+            netMsat: row.net_msat,
+            zapRequest: row.zap_request ?? null,
+            settled: row.settled === 1,
+            noteId: row.note_id ?? null,
+            wrapJson: row.wrap_json ?? null,
+            receiptJson: row.receipt_json ?? null,
+            settledAt: row.settled_at ?? null
+        };
+    }
+    static ZAP_COLUMNS = 'payment_hash, name, recipient, pr, gross_msat, net_msat, zap_request, settled, note_id, wrap_json, receipt_json, settled_at';
+    zapInvoiceByHash(paymentHash) {
+        const row = this.db
+            .prepare(`SELECT ${NoteStore.ZAP_COLUMNS} FROM zap_invoices WHERE payment_hash = ?`)
+            .get(paymentHash);
+        return row ? this.zapRow(row) : null;
+    }
+    unsettledZapInvoices() {
+        const rows = this.db
+            .prepare(`SELECT ${NoteStore.ZAP_COLUMNS} FROM zap_invoices WHERE settled = 0`)
+            .all();
+        return rows.map(row => this.zapRow(row));
+    }
+    deleteUnsettledZapInvoice(paymentHash) {
+        this.db.prepare('DELETE FROM zap_invoices WHERE payment_hash = ? AND settled = 0').run(paymentHash);
+    }
+    // The note comes into being and the events that announce it are parked
+    // for publishing, in one transaction: a crash between the two would
+    // otherwise leave a liability nobody was ever told about. Returns false
+    // if the row was already settled (a racing poll), in which case nothing
+    // was minted.
+    settleZapInvoice(paymentHash, noteId, wrapJson, receiptJson) {
+        return this.tx(() => {
+            const row = this.zapInvoiceByHash(paymentHash);
+            if (!row || row.settled)
+                return false;
+            this.assertOutputIdFree(noteId);
+            this.insertNote(noteId, row.netMsat);
+            this.db
+                .prepare('UPDATE zap_invoices SET settled = 1, note_id = ?, wrap_json = ?, receipt_json = ?, settled_at = ? WHERE payment_hash = ?')
+                .run(noteId, wrapJson, receiptJson, Date.now(), paymentHash);
+            return true;
+        });
+    }
+    // Settled zaps whose wrap has not yet reached a relay.
+    unpublishedZaps() {
+        const rows = this.db
+            .prepare(`SELECT ${NoteStore.ZAP_COLUMNS} FROM zap_invoices WHERE settled = 1 AND published_at IS NULL`)
+            .all();
+        return rows.map(row => this.zapRow(row));
+    }
+    // The wrap is on a relay: drop our copy. The receipt is dropped with it
+    // whether or not every relay took it - it is public and best-effort.
+    markZapPublished(paymentHash) {
+        this.db
+            .prepare('UPDATE zap_invoices SET wrap_json = NULL, receipt_json = NULL, published_at = ? WHERE payment_hash = ?')
+            .run(Date.now(), paymentHash);
+    }
+    // ---- lightning addresses ----
+    //
+    // One table for both kinds: names the operator set in the environment
+    // and names people registered themselves. The lookup path that serves a
+    // zap does not care which is which, so there is one of it.
+    zapName(name) {
+        const row = this.db
+            .prepare('SELECT name, pubkey, created_at, paid_msat, source FROM zap_names WHERE name = ?')
+            .get(name.toLowerCase());
+        if (!row)
+            return null;
+        return { name: row.name, pubkey: row.pubkey, createdAt: row.created_at, paidMsat: row.paid_msat, source: row.source };
+    }
+    zapNames() {
+        const rows = this.db
+            .prepare('SELECT name, pubkey, created_at, paid_msat, source FROM zap_names ORDER BY name')
+            .all();
+        return rows.map(row => ({
+            name: row.name,
+            pubkey: row.pubkey,
+            createdAt: row.created_at,
+            paidMsat: row.paid_msat,
+            source: row.source
+        }));
+    }
+    // The operator's own names, re-applied at every startup. Idempotent, and
+    // the environment wins: it is the operator's mint, and a name they put
+    // in the environment is one they mean to have.
+    putOperatorZapName(name, pubkey) {
+        this.db
+            .prepare(`INSERT INTO zap_names (name, pubkey, created_at, paid_msat, source) VALUES (?, ?, ?, 0, 'env')
+         ON CONFLICT(name) DO UPDATE SET pubkey = excluded.pubkey, source = 'env'`)
+            .run(name.toLowerCase(), pubkey, Date.now());
+    }
+    // A self-service registration: burn the note that paid for the name and
+    // record the name, or do neither. One transaction, because the two
+    // failure modes either side of it are both bad - a name nobody paid
+    // for, or a note burned for a name somebody else got first. The INSERT
+    // is also the race check: two requests for one name cannot both win.
+    buyZapName(args) {
+        this.tx(() => {
+            if (args.noteId !== undefined) {
+                this.assertOutstanding(args.noteId);
+                this.setNoteState(args.noteId, 'burned');
+            }
+            this.db
+                .prepare("INSERT INTO zap_names (name, pubkey, created_at, paid_msat, source) VALUES (?, ?, ?, ?, 'self')")
+                .run(args.name.toLowerCase(), args.pubkey, Date.now(), args.paidMsat);
         });
     }
+    removeZapName(name) {
+        return this.db.prepare('DELETE FROM zap_names WHERE name = ?').run(name.toLowerCase()).changes > 0;
+    }
+    zapNameCountFor(pubkey) {
+        const row = this.db.prepare('SELECT COUNT(*) AS n FROM zap_names WHERE pubkey = ?').get(pubkey);
+        return row.n;
+    }
     // Operator/dev funding path: mint a note directly, bypassing Lightning.
     // The fake backend's world only - the CLI never exposes it on a real one.
     creditNote(id, amountMsat) {
@@ -233,12 +488,93 @@ export class NoteStore {
             this.insertNote(id, amountMsat);
         });
     }
+    // Everything the mint owes and everything it is in the middle of
+    // paying, in one read. Public numbers only: this is what /stats
+    // publishes, and no per-note detail belongs anywhere near it.
+    liabilities(nowMs = Date.now()) {
+        const notes = this.db
+            .prepare("SELECT COUNT(*) AS count, COALESCE(SUM(amount_msat), 0) AS total FROM notes WHERE state IN ('outstanding','pending')")
+            .get();
+        const melts = this.db
+            .prepare('SELECT COUNT(*) AS count, COALESCE(SUM(amount_msat), 0) AS total, MIN(created_at) AS oldest FROM melts WHERE outcome IS NULL')
+            .get();
+        return {
+            outstandingMsat: notes.total,
+            outstandingNotes: notes.count,
+            pendingMsat: melts.total,
+            pendingMelts: melts.count,
+            // Whole seconds, and never negative however the clock has moved.
+            oldestPendingMeltAgeSecs: melts.oldest === null ? 0 : Math.max(0, Math.floor((nowMs - melts.oldest) / 1000))
+        };
+    }
+    // Note rows for the operator CLI. Newest first, capped by the caller:
+    // this is the operator's own database, not anything a request reaches.
+    notes(filter = {}) {
+        const limit = Math.max(1, Math.min(filter.limit ?? 20, 1000));
+        const rows = (filter.state === undefined
+            ? this.db
+                .prepare('SELECT id, amount_msat, state, created_at, updated_at FROM notes ORDER BY created_at DESC LIMIT ?')
+                .all(limit)
+            : this.db
+                .prepare('SELECT id, amount_msat, state, created_at, updated_at FROM notes WHERE state = ? ORDER BY created_at DESC LIMIT ?')
+                .all(filter.state, limit));
+        return rows.map(row => ({
+            id: row.id,
+            amountMsat: row.amount_msat,
+            state: row.state,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        }));
+    }
+    melts(filter = {}) {
+        const limit = Math.max(1, Math.min(filter.limit ?? 20, 1000));
+        const where = filter.pendingOnly === true ? 'WHERE outcome IS NULL' : '';
+        const rows = this.db
+            .prepare(`SELECT payment_hash, note_id, pr, amount_msat, outcome, created_at, resolved_at FROM melts ${where} ORDER BY created_at DESC LIMIT ?`)
+            .all(limit);
+        return rows.map(row => ({
+            paymentHash: row.payment_hash,
+            noteId: row.note_id,
+            pr: row.pr,
+            amountMsat: row.amount_msat,
+            outcome: row.outcome,
+            createdAt: row.created_at,
+            resolvedAt: row.resolved_at
+        }));
+    }
+    // Lifetime totals, read from the tables rather than counted in memory,
+    // so a restart does not reset them.
+    totals() {
+        const mints = this.db.prepare('SELECT COUNT(*) AS n FROM mint_invoices WHERE settled = 1').get();
+        const unsettled = this.db.prepare('SELECT COUNT(*) AS n FROM mint_invoices WHERE settled = 0').get();
+        const zaps = this.db.prepare('SELECT COUNT(*) AS n FROM zap_invoices WHERE settled = 1').get();
+        const melts = this.db
+            .prepare("SELECT COALESCE(outcome, 'pending') AS outcome, COUNT(*) AS n FROM melts GROUP BY 1")
+            .all();
+        const byOutcome = { paid: 0, restored: 0, pending: 0 };
+        for (const row of melts)
+            byOutcome[row.outcome] = row.n;
+        return { mints: mints.n, unsettledMintInvoices: unsettled.n, zaps: zaps.n, melts: byOutcome };
+    }
+    // VACUUM INTO: a consistent copy of the whole database, taken while the
+    // mint is running, without needing a sqlite3 binary on the box. SQLite
+    // refuses an existing target itself; the caller checks first so the
+    // operator gets a sentence rather than a driver error.
+    snapshot(path) {
+        this.db.exec(`VACUUM INTO '${path.replace(/'/g, "''")}'`);
+    }
     outstandingLiabilityMsat() {
         const row = this.db
             .prepare("SELECT COALESCE(SUM(amount_msat), 0) AS total FROM notes WHERE state IN ('outstanding','pending')")
             .get();
         return row.total;
     }
+    // What this connection will wait for a lock, so the guarantee is
+    // testable rather than assumed.
+    busyTimeoutMs() {
+        const row = this.db.prepare('PRAGMA busy_timeout').get();
+        return row?.timeout ?? 0;
+    }
     close() {
         this.db.close();
     }

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const packageVersion: string | undefined;

package/dist/version.js

@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+// The running version, for the discovery endpoint and the operator CLI.
+// Read from package.json rather than baked in by a build step: a mint that
+// says it is on a version it is not is worse than one that says nothing.
+// dist/ sits one level under the package root, and so does src/ when
+// running the sources directly, so the relative path is the same either
+// way. Unreadable means the field is simply absent.
+export const packageVersion = (() => {
+    try {
+        const raw = readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+        const version = JSON.parse(raw).version;
+        return typeof version === 'string' ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+})();

package/dist/zap.d.ts

@@ -0,0 +1,52 @@
+import { type Event } from 'nostr-tools/pure';
+import type { Filter } from 'nostr-tools/filter';
+import type { ZapConfig } from './config.ts';
+import type { NoteStore } from './store.ts';
+import type { LightningBackend } from './backends/types.ts';
+export declare const NOTE_KIND = 2525;
+export declare const INBOX_RELAYS_KIND = 10050;
+export declare const ZAP_REQUEST_KIND = 9734;
+export declare const INDEXER_RELAYS: string[];
+export type NostrTransport = {
+    publish(relays: string[], event: Event): Promise<{
+        ok: string[];
+        failed: string[];
+    }>;
+    query(relays: string[], filter: Filter): Promise<Event[]>;
+    close(): void;
+};
+export declare const INBOX_RETRY_MS: number;
+export declare const poolTransport: () => NostrTransport;
+export declare const inboxRelays: (transport: NostrTransport, pubkey: string, lookOn: string[]) => Promise<string[]>;
+export type ZapBridgeDeps = {
+    config: ZapConfig;
+    store: NoteStore;
+    backend: LightningBackend;
+    transport: NostrTransport;
+    netAfterMintFee: (grossMsat: number) => number;
+    minSendableMsat: number;
+    maxSendableMsat: number;
+    minMintMsat: number;
+    mintFeeLine: string | null;
+    feeInWords: string | null;
+    verify: boolean;
+    origin: string;
+    log?: (message: string) => void;
+    now?: () => number;
+};
+export type ZapCallbackResult = {
+    pr: string;
+    verify?: string;
+} | {
+    reason: string;
+};
+export type ZapBridge = {
+    pubkey: string;
+    isZapName(name: string): boolean;
+    payRequest(name: string): Record<string, unknown> | null;
+    callback(name: string, amountMsat: number, nostrParam: string | null): Promise<ZapCallbackResult>;
+    settle(): Promise<number>;
+    publish(): Promise<number>;
+    sweep(nowMs?: number): number;
+};
+export declare const createZapBridge: (deps: ZapBridgeDeps) => ZapBridge;