@qntx/spark 0.0.0-stage → 0.1.1

package/dist/lnurl-kcdXU75g.mjs

@@ -0,0 +1,729 @@
+import { i as SparkRequestError, r as SparkInputError } from "./errors-5xLkExNL.mjs";
+import { n as decodeBolt11, t as serverErrorText } from "./text-DC_Vptn6.mjs";
+import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
+import { base64, bech32 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { equalBytes } from "@noble/curves/utils.js";
+import { cbc } from "@noble/ciphers/aes.js";
+//#region src/lnurl/http.ts
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Whole-round-trip bound for every LNURL request — request and body read. */
+const LNURL_REQUEST_TIMEOUT_MS = 3e4;
+function timedOut() {
+	return new SparkRequestError("lnurl request timed out", { code: "deadline_exceeded" });
+}
+function tooLarge() {
+	return new SparkRequestError("lnurl response: body exceeds 256 KiB", { code: "unexpected_response" });
+}
+/**
+* Rejects before reading when a truthful `Content-Length` already exceeds the bound. A missing (or
+* lying) header cannot be trusted, so the caller still reads the body once and re-checks it against
+* the same bound afterwards.
+*/
+function checkContentLength(response) {
+	const declared = Number(response.headers.get("content-length") ?? "");
+	if (Number.isSafeInteger(declared) && declared > 262144) throw tooLarge();
+}
+function checkBodySize(text) {
+	if (utf8ToBytes(text).length > 262144) throw tooLarge();
+}
+/**
+* One GET against an LNURL endpoint with the injected fetch. HTTP failures and the protocol-level
+* `{"status": "ERROR", "reason"}` envelope map onto the SSP client's error vocabulary; error
+* messages never echo request URLs — withdraw callbacks carry the ephemeral `k1`, which authorizes
+* a payout.
+*/
+async function lnurlGetJson(url, fetch) {
+	const timeout = new AbortController();
+	const timer = setTimeout(() => timeout.abort(), LNURL_REQUEST_TIMEOUT_MS);
+	try {
+		let response;
+		try {
+			response = await fetch(url, { signal: timeout.signal });
+		} catch (error) {
+			if (timeout.signal.aborted) throw timedOut();
+			throw new SparkRequestError("lnurl request failed", { cause: error });
+		}
+		if (!response.ok) throw new SparkRequestError(`lnurl request failed with status ${response.status}`, { code: `http_${response.status}` });
+		checkContentLength(response);
+		let text;
+		try {
+			text = await response.text();
+		} catch (error) {
+			if (timeout.signal.aborted) throw timedOut();
+			throw new SparkRequestError("lnurl request failed", { cause: error });
+		}
+		checkBodySize(text);
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch (error) {
+			throw new SparkRequestError("lnurl response: body is not valid JSON", {
+				code: "unexpected_response",
+				cause: error
+			});
+		}
+		if (!isJsonObject(parsed)) throw new SparkRequestError("lnurl response: body is not an object", { code: "unexpected_response" });
+		if (parsed["status"] === "ERROR") {
+			const { reason } = parsed;
+			throw new SparkRequestError(`lnurl error: ${typeof reason === "string" ? serverErrorText(reason) : "no reason given"}`, { code: "lnurl_error" });
+		}
+		return parsed;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* One JSON request with a body (POST/DELETE) against an LNURL endpoint. Same error vocabulary as
+* {@link lnurlGetJson}; a 2xx response with an empty body returns `undefined`, and request bodies
+* never echo into error messages — the server's response text is sanitized before it is embedded.
+*/
+async function lnurlSendJson(url, fetch, options) {
+	const timeout = new AbortController();
+	const timer = setTimeout(() => timeout.abort(), options.timeoutMs ?? 3e4);
+	try {
+		let response;
+		try {
+			response = await fetch(url, {
+				method: options.method,
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(options.body),
+				signal: timeout.signal
+			});
+		} catch (error) {
+			if (timeout.signal.aborted) throw timedOut();
+			throw new SparkRequestError("lnurl request failed", { cause: error });
+		}
+		checkContentLength(response);
+		const text = await response.text().catch(() => "");
+		if (timeout.signal.aborted) throw timedOut();
+		checkBodySize(text);
+		if (!response.ok) {
+			const detail = serverErrorText(text);
+			throw new SparkRequestError(`lnurl request failed with status ${response.status}${detail === "" ? "" : `: ${detail}`}`, { code: `http_${response.status}` });
+		}
+		if (text === "") return;
+		let parsed;
+		try {
+			parsed = JSON.parse(text);
+		} catch (error) {
+			throw new SparkRequestError("lnurl response: body is not valid JSON", {
+				code: "unexpected_response",
+				cause: error
+			});
+		}
+		if (!isJsonObject(parsed)) throw new SparkRequestError("lnurl response: body is not an object", { code: "unexpected_response" });
+		if (parsed["status"] === "ERROR") {
+			const { reason } = parsed;
+			throw new SparkRequestError(`lnurl error: ${typeof reason === "string" ? serverErrorText(reason) : "no reason given"}`, { code: "lnurl_error" });
+		}
+		return parsed;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/lnurl/url.ts
+function fail$4(message) {
+	throw new SparkInputError(`lnurl: ${message}`);
+}
+const URL_PATTERN = /^([a-zA-Z]+):\/\/([^/?#]*)(\/[^?#]*)?(?:\?([^#]*))?(?:#.*)?$/;
+const HOST_LABEL = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+const STRICT_IPV4_LABEL = /^(0|[1-9][0-9]{0,2})$/;
+const FORBIDDEN = /[\u0000-\u0020\u007F]/;
+function checkHost(authority) {
+	if (authority.includes("@")) fail$4("url must not contain userinfo");
+	let host = authority;
+	let port;
+	const colon = authority.lastIndexOf(":");
+	if (colon !== -1) {
+		host = authority.slice(0, colon);
+		const portText = authority.slice(colon + 1);
+		if (!/^[0-9]+$/.test(portText)) fail$4("url has an invalid port");
+		port = Number(portText);
+		if (port < 1 || port > 65535) fail$4("url port is out of range");
+	}
+	const lower = host.toLowerCase();
+	if (lower.length === 0) fail$4("url has no host");
+	if (lower.length > 253) fail$4("url host is too long");
+	const labels = lower.split(".");
+	for (const label of labels) if (!HOST_LABEL.test(label)) fail$4("url host has an invalid label");
+	checkIpv4(labels);
+	return port === void 0 ? { host: lower } : {
+		host: lower,
+		port
+	};
+}
+function isWhatwgIpv4Number(label) {
+	if (/^0[xX]/.test(label)) return /^0[xX][0-9a-f]*$/.test(label);
+	if (label.startsWith("0") && label.length > 1) return /^0[0-7]+$/.test(label);
+	return /^[0-9]+$/.test(label);
+}
+function checkIpv4(labels) {
+	if (!isWhatwgIpv4Number(labels.at(-1) ?? "") || !labels.every(isWhatwgIpv4Number)) return;
+	if (labels.length !== 4) fail$4("url host has a non-canonical IPv4 form");
+	for (const label of labels) if (!STRICT_IPV4_LABEL.test(label) || Number(label) > 255) fail$4("url host has a non-canonical IPv4 form");
+}
+/**
+* Parses `text` into strict parts. Accepts `https`/`http` schemes only, a DNS hostname or IPv4
+* literal, an optional port, and a path/query; a `#fragment` is accepted and dropped. Everything
+* else throws {@link SparkInputError}.
+*/
+function parseLnurlUrl(text) {
+	if (FORBIDDEN.test(text)) fail$4("url contains whitespace or control characters");
+	const match = URL_PATTERN.exec(text);
+	if (match === null) fail$4("not a URL");
+	const schemeText = (match[1] ?? "").toLowerCase();
+	if (schemeText !== "https" && schemeText !== "http") fail$4("url scheme must be https or http");
+	const { host, port } = checkHost(match[2] ?? "");
+	const path = match[3] ?? "/";
+	const query = match[4] ?? "";
+	return port === void 0 ? {
+		scheme: schemeText,
+		host,
+		path,
+		query
+	} : {
+		scheme: schemeText,
+		host,
+		port,
+		path,
+		query
+	};
+}
+/** `scheme://host[:port]path[?query]` — the canonical string form. */
+function formatLnurlUrl(parts) {
+	const port = parts.port === void 0 ? "" : `:${parts.port}`;
+	const query = parts.query === "" ? "" : `?${parts.query}`;
+	return `${parts.scheme}://${parts.host}${port}${parts.path}${query}`;
+}
+function decodeQueryComponent(text) {
+	const spaced = text.replaceAll("+", " ");
+	try {
+		return decodeURIComponent(spaced);
+	} catch (error) {
+		throw new SparkInputError("lnurl url: malformed query escape", { cause: error });
+	}
+}
+/**
+* Parses a `application/x-www-form-urlencoded` query string (without the leading `?`) into a
+* name→value map. Bare `name` pairs (no `=`) decode to ""; the last duplicate wins.
+*/
+function queryParams(query) {
+	const params = /* @__PURE__ */ new Map();
+	if (query === "") return params;
+	for (const pair of query.split("&")) {
+		const eq = pair.indexOf("=");
+		const name = eq === -1 ? pair : pair.slice(0, eq);
+		const value = eq === -1 ? "" : pair.slice(eq + 1);
+		params.set(decodeQueryComponent(name), decodeQueryComponent(value));
+	}
+	return params;
+}
+/**
+* Appends `encodeURIComponent`-encoded `name=value` pairs to a URL's query, preserving existing
+* pairs and dropping any fragment.
+*/
+function withQuery(url, params) {
+	const parts = parseLnurlUrl(url);
+	const encoded = params.map(([name, value]) => `${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+	const query = parts.query === "" ? encoded.join("&") : `${parts.query}&${encoded.join("&")}`;
+	return formatLnurlUrl({
+		...parts,
+		query
+	});
+}
+//#endregion
+//#region src/lnurl/auth.ts
+const K1_PATTERN = /^[0-9a-f]{64}$/;
+function asAction(value) {
+	switch (value) {
+		case "register":
+		case "login":
+		case "link":
+		case "auth": return value;
+		default: return;
+	}
+}
+/**
+* Parses an LNURL-auth URL (the decoded form of a `lnurl1…` string or a bare https/onion URL).
+* Requires `tag=login` and a 64-hex `k1` query parameter; `action` must be one of the LUD-04 enum
+* values when present.
+*/
+function parseLnurlAuth(url) {
+	let parts;
+	try {
+		parts = parseLnurlUrl(url);
+	} catch (error) {
+		throw new SparkInputError("lnurl auth: not a URL", { cause: error });
+	}
+	const params = queryParams(parts.query);
+	if (params.get("tag") !== "login") throw new SparkInputError("lnurl auth: expected tag=login");
+	const k1 = params.get("k1")?.toLowerCase();
+	if (k1 === void 0 || !K1_PATTERN.test(k1)) throw new SparkInputError("lnurl auth: k1 must be 64 hex characters");
+	const actionText = params.get("action");
+	const action = actionText === void 0 ? void 0 : asAction(actionText);
+	if (actionText !== void 0 && action === void 0) throw new SparkInputError("lnurl auth: unsupported action");
+	return {
+		tag: "login",
+		url: formatLnurlUrl(parts),
+		k1,
+		...action === void 0 ? {} : { action },
+		domain: parts.host
+	};
+}
+/**
+* LUD-04 step 3: signs the `k1` challenge with the domain's linking key and GETs the service URL
+* with `sig` and `key` appended. The k1 challenge and the signature never appear in error
+* messages.
+*/
+async function submitLnurlAuth(request, options) {
+	const { linkingKey, signature } = await options.signer.sign({
+		domain: request.domain,
+		k1: hexToBytes(request.k1)
+	});
+	if ((await lnurlGetJson(withQuery(request.url, [["sig", bytesToHex(signature)], ["key", bytesToHex(linkingKey)]]), options.fetch))["status"] !== "OK") throw new SparkRequestError("lnurl auth response: status is not OK", { code: "unexpected_response" });
+}
+//#endregion
+//#region src/lnurl/codec.ts
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function fail$3(message, options) {
+	throw new SparkInputError(`lnurl: ${message}`, options);
+}
+/** LUD-01 §HTTPS or Onion: clearnet https, or http only for a `.onion` host. */
+function checkLnurlUrl(url) {
+	const parts = parseLnurlUrl(url);
+	if (parts.scheme === "https") return;
+	if (parts.scheme === "http" && parts.host.endsWith(".onion")) return;
+	fail$3("url must be https, or http to an .onion host");
+}
+/**
+* Decodes a bech32 `lnurl1…` string into the normalized URL it wraps (LUD-01). Accepts upper- or
+* lowercase (never mixed) and an optional `lightning:` scheme prefix.
+*/
+function decodeLnurl(text) {
+	const raw = text.toLowerCase().startsWith("lightning:") ? text.slice(10) : text;
+	if (/[a-z]/.test(raw) && /[A-Z]/.test(raw)) fail$3("mixed case");
+	let decoded;
+	try {
+		decoded = bech32.decodeToBytes(raw.toLowerCase(), false);
+	} catch (error) {
+		throw new SparkInputError("lnurl: invalid bech32", { cause: error });
+	}
+	if (decoded.prefix !== "lnurl") fail$3("prefix: expected 'lnurl'");
+	let url;
+	try {
+		url = UTF8_DECODER.decode(decoded.bytes);
+	} catch (error) {
+		throw new SparkInputError("lnurl: payload is not UTF-8", { cause: error });
+	}
+	checkLnurlUrl(url);
+	return formatLnurlUrl(parseLnurlUrl(url));
+}
+/** Bech32-encodes an https/onion URL into a lowercase `lnurl1…` string (LUD-01). */
+function encodeLnurl(url) {
+	checkLnurlUrl(url);
+	return bech32.encode("lnurl", bech32.toWords(utf8ToBytes(formatLnurlUrl(parseLnurlUrl(url)))), false);
+}
+const USERNAME_PATTERN = /^[a-z0-9._+-]+$/;
+/**
+* LUD-16 `<username>@<domain>` → the well-known pay endpoint. `@<domain>` resolves to the default
+* identifier `_`. An `.onion` domain yields http, a clearnet domain https. Usernames are lowercased
+* and must match `a-z0-9-_.` plus `+` for service tags; ports, userinfo and paths are rejected.
+*/
+function lightningAddressUrl(address) {
+	const lower = address.toLowerCase();
+	const at = lower.lastIndexOf("@");
+	if (at === -1) fail$3("lightning address: expected <username>@<domain>");
+	const username = lower.slice(0, at) || "_";
+	const domain = lower.slice(at + 1);
+	if (!USERNAME_PATTERN.test(username)) fail$3("lightning address: invalid username");
+	if (domain === "") fail$3("lightning address: missing domain");
+	let host;
+	try {
+		const parts = parseLnurlUrl(`https://${domain}`);
+		if (parts.port !== void 0 || parts.path !== "/") fail$3("lightning address: domain must be a bare hostname");
+		({host} = parts);
+	} catch (error) {
+		throw new SparkInputError("lnurl: lightning address: invalid domain", { cause: error });
+	}
+	return `${host.endsWith(".onion") ? "http" : "https"}://${host}/.well-known/lnurlp/${username}`;
+}
+//#endregion
+//#region src/lnurl/success-action.ts
+/** LUD-10 caps the base64-decoded ciphertext at 4 KiB. */
+const AES_CIPHERTEXT_MAX_BYTES = 4096;
+function fail$2(message) {
+	throw new SparkInputError(`lnurl successAction: ${message}`);
+}
+function asString$2(action, field) {
+	const { [field]: value } = action;
+	if (typeof value !== "string") fail$2(`${field} is not a string`);
+	return value;
+}
+/**
+* Parses a `successAction` object (LUD-09). `callbackHost` is the payRequest callback's hostname:
+* `url` actions must stay on that domain. Unknown tags are rejected — a wallet that cannot show the
+* action must not proceed (LUD-09).
+*/
+function parseSuccessAction(value, callbackHost) {
+	if (!isJsonObject(value)) fail$2("not an object");
+	switch (value["tag"]) {
+		case "message": {
+			const message = asString$2(value, "message");
+			if (message.length > 144) fail$2("message exceeds 144 characters");
+			return {
+				tag: "message",
+				message
+			};
+		}
+		case "url": {
+			const description = asString$2(value, "description");
+			if (description.length > 144) fail$2("description exceeds 144 characters");
+			const url = asString$2(value, "url");
+			let host;
+			try {
+				({host} = parseLnurlUrl(url));
+			} catch (error) {
+				throw new SparkInputError("lnurl successAction: url is not a URL", { cause: error });
+			}
+			if (host !== callbackHost) fail$2("url domain does not match the callback domain");
+			return {
+				tag: "url",
+				description,
+				url
+			};
+		}
+		case "aes": return {
+			tag: "aes",
+			description: asString$2(value, "description"),
+			ciphertext: asString$2(value, "ciphertext"),
+			iv: asString$2(value, "iv")
+		};
+		default: return fail$2("unknown tag");
+	}
+}
+/**
+* LUD-10: decrypts an `aes` successAction with the payment preimage — AES-256-CBC, the preimage is
+* the key, `iv` is base64 of 16 bytes, `ciphertext` base64 of at most 4 KiB, PKCS#7 padding, UTF-8
+* plaintext.
+*/
+function decryptSuccessAction(action, preimage) {
+	if (preimage.length !== 32) fail$2("preimage must be 32 bytes");
+	let iv;
+	let ciphertext;
+	try {
+		iv = base64.decode(action.iv);
+		ciphertext = base64.decode(action.ciphertext);
+	} catch (error) {
+		throw new SparkInputError("lnurl successAction: aes fields are not base64", { cause: error });
+	}
+	if (iv.length !== 16) fail$2("iv is not 16 bytes");
+	if (ciphertext.length === 0 || ciphertext.length > AES_CIPHERTEXT_MAX_BYTES) fail$2("ciphertext exceeds 4 KiB");
+	let plaintext;
+	try {
+		plaintext = cbc(preimage, iv).decrypt(ciphertext);
+	} catch (error) {
+		throw new SparkInputError("lnurl successAction: aes decryption failed", { cause: error });
+	}
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(plaintext);
+	} catch (error) {
+		throw new SparkInputError("lnurl successAction: aes plaintext is not UTF-8", { cause: error });
+	}
+}
+//#endregion
+//#region src/lnurl/pay.ts
+function fail$1(message) {
+	throw new SparkInputError(`lnurl payRequest: ${message}`);
+}
+function asString$1(body, field) {
+	const { [field]: value } = body;
+	if (typeof value !== "string") fail$1(`${field} is not a string`);
+	return value;
+}
+function asMsat$1(body, field) {
+	const { [field]: value } = body;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) fail$1(`${field} is not a non-negative integer`);
+	return value;
+}
+/** LUD-06: every metadata entry is an array whose first item is the mime-like type. */
+function asEntry(value) {
+	if (!Array.isArray(value) || value.length < 2 || typeof value[0] !== "string") fail$1("metadata entries must be [type, value] arrays");
+	return [value[0], value[1]];
+}
+/** The metadata array's single mandatory `text/plain` string (LUD-06 step 3). */
+function parseDescription(metadata) {
+	let entries;
+	try {
+		entries = JSON.parse(metadata);
+	} catch (error) {
+		throw new SparkInputError("lnurl payRequest: metadata is not valid JSON", { cause: error });
+	}
+	if (!Array.isArray(entries)) fail$1("metadata is not an array");
+	let description;
+	for (const raw of entries) {
+		const [mime, content] = asEntry(raw);
+		if (mime !== "text/plain") continue;
+		if (typeof content !== "string") fail$1("metadata text/plain value is not a string");
+		if (description !== void 0) fail$1("metadata has more than one text/plain entry");
+		description = content;
+	}
+	if (description === void 0) fail$1("metadata lacks a text/plain entry");
+	return description;
+}
+function parseLnurlPayRequest(body) {
+	if (body["tag"] !== "payRequest") fail$1("tag is not payRequest");
+	const callback = asString$1(body, "callback");
+	try {
+		checkLnurlUrl(callback);
+	} catch (error) {
+		throw new SparkInputError("lnurl payRequest: callback must be a valid https or .onion http url", { cause: error });
+	}
+	const minSendableMsat = asMsat$1(body, "minSendable");
+	const maxSendableMsat = asMsat$1(body, "maxSendable");
+	if (minSendableMsat === 0) fail$1("minSendable is less than 1");
+	if (minSendableMsat > maxSendableMsat) fail$1("minSendable exceeds maxSendable");
+	const metadata = asString$1(body, "metadata");
+	const description = parseDescription(metadata);
+	const commentAllowedRaw = body["commentAllowed"];
+	let commentAllowed = 0;
+	if (commentAllowedRaw !== void 0) {
+		if (typeof commentAllowedRaw !== "number" || !Number.isSafeInteger(commentAllowedRaw) || commentAllowedRaw < 0) fail$1("commentAllowed is not a non-negative integer");
+		commentAllowed = commentAllowedRaw;
+	}
+	const allowsNostr = body["allowsNostr"] === true;
+	let nostrPubkey;
+	if (allowsNostr) {
+		const pubkey = body["nostrPubkey"];
+		if (typeof pubkey !== "string" || !/^[0-9a-fA-F]{64}$/.test(pubkey)) fail$1("allowsNostr without a 32-byte hex nostrPubkey");
+		nostrPubkey = hexToBytes(pubkey);
+	}
+	return {
+		tag: "payRequest",
+		callback,
+		minSendableMsat,
+		maxSendableMsat,
+		metadata,
+		description,
+		commentAllowed,
+		allowsNostr,
+		nostrPubkey
+	};
+}
+/**
+* LUD-06 second callback: requests the invoice for `amountMsat`, then verifies it against the
+* request — exact amount, invoice network, and a `h` description-hash over the raw metadata (or
+* over the zap-request event alone for a nostr zap, NIP-57).
+*/
+async function requestInvoice(request, options) {
+	const { amountMsat, comment, zapRequest } = options;
+	if (!Number.isSafeInteger(amountMsat) || amountMsat < request.minSendableMsat || amountMsat > request.maxSendableMsat) fail$1("amount is outside the sendable bounds");
+	if (comment !== void 0) {
+		if (request.commentAllowed === 0) fail$1("comment: the service does not accept comments");
+		if (comment.length > request.commentAllowed) fail$1("comment exceeds commentAllowed");
+	}
+	if (zapRequest !== void 0 && !request.allowsNostr) fail$1("zapRequest: the service does not allow nostr zaps");
+	const params = [["amount", String(amountMsat)]];
+	if (comment !== void 0) params.push(["comment", comment]);
+	if (zapRequest !== void 0) params.push(["nostr", zapRequest]);
+	const body = await lnurlGetJson(withQuery(request.callback, params), options.fetch);
+	const { pr } = body;
+	if (typeof pr !== "string") fail$1("response pr is not a string");
+	const successAction = body["successAction"] === void 0 ? void 0 : parseSuccessAction(body["successAction"], parseLnurlUrl(request.callback).host);
+	let decoded;
+	try {
+		decoded = decodeBolt11(pr);
+	} catch (error) {
+		throw new SparkRequestError("lnurl response: pr is not a valid BOLT-11 invoice", {
+			code: "unexpected_response",
+			cause: error
+		});
+	}
+	if (decoded.amountMsat !== BigInt(amountMsat)) fail$1("invoice amount does not match the requested amount");
+	if (decoded.network !== options.network) fail$1("invoice is for a different network");
+	if (decoded.descriptionHash === void 0) fail$1("invoice lacks a description hash");
+	const expected = sha256(utf8ToBytes(zapRequest ?? request.metadata));
+	if (!equalBytes(decoded.descriptionHash, expected)) fail$1("invoice description hash does not match the metadata");
+	return {
+		invoice: pr,
+		decoded,
+		successAction
+	};
+}
+//#endregion
+//#region src/lnurl/withdraw.ts
+function fail(message) {
+	throw new SparkInputError(`lnurl withdrawRequest: ${message}`);
+}
+function asString(body, field, required) {
+	const { [field]: value } = body;
+	if (typeof value !== "string") {
+		if (!required && value === void 0) return "";
+		fail(`${field} is not a string`);
+	}
+	return value;
+}
+function asMsat(body, field) {
+	const { [field]: value } = body;
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) fail(`${field} is not a non-negative integer`);
+	return value;
+}
+function parseLnurlWithdrawRequest(body) {
+	if (body["tag"] !== "withdrawRequest") fail("tag is not withdrawRequest");
+	const callback = asString(body, "callback", true);
+	try {
+		checkLnurlUrl(callback);
+	} catch (error) {
+		throw new SparkInputError("lnurl withdrawRequest: callback must be a valid https or .onion http url", { cause: error });
+	}
+	const k1 = asString(body, "k1", true);
+	if (k1 === "") fail("k1 is empty");
+	const minWithdrawableMsat = asMsat(body, "minWithdrawable");
+	const maxWithdrawableMsat = asMsat(body, "maxWithdrawable");
+	if (minWithdrawableMsat > maxWithdrawableMsat) fail("minWithdrawable exceeds maxWithdrawable");
+	return {
+		tag: "withdrawRequest",
+		callback,
+		k1,
+		defaultDescription: asString(body, "defaultDescription", false),
+		minWithdrawableMsat,
+		maxWithdrawableMsat
+	};
+}
+/**
+* LUD-03 step 5: submits the wallet's BOLT-11 `invoice` for payment. The service pays
+* asynchronously; a `{"status": "OK"}` body means it accepted — errors surface as
+* `SparkRequestError` (`lnurl_error` / `http_*`).
+*/
+async function submitWithdraw(request, options) {
+	if ((await lnurlGetJson(withQuery(request.callback, [["k1", request.k1], ["pr", options.invoice]]), options.fetch))["status"] !== "OK") throw new SparkRequestError("lnurl withdraw response: status is not OK", { code: "unexpected_response" });
+}
+//#endregion
+//#region src/lnurl/fetch.ts
+/**
+* Resolves an `lnurl1…` string, a lightning address (`user@domain`, LUD-16) or a bare https/onion
+* URL into a typed LNURL service request. A `tag=login` query is a LUD-04 auth challenge carried
+* inside the LNURL itself and returns without fetching; otherwise the endpoint is fetched and only
+* the interactive `payRequest` (LUD-06) and `withdrawRequest` (LUD-03) tags are supported.
+*/
+async function resolveLnurl(input, options) {
+	const url = resolveUrl(input);
+	if (queryParams(parseLnurlUrl(url).query).get("tag") === "login") return parseLnurlAuth(url);
+	const body = await lnurlGetJson(url, options.fetch);
+	switch (body["tag"]) {
+		case "payRequest": return parseLnurlPayRequest(body);
+		case "withdrawRequest": return parseLnurlWithdrawRequest(body);
+		default: throw new SparkInputError(`lnurl: unsupported tag ${JSON.stringify(body["tag"] ?? null)}`);
+	}
+}
+function resolveUrl(input) {
+	const lower = input.toLowerCase();
+	if (lower.startsWith("lnurl1") || lower.startsWith("lightning:")) return decodeLnurl(input);
+	if (input.includes("@")) return lightningAddressUrl(input);
+	let url;
+	try {
+		checkLnurlUrl(input);
+		url = input;
+	} catch (error) {
+		throw new SparkInputError("lnurl: not an lnurl, lightning address, or URL", { cause: error });
+	}
+	return url;
+}
+//#endregion
+//#region src/lnurl/lightning-address.ts
+/**
+* Builds the register request body the signed statement commits to — lowercased domain and
+* username, fresh timestamp — and signs it. Split from {@link registerLightningAddress} so the same
+* bytes can be handed to a server handler in tests without HTTP.
+*/
+async function lightningAddressRegisterBody(options) {
+	const statement = {
+		kind: "lightning-address",
+		action: "register",
+		domain: options.domain.toLowerCase(),
+		username: options.username.toLowerCase(),
+		description: options.description,
+		timestamp: Math.floor((options.now ?? Date.now)() / 1e3)
+	};
+	const signature = await options.signer.signIdentity(statement);
+	return {
+		pubkeyHex: bytesToHex(await options.signer.identityPublicKey()),
+		body: {
+			username: statement.username,
+			signature: bytesToHex(signature),
+			timestamp: statement.timestamp,
+			description: options.description
+		}
+	};
+}
+/** The unregister counterpart of {@link lightningAddressRegisterBody}. */
+async function lightningAddressUnregisterBody(options) {
+	const statement = {
+		kind: "lightning-address",
+		action: "unregister",
+		domain: options.domain.toLowerCase(),
+		username: options.username.toLowerCase(),
+		timestamp: Math.floor((options.now ?? Date.now)() / 1e3)
+	};
+	const signature = await options.signer.signIdentity(statement);
+	return {
+		pubkeyHex: bytesToHex(await options.signer.identityPublicKey()),
+		body: {
+			username: statement.username,
+			signature: bytesToHex(signature),
+			timestamp: statement.timestamp
+		}
+	};
+}
+function lnurlpayUrl(serverUrl, pubkeyHex) {
+	checkLnurlUrl(serverUrl);
+	const base = formatLnurlUrl(parseLnurlUrl(serverUrl));
+	return `${base.endsWith("/") ? base.slice(0, -1) : base}/lnurlpay/${pubkeyHex}`;
+}
+/**
+* Claims `username` on the Lightning Address server at `serverUrl`: signs the register statement
+* and POSTs it to `/lnurlpay/{pubkey}`. `serverUrl` must be https or an `.onion` http URL.
+*/
+async function registerLightningAddress(options) {
+	const { pubkeyHex, body } = await lightningAddressRegisterBody(options);
+	const response = await lnurlSendJson(lnurlpayUrl(options.serverUrl, pubkeyHex), options.fetch, {
+		method: "POST",
+		body
+	});
+	const lnurl = response?.["lnurl"];
+	const lightningAddress = response?.["lightning_address"];
+	if (typeof lnurl !== "string" || typeof lightningAddress !== "string") throw new SparkRequestError("lnurl register response: missing lnurl or lightning_address", { code: "unexpected_response" });
+	const domain = options.domain.toLowerCase();
+	const username = options.username.toLowerCase();
+	if (lightningAddress !== `${username}@${domain}`) throw new SparkRequestError("lnurl register response: lightning_address is not the requested address", { code: "unexpected_response" });
+	let decoded;
+	try {
+		decoded = decodeLnurl(lnurl);
+	} catch (error) {
+		throw new SparkRequestError("lnurl register response: lnurl does not decode", {
+			code: "unexpected_response",
+			cause: error
+		});
+	}
+	if (decoded !== `https://${domain}/lnurlp/${username}`) throw new SparkRequestError("lnurl register response: lnurl does not point at the requested pay endpoint", { code: "unexpected_response" });
+	return {
+		lnurl,
+		lightningAddress
+	};
+}
+/**
+* Gives up `username` on the server: signs the unregister statement and DELETEs
+* `/lnurlpay/{pubkey}`.
+*/
+async function unregisterLightningAddress(options) {
+	const { pubkeyHex, body } = await lightningAddressUnregisterBody(options);
+	await lnurlSendJson(lnurlpayUrl(options.serverUrl, pubkeyHex), options.fetch, {
+		method: "DELETE",
+		body
+	});
+}
+//#endregion
+export { submitLnurlAuth as _, resolveLnurl as a, lnurlSendJson as b, parseLnurlPayRequest as c, parseSuccessAction as d, checkLnurlUrl as f, parseLnurlAuth as g, lightningAddressUrl as h, unregisterLightningAddress as i, requestInvoice as l, encodeLnurl as m, lightningAddressUnregisterBody as n, parseLnurlWithdrawRequest as o, decodeLnurl as p, registerLightningAddress as r, submitWithdraw as s, lightningAddressRegisterBody as t, decryptSuccessAction as u, isJsonObject as v, lnurlGetJson as y };