@qntx/spark 0.0.0-stage → 0.1.1

package/dist/text-DC_Vptn6.mjs

@@ -0,0 +1,303 @@
+import { r as SparkInputError } from "./errors-5xLkExNL.mjs";
+import { concatBytes, utf8ToBytes } from "@noble/hashes/utils.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bech32 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+//#region src/core/bolt11.ts
+const TAG_PAYMENT_HASH = 1;
+const TAG_ROUTE_HINT = 3;
+const TAG_FEATURES = 5;
+const TAG_EXPIRY = 6;
+const TAG_FALLBACK = 9;
+const TAG_DESCRIPTION = 13;
+const TAG_PAYMENT_SECRET = 16;
+const TAG_PAYEE = 19;
+const TAG_DESCRIPTION_HASH = 23;
+const TAG_MIN_FINAL_CLTV = 24;
+const TAG_METADATA = 27;
+const TIMESTAMP_WORDS = 7;
+const SIGNATURE_WORDS = 104;
+const HASH_WORDS = 52;
+const PAYEE_WORDS = 53;
+const ROUTE_HOP_BYTES = 51;
+const DEFAULT_EXPIRY_SECONDS = 3600;
+const DEFAULT_MIN_FINAL_CLTV = 18;
+const NETWORK_PREFIX = {
+	bc: "mainnet",
+	bcrt: "regtest",
+	tb: "testnet",
+	tbs: "signet"
+};
+const MULTIPLIER_MSAT = {
+	"": 100000000000n,
+	m: 100000000n,
+	u: 100000n,
+	n: 100n
+};
+const KNOWN_EVEN_FEATURES = /* @__PURE__ */ new Set([
+	0,
+	4,
+	6,
+	8,
+	10,
+	12,
+	14,
+	16,
+	18,
+	22,
+	24,
+	26,
+	28,
+	34,
+	36,
+	38,
+	40,
+	42,
+	44,
+	46,
+	48,
+	50,
+	60,
+	62,
+	66
+]);
+function fail(message) {
+	throw new SparkInputError(`invoice: ${message}`);
+}
+/** 5-bit words → bytes, big-endian, dropping the incomplete trailing group. */
+function wordsToBytes(words) {
+	return wordsToBytesImpl(words, false);
+}
+/** 5-bit words → bytes, big-endian, zero-padding the last partial byte. */
+function wordsToBytesPadded(words) {
+	return wordsToBytesImpl(words, true);
+}
+function wordsToBytesImpl(words, pad) {
+	const total = pad ? Math.ceil(words.length * 5 / 8) : Math.floor(words.length * 5 / 8);
+	const out = new Uint8Array(total);
+	let acc = 0;
+	let bits = 0;
+	let index = 0;
+	for (const word of words) {
+		acc = (acc << 5 | word) & 4294967295;
+		bits += 5;
+		while (bits >= 8) {
+			bits -= 8;
+			out[index] = acc >>> bits & 255;
+			index++;
+		}
+		acc &= (1 << bits) - 1;
+	}
+	if (pad && bits > 0) out[index] = acc << 8 - bits & 255;
+	return out;
+}
+function wordsToInt(words) {
+	let value = 0;
+	for (const word of words) {
+		value = value * 32 + word;
+		if (value > Number.MAX_SAFE_INTEGER) fail("integer field overflows a safe integer");
+	}
+	return value;
+}
+/** Feature bit `n` of a big-endian bitfield expressed as 5-bit words (bit 0 = LSB). */
+function hasFeatureBit(words, bit) {
+	return ((words[words.length - 1 - Math.floor(bit / 5)] ?? 0) >>> bit % 5 & 1) === 1;
+}
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function parseAmount(hrpAmount) {
+	if (hrpAmount === "") return;
+	const match = /^([0-9]+)([munp]?)$/.exec(hrpAmount);
+	if (match === null) fail("amount: not a decimal integer with optional m/u/n/p multiplier");
+	const digits = match[1] ?? "";
+	const multiplier = match[2] ?? "";
+	if (digits.length > 1 && digits.startsWith("0")) fail("amount: leading zeros are not allowed");
+	const value = BigInt(digits);
+	if (multiplier === "p") {
+		if (value % 10n !== 0n) fail("amount: pico-BTC value must be a multiple of 10 (whole millisatoshis)");
+		return value / 10n;
+	}
+	const factor = MULTIPLIER_MSAT[multiplier];
+	if (factor === void 0) fail("amount: invalid multiplier");
+	return value * factor;
+}
+function parseRouteHint(words) {
+	const data = wordsToBytes(words);
+	if (data.length === 0 || data.length % ROUTE_HOP_BYTES !== 0) fail("route hint: data is not a multiple of the 51-byte entry size");
+	const hops = [];
+	for (let offset = 0; offset < data.length; offset += ROUTE_HOP_BYTES) {
+		const entry = data.subarray(offset, offset + ROUTE_HOP_BYTES);
+		hops.push({
+			publicKey: entry.slice(0, 33),
+			shortChannelId: entry.slice(33, 41),
+			feeBaseMsat: new DataView(entry.buffer, entry.byteOffset + 41, 8).getUint32(0),
+			feeProportionalMillionths: new DataView(entry.buffer, entry.byteOffset + 41, 8).getUint32(4),
+			cltvExpiryDelta: new DataView(entry.buffer, entry.byteOffset + 49, 2).getUint16(0)
+		});
+	}
+	return hops;
+}
+/**
+* Decodes a BOLT-11 payment request. Throws {@link SparkInputError} on malformed input: bad bech32,
+* unknown prefix, bad amount, missing required fields, unknown even feature bits, or a signature
+* that fails verification/recovery.
+*/
+function decodeBolt11(invoice) {
+	let decoded;
+	try {
+		decoded = bech32.decode(invoice, false);
+	} catch (error) {
+		throw new SparkInputError("invoice: invalid bech32", { cause: error });
+	}
+	const { prefix: hrp, words } = decoded;
+	if (!hrp.startsWith("ln")) fail("prefix: expected 'ln'");
+	const letters = /^[a-z]+/.exec(hrp.slice(2))?.[0];
+	const network = letters === void 0 ? void 0 : NETWORK_PREFIX[letters];
+	if (network === void 0) fail("prefix: unknown currency code");
+	const amountMsat = parseAmount(hrp.slice(2 + (letters?.length ?? 0)));
+	const taggedEnd = words.length - SIGNATURE_WORDS;
+	if (taggedEnd < TIMESTAMP_WORDS) fail("too short");
+	const timestamp = wordsToInt(words.slice(0, TIMESTAMP_WORDS));
+	let paymentHash;
+	let paymentSecret;
+	let description;
+	let descriptionHash;
+	let payeeNode;
+	let expirySeconds = DEFAULT_EXPIRY_SECONDS;
+	let minFinalCltvExpiry = DEFAULT_MIN_FINAL_CLTV;
+	let featuresWords;
+	const routeHints = [];
+	const fallbackAddresses = [];
+	let metadata;
+	for (let i = TIMESTAMP_WORDS; i < taggedEnd;) {
+		if (i + 3 > taggedEnd) fail("tagged field: truncated header");
+		const tag = words[i];
+		const lengthHi = words[i + 1];
+		const lengthLo = words[i + 2];
+		if (tag === void 0 || lengthHi === void 0 || lengthLo === void 0) fail("tagged field: truncated header");
+		const length = lengthHi * 32 + lengthLo;
+		if (i + 3 + length > taggedEnd) fail("tagged field: data overruns the signature");
+		const field = words.slice(i + 3, i + 3 + length);
+		switch (tag) {
+			case TAG_PAYMENT_HASH:
+			case TAG_PAYMENT_SECRET:
+			case TAG_DESCRIPTION_HASH:
+			case TAG_PAYEE: {
+				const expected = tag === TAG_PAYEE ? PAYEE_WORDS : HASH_WORDS;
+				if (field.length !== expected) break;
+				const value = wordsToBytes(field);
+				if (tag === TAG_PAYMENT_HASH && paymentHash === void 0) paymentHash = value;
+				else if (tag === TAG_PAYMENT_SECRET && paymentSecret === void 0) paymentSecret = value;
+				else if (tag === TAG_DESCRIPTION_HASH && descriptionHash === void 0) descriptionHash = value;
+				else if (tag === TAG_PAYEE && payeeNode === void 0) payeeNode = value;
+				break;
+			}
+			case TAG_DESCRIPTION:
+				try {
+					description ??= UTF8_DECODER.decode(wordsToBytes(field));
+				} catch (error) {
+					throw new SparkInputError("invoice: description: invalid UTF-8", { cause: error });
+				}
+				break;
+			case TAG_EXPIRY:
+				if (field[0] === 0) fail("expiry: non-minimal data_length");
+				expirySeconds = wordsToInt(field);
+				break;
+			case TAG_MIN_FINAL_CLTV:
+				if (field[0] === 0) fail("min_final_cltv_expiry: non-minimal data_length");
+				minFinalCltvExpiry = wordsToInt(field);
+				break;
+			case TAG_FEATURES:
+				if (field[0] === 0) fail("features: non-minimal data_length");
+				featuresWords = field;
+				break;
+			case TAG_FALLBACK: {
+				if (field.length === 0) fail("fallback: missing version");
+				const version = field[0] ?? 0;
+				fallbackAddresses.push({
+					version,
+					program: wordsToBytes(field.slice(1))
+				});
+				break;
+			}
+			case TAG_ROUTE_HINT:
+				routeHints.push(parseRouteHint(field));
+				break;
+			case TAG_METADATA: metadata ??= wordsToBytes(field);
+		}
+		i += 3 + length;
+	}
+	if (paymentHash === void 0) fail("missing payment hash (p)");
+	if (paymentSecret === void 0) fail("missing payment secret (s)");
+	if (description === void 0 && descriptionHash === void 0) fail("missing description (d) and description hash (h)");
+	if (description !== void 0 && descriptionHash !== void 0) fail("both description (d) and description hash (h) present");
+	if (featuresWords !== void 0) {
+		for (let bit = 0; bit < featuresWords.length * 5; bit += 2) if (!KNOWN_EVEN_FEATURES.has(bit) && hasFeatureBit(featuresWords, bit)) fail(`features: unknown required feature bit ${bit}`);
+	}
+	const signature = wordsToBytes(words.slice(taggedEnd));
+	const compact = signature.slice(0, 64);
+	const [recoveryId] = signature.subarray(64, 65);
+	if (recoveryId === void 0 || recoveryId > 3) fail("signature: recovery id must be 0..3");
+	const preimage = concatBytes(utf8ToBytes(hrp), wordsToBytesPadded(words.slice(0, taggedEnd)));
+	const messageHash = sha256(preimage);
+	let payee;
+	if (payeeNode !== void 0 && isValidPoint(payeeNode)) {
+		let ok;
+		try {
+			ok = secp256k1.verify(compact, messageHash, payeeNode, {
+				prehash: false,
+				lowS: true
+			});
+		} catch {
+			ok = false;
+		}
+		if (!ok) fail("signature: does not verify against the n field");
+		payee = payeeNode;
+	} else {
+		const recoverable = /* @__PURE__ */ new Uint8Array(65);
+		recoverable[0] = recoveryId;
+		recoverable.set(compact, 1);
+		try {
+			payee = secp256k1.recoverPublicKey(recoverable, messageHash, { prehash: false });
+		} catch (error) {
+			throw new SparkInputError("invoice: signature is not recoverable", { cause: error });
+		}
+	}
+	return {
+		network,
+		amountMsat,
+		timestamp,
+		paymentHash,
+		paymentSecret,
+		description,
+		descriptionHash,
+		expirySeconds,
+		minFinalCltvExpiry,
+		payee,
+		features: featuresWords === void 0 ? void 0 : wordsToBytes(featuresWords),
+		routeHints,
+		fallbackAddresses,
+		metadata
+	};
+}
+function isValidPoint(bytes) {
+	try {
+		secp256k1.Point.fromBytes(bytes);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** True once `timestamp + expirySeconds` has passed at `nowMs` (unix milliseconds). */
+function isExpired(invoice, nowMs) {
+	return nowMs > (invoice.timestamp + invoice.expirySeconds) * 1e3;
+}
+//#endregion
+//#region src/core/text.ts
+const CONTROL = /[\u0000-\u001F\u007F-\u009F]/g;
+/** Server-supplied error text made safe to embed in an error message. */
+function serverErrorText(text) {
+	const cleaned = text.replace(CONTROL, "");
+	return cleaned.length <= 256 ? cleaned : `${cleaned.slice(0, 256)}\u2026`;
+}
+//#endregion
+export { decodeBolt11 as n, isExpired as r, serverErrorText as t };