🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →
@getalby/lightning-tools
Advanced tools
@getalby/lightning-tools - npm Package Compare versions
+1585
| 'use strict'; | ||
| function bytes(b, ...lengths) { | ||
| if (!(b instanceof Uint8Array)) | ||
| throw new Error('Expected Uint8Array'); | ||
| if (lengths.length > 0 && !lengths.includes(b.length)) | ||
| throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`); | ||
| } | ||
| function exists(instance, checkFinished = true) { | ||
| if (instance.destroyed) | ||
| throw new Error('Hash instance has been destroyed'); | ||
| if (checkFinished && instance.finished) | ||
| throw new Error('Hash#digest() has already been called'); | ||
| } | ||
| function output(out, instance) { | ||
| bytes(out); | ||
| const min = instance.outputLen; | ||
| if (out.length < min) { | ||
| throw new Error(`digestInto() expects output buffer of length at least ${min}`); | ||
| } | ||
| } | ||
| /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| // We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+. | ||
| // node.js versions earlier than v19 don't declare it in global scope. | ||
| // For node.js, package.json#exports field mapping rewrites import | ||
| // from `crypto` to `cryptoNode`, which imports native module. | ||
| // Makes the utils un-importable in browsers without a bundler. | ||
| // Once node.js 18 is deprecated, we can just drop the import. | ||
| const u8a = (a) => a instanceof Uint8Array; | ||
| // Cast array to view | ||
| const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength); | ||
| // The rotate right (circular right shift) operation for uint32 | ||
| const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift); | ||
| // big-endian hardware is rare. Just in case someone still decides to run hashes: | ||
| // early-throw an error because we don't support BE yet. | ||
| const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44; | ||
| if (!isLE) | ||
| throw new Error('Non little-endian hardware is not supported'); | ||
| const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0')); | ||
| /** | ||
| * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123' | ||
| */ | ||
| function bytesToHex(bytes) { | ||
| if (!u8a(bytes)) | ||
| throw new Error('Uint8Array expected'); | ||
| // pre-caching improves the speed 6x | ||
| let hex = ''; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| hex += hexes[bytes[i]]; | ||
| } | ||
| return hex; | ||
| } | ||
| /** | ||
| * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99]) | ||
| */ | ||
| function utf8ToBytes(str) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`utf8ToBytes expected string, got ${typeof str}`); | ||
| return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809 | ||
| } | ||
| /** | ||
| * Normalizes (non-hex) string or Uint8Array to Uint8Array. | ||
| * Warning: when Uint8Array is passed, it would NOT get copied. | ||
| * Keep in mind for future mutable operations. | ||
| */ | ||
| function toBytes(data) { | ||
| if (typeof data === 'string') | ||
| data = utf8ToBytes(data); | ||
| if (!u8a(data)) | ||
| throw new Error(`expected Uint8Array, got ${typeof data}`); | ||
| return data; | ||
| } | ||
| // For runtime check if class implements interface | ||
| class Hash { | ||
| // Safe version that clones internal state | ||
| clone() { | ||
| return this._cloneInto(); | ||
| } | ||
| } | ||
| function wrapConstructor(hashCons) { | ||
| const hashC = (msg) => hashCons().update(toBytes(msg)).digest(); | ||
| const tmp = hashCons(); | ||
| hashC.outputLen = tmp.outputLen; | ||
| hashC.blockLen = tmp.blockLen; | ||
| hashC.create = () => hashCons(); | ||
| return hashC; | ||
| } | ||
| // Polyfill for Safari 14 | ||
| function setBigUint64(view, byteOffset, value, isLE) { | ||
| if (typeof view.setBigUint64 === 'function') | ||
| return view.setBigUint64(byteOffset, value, isLE); | ||
| const _32n = BigInt(32); | ||
| const _u32_max = BigInt(0xffffffff); | ||
| const wh = Number((value >> _32n) & _u32_max); | ||
| const wl = Number(value & _u32_max); | ||
| const h = isLE ? 4 : 0; | ||
| const l = isLE ? 0 : 4; | ||
| view.setUint32(byteOffset + h, wh, isLE); | ||
| view.setUint32(byteOffset + l, wl, isLE); | ||
| } | ||
| // Base SHA2 class (RFC 6234) | ||
| class SHA2 extends Hash { | ||
| constructor(blockLen, outputLen, padOffset, isLE) { | ||
| super(); | ||
| this.blockLen = blockLen; | ||
| this.outputLen = outputLen; | ||
| this.padOffset = padOffset; | ||
| this.isLE = isLE; | ||
| this.finished = false; | ||
| this.length = 0; | ||
| this.pos = 0; | ||
| this.destroyed = false; | ||
| this.buffer = new Uint8Array(blockLen); | ||
| this.view = createView(this.buffer); | ||
| } | ||
| update(data) { | ||
| exists(this); | ||
| const { view, buffer, blockLen } = this; | ||
| data = toBytes(data); | ||
| const len = data.length; | ||
| for (let pos = 0; pos < len;) { | ||
| const take = Math.min(blockLen - this.pos, len - pos); | ||
| // Fast path: we have at least one block in input, cast it to view and process | ||
| if (take === blockLen) { | ||
| const dataView = createView(data); | ||
| for (; blockLen <= len - pos; pos += blockLen) | ||
| this.process(dataView, pos); | ||
| continue; | ||
| } | ||
| buffer.set(data.subarray(pos, pos + take), this.pos); | ||
| this.pos += take; | ||
| pos += take; | ||
| if (this.pos === blockLen) { | ||
| this.process(view, 0); | ||
| this.pos = 0; | ||
| } | ||
| } | ||
| this.length += data.length; | ||
| this.roundClean(); | ||
| return this; | ||
| } | ||
| digestInto(out) { | ||
| exists(this); | ||
| output(out, this); | ||
| this.finished = true; | ||
| // Padding | ||
| // We can avoid allocation of buffer for padding completely if it | ||
| // was previously not allocated here. But it won't change performance. | ||
| const { buffer, view, blockLen, isLE } = this; | ||
| let { pos } = this; | ||
| // append the bit '1' to the message | ||
| buffer[pos++] = 0b10000000; | ||
| this.buffer.subarray(pos).fill(0); | ||
| // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again | ||
| if (this.padOffset > blockLen - pos) { | ||
| this.process(view, 0); | ||
| pos = 0; | ||
| } | ||
| // Pad until full block byte with zeros | ||
| for (let i = pos; i < blockLen; i++) | ||
| buffer[i] = 0; | ||
| // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that | ||
| // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen. | ||
| // So we just write lowest 64 bits of that value. | ||
| setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE); | ||
| this.process(view, 0); | ||
| const oview = createView(out); | ||
| const len = this.outputLen; | ||
| // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT | ||
| if (len % 4) | ||
| throw new Error('_sha2: outputLen should be aligned to 32bit'); | ||
| const outLen = len / 4; | ||
| const state = this.get(); | ||
| if (outLen > state.length) | ||
| throw new Error('_sha2: outputLen bigger than state'); | ||
| for (let i = 0; i < outLen; i++) | ||
| oview.setUint32(4 * i, state[i], isLE); | ||
| } | ||
| digest() { | ||
| const { buffer, outputLen } = this; | ||
| this.digestInto(buffer); | ||
| const res = buffer.slice(0, outputLen); | ||
| this.destroy(); | ||
| return res; | ||
| } | ||
| _cloneInto(to) { | ||
| to || (to = new this.constructor()); | ||
| to.set(...this.get()); | ||
| const { blockLen, buffer, length, finished, destroyed, pos } = this; | ||
| to.length = length; | ||
| to.pos = pos; | ||
| to.finished = finished; | ||
| to.destroyed = destroyed; | ||
| if (length % blockLen) | ||
| to.buffer.set(buffer); | ||
| return to; | ||
| } | ||
| } | ||
| // SHA2-256 need to try 2^128 hashes to execute birthday attack. | ||
| // BTC network is doing 2^67 hashes/sec as per early 2023. | ||
| // Choice: a ? b : c | ||
| const Chi = (a, b, c) => (a & b) ^ (~a & c); | ||
| // Majority function, true if any two inpust is true | ||
| const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c); | ||
| // Round constants: | ||
| // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311) | ||
| // prettier-ignore | ||
| const SHA256_K = /* @__PURE__ */ new Uint32Array([ | ||
| 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | ||
| 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | ||
| 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | ||
| 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | ||
| 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | ||
| 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | ||
| 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | ||
| 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 | ||
| ]); | ||
| // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19): | ||
| // prettier-ignore | ||
| const IV = /* @__PURE__ */ new Uint32Array([ | ||
| 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 | ||
| ]); | ||
| // Temporary buffer, not used to store anything between runs | ||
| // Named this way because it matches specification. | ||
| const SHA256_W = /* @__PURE__ */ new Uint32Array(64); | ||
| class SHA256 extends SHA2 { | ||
| constructor() { | ||
| super(64, 32, 8, false); | ||
| // We cannot use array here since array allows indexing by variable | ||
| // which means optimizer/compiler cannot use registers. | ||
| this.A = IV[0] | 0; | ||
| this.B = IV[1] | 0; | ||
| this.C = IV[2] | 0; | ||
| this.D = IV[3] | 0; | ||
| this.E = IV[4] | 0; | ||
| this.F = IV[5] | 0; | ||
| this.G = IV[6] | 0; | ||
| this.H = IV[7] | 0; | ||
| } | ||
| get() { | ||
| const { A, B, C, D, E, F, G, H } = this; | ||
| return [A, B, C, D, E, F, G, H]; | ||
| } | ||
| // prettier-ignore | ||
| set(A, B, C, D, E, F, G, H) { | ||
| this.A = A | 0; | ||
| this.B = B | 0; | ||
| this.C = C | 0; | ||
| this.D = D | 0; | ||
| this.E = E | 0; | ||
| this.F = F | 0; | ||
| this.G = G | 0; | ||
| this.H = H | 0; | ||
| } | ||
| process(view, offset) { | ||
| // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array | ||
| for (let i = 0; i < 16; i++, offset += 4) | ||
| SHA256_W[i] = view.getUint32(offset, false); | ||
| for (let i = 16; i < 64; i++) { | ||
| const W15 = SHA256_W[i - 15]; | ||
| const W2 = SHA256_W[i - 2]; | ||
| const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3); | ||
| const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10); | ||
| SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0; | ||
| } | ||
| // Compression function main loop, 64 rounds | ||
| let { A, B, C, D, E, F, G, H } = this; | ||
| for (let i = 0; i < 64; i++) { | ||
| const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25); | ||
| const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0; | ||
| const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22); | ||
| const T2 = (sigma0 + Maj(A, B, C)) | 0; | ||
| H = G; | ||
| G = F; | ||
| F = E; | ||
| E = (D + T1) | 0; | ||
| D = C; | ||
| C = B; | ||
| B = A; | ||
| A = (T1 + T2) | 0; | ||
| } | ||
| // Add the compressed chunk to the current hash value | ||
| A = (A + this.A) | 0; | ||
| B = (B + this.B) | 0; | ||
| C = (C + this.C) | 0; | ||
| D = (D + this.D) | 0; | ||
| E = (E + this.E) | 0; | ||
| F = (F + this.F) | 0; | ||
| G = (G + this.G) | 0; | ||
| H = (H + this.H) | 0; | ||
| this.set(A, B, C, D, E, F, G, H); | ||
| } | ||
| roundClean() { | ||
| SHA256_W.fill(0); | ||
| } | ||
| destroy() { | ||
| this.set(0, 0, 0, 0, 0, 0, 0, 0); | ||
| this.buffer.fill(0); | ||
| } | ||
| } | ||
| /** | ||
| * SHA2-256 hash function | ||
| * @param message - data that would be hashed | ||
| */ | ||
| const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256()); | ||
| var lib = {}; | ||
| var hasRequiredLib; | ||
| function requireLib () { | ||
| if (hasRequiredLib) return lib; | ||
| hasRequiredLib = 1; | ||
| (function (exports) { | ||
| /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64url = exports.base64 = exports.base32crockford = exports.base32hex = exports.base32 = exports.base16 = exports.utils = exports.assertNumber = void 0; | ||
| function assertNumber(n) { | ||
| if (!Number.isSafeInteger(n)) | ||
| throw new Error(`Wrong integer: ${n}`); | ||
| } | ||
| exports.assertNumber = assertNumber; | ||
| function chain(...args) { | ||
| const wrap = (a, b) => (c) => a(b(c)); | ||
| const encode = Array.from(args) | ||
| .reverse() | ||
| .reduce((acc, i) => (acc ? wrap(acc, i.encode) : i.encode), undefined); | ||
| const decode = args.reduce((acc, i) => (acc ? wrap(acc, i.decode) : i.decode), undefined); | ||
| return { encode, decode }; | ||
| } | ||
| function alphabet(alphabet) { | ||
| return { | ||
| encode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('alphabet.encode input should be an array of numbers'); | ||
| return digits.map((i) => { | ||
| assertNumber(i); | ||
| if (i < 0 || i >= alphabet.length) | ||
| throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`); | ||
| return alphabet[i]; | ||
| }); | ||
| }, | ||
| decode: (input) => { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('alphabet.decode input should be array of strings'); | ||
| return input.map((letter) => { | ||
| if (typeof letter !== 'string') | ||
| throw new Error(`alphabet.decode: not string element=${letter}`); | ||
| const index = alphabet.indexOf(letter); | ||
| if (index === -1) | ||
| throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`); | ||
| return index; | ||
| }); | ||
| }, | ||
| }; | ||
| } | ||
| function join(separator = '') { | ||
| if (typeof separator !== 'string') | ||
| throw new Error('join separator should be string'); | ||
| return { | ||
| encode: (from) => { | ||
| if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string')) | ||
| throw new Error('join.encode input should be array of strings'); | ||
| for (let i of from) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`join.encode: non-string input=${i}`); | ||
| return from.join(separator); | ||
| }, | ||
| decode: (to) => { | ||
| if (typeof to !== 'string') | ||
| throw new Error('join.decode input should be string'); | ||
| return to.split(separator); | ||
| }, | ||
| }; | ||
| } | ||
| function padding(bits, chr = '=') { | ||
| assertNumber(bits); | ||
| if (typeof chr !== 'string') | ||
| throw new Error('padding chr should be string'); | ||
| return { | ||
| encode(data) { | ||
| if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of data) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.encode: non-string input=${i}`); | ||
| while ((data.length * bits) % 8) | ||
| data.push(chr); | ||
| return data; | ||
| }, | ||
| decode(input) { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of input) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.decode: non-string input=${i}`); | ||
| let end = input.length; | ||
| if ((end * bits) % 8) | ||
| throw new Error('Invalid padding: string should have whole number of bytes'); | ||
| for (; end > 0 && input[end - 1] === chr; end--) { | ||
| if (!(((end - 1) * bits) % 8)) | ||
| throw new Error('Invalid padding: string has too much padding'); | ||
| } | ||
| return input.slice(0, end); | ||
| }, | ||
| }; | ||
| } | ||
| function normalize(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('normalize fn should be function'); | ||
| return { encode: (from) => from, decode: (to) => fn(to) }; | ||
| } | ||
| function convertRadix(data, from, to) { | ||
| if (from < 2) | ||
| throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`); | ||
| if (to < 2) | ||
| throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`); | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix: data should be array'); | ||
| if (!data.length) | ||
| return []; | ||
| let pos = 0; | ||
| const res = []; | ||
| const digits = Array.from(data); | ||
| digits.forEach((d) => { | ||
| assertNumber(d); | ||
| if (d < 0 || d >= from) | ||
| throw new Error(`Wrong integer: ${d}`); | ||
| }); | ||
| while (true) { | ||
| let carry = 0; | ||
| let done = true; | ||
| for (let i = pos; i < digits.length; i++) { | ||
| const digit = digits[i]; | ||
| const digitBase = from * carry + digit; | ||
| if (!Number.isSafeInteger(digitBase) || | ||
| (from * carry) / from !== carry || | ||
| digitBase - digit !== from * carry) { | ||
| throw new Error('convertRadix: carry overflow'); | ||
| } | ||
| carry = digitBase % to; | ||
| digits[i] = Math.floor(digitBase / to); | ||
| if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase) | ||
| throw new Error('convertRadix: carry overflow'); | ||
| if (!done) | ||
| continue; | ||
| else if (!digits[i]) | ||
| pos = i; | ||
| else | ||
| done = false; | ||
| } | ||
| res.push(carry); | ||
| if (done) | ||
| break; | ||
| } | ||
| for (let i = 0; i < data.length - 1 && data[i] === 0; i++) | ||
| res.push(0); | ||
| return res.reverse(); | ||
| } | ||
| const gcd = (a, b) => (!b ? a : gcd(b, a % b)); | ||
| const radix2carry = (from, to) => from + (to - gcd(from, to)); | ||
| function convertRadix2(data, from, to, padding) { | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix2: data should be array'); | ||
| if (from <= 0 || from > 32) | ||
| throw new Error(`convertRadix2: wrong from=${from}`); | ||
| if (to <= 0 || to > 32) | ||
| throw new Error(`convertRadix2: wrong to=${to}`); | ||
| if (radix2carry(from, to) > 32) { | ||
| throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`); | ||
| } | ||
| let carry = 0; | ||
| let pos = 0; | ||
| const mask = 2 ** to - 1; | ||
| const res = []; | ||
| for (const n of data) { | ||
| assertNumber(n); | ||
| if (n >= 2 ** from) | ||
| throw new Error(`convertRadix2: invalid data word=${n} from=${from}`); | ||
| carry = (carry << from) | n; | ||
| if (pos + from > 32) | ||
| throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`); | ||
| pos += from; | ||
| for (; pos >= to; pos -= to) | ||
| res.push(((carry >> (pos - to)) & mask) >>> 0); | ||
| carry &= 2 ** pos - 1; | ||
| } | ||
| carry = (carry << (to - pos)) & mask; | ||
| if (!padding && pos >= from) | ||
| throw new Error('Excess padding'); | ||
| if (!padding && carry) | ||
| throw new Error(`Non-zero padding: ${carry}`); | ||
| if (padding && pos > 0) | ||
| res.push(carry >>> 0); | ||
| return res; | ||
| } | ||
| function radix(num) { | ||
| assertNumber(num); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix.encode input should be Uint8Array'); | ||
| return convertRadix(Array.from(bytes), 2 ** 8, num); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix(digits, num, 2 ** 8)); | ||
| }, | ||
| }; | ||
| } | ||
| function radix2(bits, revPadding = false) { | ||
| assertNumber(bits); | ||
| if (bits <= 0 || bits > 32) | ||
| throw new Error('radix2: bits should be in (0..32]'); | ||
| if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32) | ||
| throw new Error('radix2: carry overflow'); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix2.encode input should be Uint8Array'); | ||
| return convertRadix2(Array.from(bytes), 8, bits, !revPadding); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix2.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding)); | ||
| }, | ||
| }; | ||
| } | ||
| function unsafeWrapper(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('unsafeWrapper fn should be function'); | ||
| return function (...args) { | ||
| try { | ||
| return fn.apply(null, args); | ||
| } | ||
| catch (e) { } | ||
| }; | ||
| } | ||
| function checksum(len, fn) { | ||
| assertNumber(len); | ||
| if (typeof fn !== 'function') | ||
| throw new Error('checksum fn should be function'); | ||
| return { | ||
| encode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.encode: input should be Uint8Array'); | ||
| const checksum = fn(data).slice(0, len); | ||
| const res = new Uint8Array(data.length + len); | ||
| res.set(data); | ||
| res.set(checksum, data.length); | ||
| return res; | ||
| }, | ||
| decode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.decode: input should be Uint8Array'); | ||
| const payload = data.slice(0, -len); | ||
| const newChecksum = fn(payload).slice(0, len); | ||
| const oldChecksum = data.slice(-len); | ||
| for (let i = 0; i < len; i++) | ||
| if (newChecksum[i] !== oldChecksum[i]) | ||
| throw new Error('Invalid checksum'); | ||
| return payload; | ||
| }, | ||
| }; | ||
| } | ||
| exports.utils = { alphabet, chain, checksum, radix, radix2, join, padding }; | ||
| exports.base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join('')); | ||
| exports.base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join('')); | ||
| exports.base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join('')); | ||
| exports.base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1'))); | ||
| exports.base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join('')); | ||
| exports.base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join('')); | ||
| const genBase58 = (abc) => chain(radix(58), alphabet(abc), join('')); | ||
| exports.base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'); | ||
| exports.base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'); | ||
| exports.base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz'); | ||
| const XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11]; | ||
| exports.base58xmr = { | ||
| encode(data) { | ||
| let res = ''; | ||
| for (let i = 0; i < data.length; i += 8) { | ||
| const block = data.subarray(i, i + 8); | ||
| res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1'); | ||
| } | ||
| return res; | ||
| }, | ||
| decode(str) { | ||
| let res = []; | ||
| for (let i = 0; i < str.length; i += 11) { | ||
| const slice = str.slice(i, i + 11); | ||
| const blockLen = XMR_BLOCK_LEN.indexOf(slice.length); | ||
| const block = exports.base58.decode(slice); | ||
| for (let j = 0; j < block.length - blockLen; j++) { | ||
| if (block[j] !== 0) | ||
| throw new Error('base58xmr: wrong padding'); | ||
| } | ||
| res = res.concat(Array.from(block.slice(block.length - blockLen))); | ||
| } | ||
| return Uint8Array.from(res); | ||
| }, | ||
| }; | ||
| const base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), exports.base58); | ||
| exports.base58check = base58check; | ||
| const BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join('')); | ||
| const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; | ||
| function bech32Polymod(pre) { | ||
| const b = pre >> 25; | ||
| let chk = (pre & 0x1ffffff) << 5; | ||
| for (let i = 0; i < POLYMOD_GENERATORS.length; i++) { | ||
| if (((b >> i) & 1) === 1) | ||
| chk ^= POLYMOD_GENERATORS[i]; | ||
| } | ||
| return chk; | ||
| } | ||
| function bechChecksum(prefix, words, encodingConst = 1) { | ||
| const len = prefix.length; | ||
| let chk = 1; | ||
| for (let i = 0; i < len; i++) { | ||
| const c = prefix.charCodeAt(i); | ||
| if (c < 33 || c > 126) | ||
| throw new Error(`Invalid prefix (${prefix})`); | ||
| chk = bech32Polymod(chk) ^ (c >> 5); | ||
| } | ||
| chk = bech32Polymod(chk); | ||
| for (let i = 0; i < len; i++) | ||
| chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f); | ||
| for (let v of words) | ||
| chk = bech32Polymod(chk) ^ v; | ||
| for (let i = 0; i < 6; i++) | ||
| chk = bech32Polymod(chk); | ||
| chk ^= encodingConst; | ||
| return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false)); | ||
| } | ||
| function genBech32(encoding) { | ||
| const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3; | ||
| const _words = radix2(5); | ||
| const fromWords = _words.decode; | ||
| const toWords = _words.encode; | ||
| const fromWordsUnsafe = unsafeWrapper(fromWords); | ||
| function encode(prefix, words, limit = 90) { | ||
| if (typeof prefix !== 'string') | ||
| throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`); | ||
| if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number')) | ||
| throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`); | ||
| const actualLength = prefix.length + 7 + words.length; | ||
| if (limit !== false && actualLength > limit) | ||
| throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); | ||
| prefix = prefix.toLowerCase(); | ||
| return `${prefix}1${BECH_ALPHABET.encode(words)}${bechChecksum(prefix, words, ENCODING_CONST)}`; | ||
| } | ||
| function decode(str, limit = 90) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`bech32.decode input should be string, not ${typeof str}`); | ||
| if (str.length < 8 || (limit !== false && str.length > limit)) | ||
| throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`); | ||
| const lowered = str.toLowerCase(); | ||
| if (str !== lowered && str !== str.toUpperCase()) | ||
| throw new Error(`String must be lowercase or uppercase`); | ||
| str = lowered; | ||
| const sepIndex = str.lastIndexOf('1'); | ||
| if (sepIndex === 0 || sepIndex === -1) | ||
| throw new Error(`Letter "1" must be present between prefix and data only`); | ||
| const prefix = str.slice(0, sepIndex); | ||
| const _words = str.slice(sepIndex + 1); | ||
| if (_words.length < 6) | ||
| throw new Error('Data must be at least 6 characters long'); | ||
| const words = BECH_ALPHABET.decode(_words).slice(0, -6); | ||
| const sum = bechChecksum(prefix, words, ENCODING_CONST); | ||
| if (!_words.endsWith(sum)) | ||
| throw new Error(`Invalid checksum in ${str}: expected "${sum}"`); | ||
| return { prefix, words }; | ||
| } | ||
| const decodeUnsafe = unsafeWrapper(decode); | ||
| function decodeToBytes(str) { | ||
| const { prefix, words } = decode(str, false); | ||
| return { prefix, words, bytes: fromWords(words) }; | ||
| } | ||
| return { encode, decode, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords }; | ||
| } | ||
| exports.bech32 = genBech32('bech32'); | ||
| exports.bech32m = genBech32('bech32m'); | ||
| exports.utf8 = { | ||
| encode: (data) => new TextDecoder().decode(data), | ||
| decode: (str) => new TextEncoder().encode(str), | ||
| }; | ||
| exports.hex = chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => { | ||
| if (typeof s !== 'string' || s.length % 2) | ||
| throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`); | ||
| return s.toLowerCase(); | ||
| })); | ||
| const CODERS = { | ||
| utf8: exports.utf8, hex: exports.hex, base16: exports.base16, base32: exports.base32, base64: exports.base64, base64url: exports.base64url, base58: exports.base58, base58xmr: exports.base58xmr | ||
| }; | ||
| const coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`; | ||
| const bytesToString = (type, bytes) => { | ||
| if (typeof type !== 'string' || !CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new TypeError('bytesToString() expects Uint8Array'); | ||
| return CODERS[type].encode(bytes); | ||
| }; | ||
| exports.bytesToString = bytesToString; | ||
| exports.str = exports.bytesToString; | ||
| const stringToBytes = (type, str) => { | ||
| if (!CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (typeof str !== 'string') | ||
| throw new TypeError('stringToBytes() expects string'); | ||
| return CODERS[type].decode(str); | ||
| }; | ||
| exports.stringToBytes = stringToBytes; | ||
| exports.bytes = exports.stringToBytes; | ||
| } (lib)); | ||
| return lib; | ||
| } | ||
| var bolt11; | ||
| var hasRequiredBolt11; | ||
| function requireBolt11 () { | ||
| if (hasRequiredBolt11) return bolt11; | ||
| hasRequiredBolt11 = 1; | ||
| const {bech32, hex, utf8} = requireLib(); | ||
| // defaults for encode; default timestamp is current time at call | ||
| const DEFAULTNETWORK = { | ||
| // default network is bitcoin | ||
| bech32: 'bc', | ||
| pubKeyHash: 0x00, | ||
| scriptHash: 0x05, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const TESTNETWORK = { | ||
| bech32: 'tb', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIGNETNETWORK = { | ||
| bech32: 'tbs', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const REGTESTNETWORK = { | ||
| bech32: 'bcrt', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIMNETWORK = { | ||
| bech32: 'sb', | ||
| pubKeyHash: 0x3f, | ||
| scriptHash: 0x7b, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const FEATUREBIT_ORDER = [ | ||
| 'option_data_loss_protect', | ||
| 'initial_routing_sync', | ||
| 'option_upfront_shutdown_script', | ||
| 'gossip_queries', | ||
| 'var_onion_optin', | ||
| 'gossip_queries_ex', | ||
| 'option_static_remotekey', | ||
| 'payment_secret', | ||
| 'basic_mpp', | ||
| 'option_support_large_channel' | ||
| ]; | ||
| const DIVISORS = { | ||
| m: BigInt(1e3), | ||
| u: BigInt(1e6), | ||
| n: BigInt(1e9), | ||
| p: BigInt(1e12) | ||
| }; | ||
| const MAX_MILLISATS = BigInt('2100000000000000000'); | ||
| const MILLISATS_PER_BTC = BigInt(1e11); | ||
| const TAGCODES = { | ||
| payment_hash: 1, | ||
| payment_secret: 16, | ||
| description: 13, | ||
| payee: 19, | ||
| description_hash: 23, // commit to longer descriptions (used by lnurl-pay) | ||
| expiry: 6, // default: 3600 (1 hour) | ||
| min_final_cltv_expiry: 24, // default: 9 | ||
| fallback_address: 9, | ||
| route_hint: 3, // for extra routing info (private etc.) | ||
| feature_bits: 5, | ||
| metadata: 27 | ||
| }; | ||
| // reverse the keys and values of TAGCODES and insert into TAGNAMES | ||
| const TAGNAMES = {}; | ||
| for (let i = 0, keys = Object.keys(TAGCODES); i < keys.length; i++) { | ||
| const currentName = keys[i]; | ||
| const currentCode = TAGCODES[keys[i]].toString(); | ||
| TAGNAMES[currentCode] = currentName; | ||
| } | ||
| const TAGPARSERS = { | ||
| 1: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 16: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 13: words => utf8.encode(bech32.fromWordsUnsafe(words)), // string variable length | ||
| 19: words => hex.encode(bech32.fromWordsUnsafe(words)), // 264 bits | ||
| 23: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 27: words => hex.encode(bech32.fromWordsUnsafe(words)), // variable | ||
| 6: wordsToIntBE, // default: 3600 (1 hour) | ||
| 24: wordsToIntBE, // default: 9 | ||
| 3: routingInfoParser, // for extra routing info (private etc.) | ||
| 5: featureBitsParser // keep feature bits as array of 5 bit words | ||
| }; | ||
| function getUnknownParser(tagCode) { | ||
| return words => ({ | ||
| tagCode: parseInt(tagCode), | ||
| words: bech32.encode('unknown', words, Number.MAX_SAFE_INTEGER) | ||
| }) | ||
| } | ||
| function wordsToIntBE(words) { | ||
| return words.reverse().reduce((total, item, index) => { | ||
| return total + item * Math.pow(32, index) | ||
| }, 0) | ||
| } | ||
| // first convert from words to buffer, trimming padding where necessary | ||
| // parse in 51 byte chunks. See encoder for details. | ||
| function routingInfoParser(words) { | ||
| const routes = []; | ||
| let pubkey, | ||
| shortChannelId, | ||
| feeBaseMSats, | ||
| feeProportionalMillionths, | ||
| cltvExpiryDelta; | ||
| let routesBuffer = bech32.fromWordsUnsafe(words); | ||
| while (routesBuffer.length > 0) { | ||
| pubkey = hex.encode(routesBuffer.slice(0, 33)); // 33 bytes | ||
| shortChannelId = hex.encode(routesBuffer.slice(33, 41)); // 8 bytes | ||
| feeBaseMSats = parseInt(hex.encode(routesBuffer.slice(41, 45)), 16); // 4 bytes | ||
| feeProportionalMillionths = parseInt( | ||
| hex.encode(routesBuffer.slice(45, 49)), | ||
| 16 | ||
| ); // 4 bytes | ||
| cltvExpiryDelta = parseInt(hex.encode(routesBuffer.slice(49, 51)), 16); // 2 bytes | ||
| routesBuffer = routesBuffer.slice(51); | ||
| routes.push({ | ||
| pubkey, | ||
| short_channel_id: shortChannelId, | ||
| fee_base_msat: feeBaseMSats, | ||
| fee_proportional_millionths: feeProportionalMillionths, | ||
| cltv_expiry_delta: cltvExpiryDelta | ||
| }); | ||
| } | ||
| return routes | ||
| } | ||
| function featureBitsParser(words) { | ||
| const bools = words | ||
| .slice() | ||
| .reverse() | ||
| .map(word => [ | ||
| !!(word & 0b1), | ||
| !!(word & 0b10), | ||
| !!(word & 0b100), | ||
| !!(word & 0b1000), | ||
| !!(word & 0b10000) | ||
| ]) | ||
| .reduce((finalArr, itemArr) => finalArr.concat(itemArr), []); | ||
| while (bools.length < FEATUREBIT_ORDER.length * 2) { | ||
| bools.push(false); | ||
| } | ||
| const featureBits = {}; | ||
| FEATUREBIT_ORDER.forEach((featureName, index) => { | ||
| let status; | ||
| if (bools[index * 2]) { | ||
| status = 'required'; | ||
| } else if (bools[index * 2 + 1]) { | ||
| status = 'supported'; | ||
| } else { | ||
| status = 'unsupported'; | ||
| } | ||
| featureBits[featureName] = status; | ||
| }); | ||
| const extraBits = bools.slice(FEATUREBIT_ORDER.length * 2); | ||
| featureBits.extra_bits = { | ||
| start_bit: FEATUREBIT_ORDER.length * 2, | ||
| bits: extraBits, | ||
| has_required: extraBits.reduce( | ||
| (result, bit, index) => | ||
| index % 2 !== 0 ? result || false : result || bit, | ||
| false | ||
| ) | ||
| }; | ||
| return featureBits | ||
| } | ||
| function hrpToMillisat(hrpString, outputString) { | ||
| let divisor, value; | ||
| if (hrpString.slice(-1).match(/^[munp]$/)) { | ||
| divisor = hrpString.slice(-1); | ||
| value = hrpString.slice(0, -1); | ||
| } else if (hrpString.slice(-1).match(/^[^munp0-9]$/)) { | ||
| throw new Error('Not a valid multiplier for the amount') | ||
| } else { | ||
| value = hrpString; | ||
| } | ||
| if (!value.match(/^\d+$/)) | ||
| throw new Error('Not a valid human readable amount') | ||
| const valueBN = BigInt(value); | ||
| const millisatoshisBN = divisor | ||
| ? (valueBN * MILLISATS_PER_BTC) / DIVISORS[divisor] | ||
| : valueBN * MILLISATS_PER_BTC; | ||
| if ( | ||
| (divisor === 'p' && !(valueBN % BigInt(10) === BigInt(0))) || | ||
| millisatoshisBN > MAX_MILLISATS | ||
| ) { | ||
| throw new Error('Amount is outside of valid range') | ||
| } | ||
| return outputString ? millisatoshisBN.toString() : millisatoshisBN | ||
| } | ||
| // decode will only have extra comments that aren't covered in encode comments. | ||
| // also if anything is hard to read I'll comment. | ||
| function decode(paymentRequest, network) { | ||
| if (typeof paymentRequest !== 'string') | ||
| throw new Error('Lightning Payment Request must be string') | ||
| if (paymentRequest.slice(0, 2).toLowerCase() !== 'ln') | ||
| throw new Error('Not a proper lightning payment request') | ||
| const sections = []; | ||
| const decoded = bech32.decode(paymentRequest, Number.MAX_SAFE_INTEGER); | ||
| paymentRequest = paymentRequest.toLowerCase(); | ||
| const prefix = decoded.prefix; | ||
| let words = decoded.words; | ||
| let letters = paymentRequest.slice(prefix.length + 1); | ||
| let sigWords = words.slice(-104); | ||
| words = words.slice(0, -104); | ||
| // Without reverse lookups, can't say that the multipier at the end must | ||
| // have a number before it, so instead we parse, and if the second group | ||
| // doesn't have anything, there's a good chance the last letter of the | ||
| // coin type got captured by the third group, so just re-regex without | ||
| // the number. | ||
| let prefixMatches = prefix.match(/^ln(\S+?)(\d*)([a-zA-Z]?)$/); | ||
| if (prefixMatches && !prefixMatches[2]) | ||
| prefixMatches = prefix.match(/^ln(\S+)$/); | ||
| if (!prefixMatches) { | ||
| throw new Error('Not a proper lightning payment request') | ||
| } | ||
| // "ln" section | ||
| sections.push({ | ||
| name: 'lightning_network', | ||
| letters: 'ln' | ||
| }); | ||
| // "bc" section | ||
| const bech32Prefix = prefixMatches[1]; | ||
| let coinNetwork; | ||
| if (!network) { | ||
| switch (bech32Prefix) { | ||
| case DEFAULTNETWORK.bech32: | ||
| coinNetwork = DEFAULTNETWORK; | ||
| break | ||
| case TESTNETWORK.bech32: | ||
| coinNetwork = TESTNETWORK; | ||
| break | ||
| case SIGNETNETWORK.bech32: | ||
| coinNetwork = SIGNETNETWORK; | ||
| break | ||
| case REGTESTNETWORK.bech32: | ||
| coinNetwork = REGTESTNETWORK; | ||
| break | ||
| case SIMNETWORK.bech32: | ||
| coinNetwork = SIMNETWORK; | ||
| break | ||
| } | ||
| } else { | ||
| if ( | ||
| network.bech32 === undefined || | ||
| network.pubKeyHash === undefined || | ||
| network.scriptHash === undefined || | ||
| !Array.isArray(network.validWitnessVersions) | ||
| ) | ||
| throw new Error('Invalid network') | ||
| coinNetwork = network; | ||
| } | ||
| if (!coinNetwork || coinNetwork.bech32 !== bech32Prefix) { | ||
| throw new Error('Unknown coin bech32 prefix') | ||
| } | ||
| sections.push({ | ||
| name: 'coin_network', | ||
| letters: bech32Prefix, | ||
| value: coinNetwork | ||
| }); | ||
| // amount section | ||
| const value = prefixMatches[2]; | ||
| let millisatoshis; | ||
| if (value) { | ||
| const divisor = prefixMatches[3]; | ||
| millisatoshis = hrpToMillisat(value + divisor, true); | ||
| sections.push({ | ||
| name: 'amount', | ||
| letters: prefixMatches[2] + prefixMatches[3], | ||
| value: millisatoshis | ||
| }); | ||
| } else { | ||
| millisatoshis = null; | ||
| } | ||
| // "1" separator | ||
| sections.push({ | ||
| name: 'separator', | ||
| letters: '1' | ||
| }); | ||
| // timestamp | ||
| const timestamp = wordsToIntBE(words.slice(0, 7)); | ||
| words = words.slice(7); // trim off the left 7 words | ||
| sections.push({ | ||
| name: 'timestamp', | ||
| letters: letters.slice(0, 7), | ||
| value: timestamp | ||
| }); | ||
| letters = letters.slice(7); | ||
| let tagName, parser, tagLength, tagWords; | ||
| // we have no tag count to go on, so just keep hacking off words | ||
| // until we have none. | ||
| while (words.length > 0) { | ||
| const tagCode = words[0].toString(); | ||
| tagName = TAGNAMES[tagCode] || 'unknown_tag'; | ||
| parser = TAGPARSERS[tagCode] || getUnknownParser(tagCode); | ||
| words = words.slice(1); | ||
| tagLength = wordsToIntBE(words.slice(0, 2)); | ||
| words = words.slice(2); | ||
| tagWords = words.slice(0, tagLength); | ||
| words = words.slice(tagLength); | ||
| sections.push({ | ||
| name: tagName, | ||
| tag: letters[0], | ||
| letters: letters.slice(0, 1 + 2 + tagLength), | ||
| value: parser(tagWords) // see: parsers for more comments | ||
| }); | ||
| letters = letters.slice(1 + 2 + tagLength); | ||
| } | ||
| // signature | ||
| sections.push({ | ||
| name: 'signature', | ||
| letters: letters.slice(0, 104), | ||
| value: hex.encode(bech32.fromWordsUnsafe(sigWords)) | ||
| }); | ||
| letters = letters.slice(104); | ||
| // checksum | ||
| sections.push({ | ||
| name: 'checksum', | ||
| letters: letters | ||
| }); | ||
| let result = { | ||
| paymentRequest, | ||
| sections, | ||
| get expiry() { | ||
| let exp = sections.find(s => s.name === 'expiry'); | ||
| if (exp) return getValue('timestamp') + exp.value | ||
| }, | ||
| get route_hints() { | ||
| return sections.filter(s => s.name === 'route_hint').map(s => s.value) | ||
| } | ||
| }; | ||
| for (let name in TAGCODES) { | ||
| if (name === 'route_hint') { | ||
| // route hints can be multiple, so this won't work for them | ||
| continue | ||
| } | ||
| Object.defineProperty(result, name, { | ||
| get() { | ||
| return getValue(name) | ||
| } | ||
| }); | ||
| } | ||
| return result | ||
| function getValue(name) { | ||
| let section = sections.find(s => s.name === name); | ||
| return section ? section.value : undefined | ||
| } | ||
| } | ||
| bolt11 = { | ||
| decode, | ||
| hrpToMillisat | ||
| }; | ||
| return bolt11; | ||
| } | ||
| var bolt11Exports = requireBolt11(); | ||
| // from https://stackoverflow.com/a/50868276 | ||
| const fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))); | ||
| const decodeInvoice = (paymentRequest) => { | ||
| if (!paymentRequest) | ||
| return null; | ||
| try { | ||
| const decoded = bolt11Exports.decode(paymentRequest); | ||
| if (!decoded || !decoded.sections) | ||
| return null; | ||
| const hashTag = decoded.sections.find((value) => value.name === "payment_hash"); | ||
| if (hashTag?.name !== "payment_hash" || !hashTag.value) | ||
| return null; | ||
| const paymentHash = hashTag.value; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
| } | ||
| const timestampTag = decoded.sections.find((value) => value.name === "timestamp"); | ||
| if (timestampTag?.name !== "timestamp" || !timestampTag.value) | ||
| return null; | ||
| const timestamp = timestampTag.value; | ||
| let expiry; | ||
| const expiryTag = decoded.sections.find((value) => value.name === "expiry"); | ||
| if (expiryTag?.name === "expiry") { | ||
| expiry = expiryTag.value; | ||
| } | ||
| const descriptionTag = decoded.sections.find((value) => value.name === "description"); | ||
| const description = descriptionTag?.name === "description" | ||
| ? descriptionTag?.value | ||
| : undefined; | ||
| return { | ||
| paymentHash, | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
| expiry, | ||
| description, | ||
| }; | ||
| } | ||
| catch { | ||
| return null; | ||
| } | ||
| }; | ||
| class Invoice { | ||
| constructor(args) { | ||
| this.paymentRequest = args.pr; | ||
| if (!this.paymentRequest) { | ||
| throw new Error("Invalid payment request"); | ||
| } | ||
| const decodedInvoice = decodeInvoice(this.paymentRequest); | ||
| if (!decodedInvoice) { | ||
| throw new Error("Failed to decode payment request"); | ||
| } | ||
| this.paymentHash = decodedInvoice.paymentHash; | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
| this.expiry = decodedInvoice.expiry; | ||
| this.createdDate = new Date(this.timestamp * 1000); | ||
| this.expiryDate = this.expiry | ||
| ? new Date((this.timestamp + this.expiry) * 1000) | ||
| : undefined; | ||
| this.description = decodedInvoice.description ?? null; | ||
| this.verify = args.verify ?? null; | ||
| this.preimage = args.preimage ?? null; | ||
| this.successAction = args.successAction ?? null; | ||
| } | ||
| async isPaid() { | ||
| if (this.preimage) | ||
| return this.validatePreimage(this.preimage); | ||
| else if (this.verify) { | ||
| return await this.verifyPayment(); | ||
| } | ||
| else { | ||
| throw new Error("Could not verify payment"); | ||
| } | ||
| } | ||
| validatePreimage(preimage) { | ||
| if (!preimage || !this.paymentHash) | ||
| return false; | ||
| try { | ||
| const preimageHash = bytesToHex(sha256(fromHexString(preimage))); | ||
| return this.paymentHash === preimageHash; | ||
| } | ||
| catch { | ||
| return false; | ||
| } | ||
| } | ||
| async verifyPayment() { | ||
| try { | ||
| if (!this.verify) { | ||
| throw new Error("LNURL verify not available"); | ||
| } | ||
| const response = await fetch(this.verify); | ||
| if (!response.ok) { | ||
| throw new Error(`Verification request failed: ${response.status} ${response.statusText}`); | ||
| } | ||
| const json = await response.json(); | ||
| if (json.preimage) { | ||
| this.preimage = json.preimage; | ||
| } | ||
| return json.settled; | ||
| } | ||
| catch (error) { | ||
| console.error("Failed to check LNURL-verify", error); | ||
| return false; | ||
| } | ||
| } | ||
| hasExpired() { | ||
| const { expiryDate } = this; | ||
| if (expiryDate) { | ||
| return expiryDate.getTime() < Date.now(); | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| function createGuardedWallet(wallet, maxAmountSats) { | ||
| return { | ||
| payInvoice: async (args) => { | ||
| const invoice = new Invoice({ pr: args.invoice }); | ||
| if (invoice.satoshi > maxAmountSats) { | ||
| throw new Error(`Invoice amount (${invoice.satoshi} sats) exceeds maxAmount (${maxAmountSats} sats)`); | ||
| } | ||
| return wallet.payInvoice(args); | ||
| }, | ||
| }; | ||
| } | ||
| const parseL402 = (input) => { | ||
| // Remove the L402 and LSAT identifiers | ||
| const string = input.replace("L402", "").replace("LSAT", "").trim(); | ||
| // Initialize an object to store the key-value pairs | ||
| const keyValuePairs = {}; | ||
| // Regular expression to match key and (quoted or unquoted) value | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g; | ||
| let match; | ||
| // Use regex to find all key-value pairs | ||
| while ((match = regex.exec(string)) !== null) { | ||
| // Key is always match[1] | ||
| // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted) | ||
| keyValuePairs[match[1]] = match[3] || match[4] || match[5]; | ||
| } | ||
| return keyValuePairs; | ||
| }; | ||
| const handleL402Payment = async (l402Header, url, fetchArgs, headers, wallet) => { | ||
| const details = parseL402(l402Header); | ||
| const token = details.token || details.macaroon; | ||
| const invoice = details.invoice; | ||
| if (!token) { | ||
| throw new Error("L402: missing token/macaroon in WWW-Authenticate header"); | ||
| } | ||
| if (!invoice) { | ||
| throw new Error("L402: missing invoice in WWW-Authenticate header"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| headers.set("Authorization", `L402 ${token}:${invResp.preimage}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithL402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("www-authenticate"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleL402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| const buildX402PaymentSignature = (scheme, network, invoice, requirements) => { | ||
| const json = JSON.stringify({ | ||
| x402Version: 2, | ||
| scheme, | ||
| network, | ||
| payload: { invoice }, | ||
| accepted: requirements, | ||
| }); | ||
| // btoa only handles latin1; encode via UTF-8 to be safe | ||
| return btoa(unescape(encodeURIComponent(json))); | ||
| }; | ||
| const handleX402Payment = async (x402Header, url, fetchArgs, headers, wallet) => { | ||
| let parsed; | ||
| try { | ||
| parsed = JSON.parse(decodeURIComponent(escape(atob(x402Header)))); | ||
| } | ||
| catch (_) { | ||
| throw new Error("x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)"); | ||
| } | ||
| if (!Array.isArray(parsed.accepts) || parsed.accepts.length === 0) { | ||
| throw new Error("x402: PAYMENT-REQUIRED header contains no payment options"); | ||
| } | ||
| const requirements = parsed.accepts.find((e) => { | ||
| return e.extra?.paymentMethod === "lightning"; | ||
| }); | ||
| if (!requirements) { | ||
| throw new Error("x402: unsupported x402 network, only Bitcoin lightning network is supported."); | ||
| } | ||
| if (!requirements.extra?.invoice) { | ||
| throw new Error("x402: payment requirements missing lightning invoice"); | ||
| } | ||
| const invoice = new Invoice({ pr: requirements.extra.invoice }); | ||
| if (invoice.amountRaw != requirements.amount) { | ||
| throw new Error(`Invalid invoice amount: ${invoice.amountRaw}. expected ${requirements.amount}`); | ||
| } | ||
| await wallet.payInvoice({ invoice: invoice.paymentRequest }); | ||
| headers.set("payment-signature", buildX402PaymentSignature(requirements.scheme, requirements.network, invoice.paymentRequest, requirements)); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithX402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("PAYMENT-REQUIRED"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleX402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| /** | ||
| * Parse a `WWW-Authenticate: Payment …` header produced by a | ||
| * draft-lightning-charge-00 server. Expected format: | ||
| * | ||
| * Payment id="<id>", realm="<realm>", method="lightning", | ||
| * intent="charge", request="<base64url>" [, expires="<rfc3339>"] | ||
| * | ||
| * Returns null when the header is not a Payment lightning/charge challenge. | ||
| */ | ||
| const parseMppChallenge = (header) => { | ||
| if (!header.trimStart().toLowerCase().startsWith("payment")) { | ||
| return null; | ||
| } | ||
| const rest = header | ||
| .slice(header.toLowerCase().indexOf("payment") + "payment".length) | ||
| .trim(); | ||
| const result = {}; | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,\s]*))/g; | ||
| let match; | ||
| while ((match = regex.exec(rest)) !== null) { | ||
| result[match[1]] = match[3] ?? match[4] ?? match[5] ?? ""; | ||
| } | ||
| if (result.method !== "lightning" || | ||
| result.intent !== "charge" || | ||
| !result.id || | ||
| !result.realm || | ||
| !result.request) { | ||
| return null; | ||
| } | ||
| return { | ||
| id: result.id, | ||
| realm: result.realm, | ||
| method: result.method, | ||
| intent: result.intent, | ||
| request: result.request, | ||
| ...(result.expires ? { expires: result.expires } : {}), | ||
| }; | ||
| }; | ||
| /** Decode a base64url string (no padding required) to a UTF-8 string. */ | ||
| const decodeBase64url = (input) => { | ||
| const base64 = input.replace(/-/g, "+").replace(/_/g, "/"); | ||
| const binary = atob(base64); | ||
| const bytes = new Uint8Array(binary.length); | ||
| for (let i = 0; i < binary.length; i++) { | ||
| bytes[i] = binary.charCodeAt(i); | ||
| } | ||
| return new TextDecoder("utf-8").decode(bytes); | ||
| }; | ||
| /** Encode a UTF-8 string to base64url without padding. */ | ||
| const encodeBase64url = (input) => { | ||
| const bytes = new TextEncoder().encode(input); | ||
| let binary = ""; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| binary += String.fromCharCode(bytes[i]); | ||
| } | ||
| return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); | ||
| }; | ||
| /** | ||
| * JSON Canonicalization Scheme (RFC 8785). | ||
| * Produces compact JSON with object keys sorted lexicographically. | ||
| */ | ||
| const jcs = (value) => { | ||
| if (value === null || typeof value !== "object") { | ||
| return JSON.stringify(value); | ||
| } | ||
| if (Array.isArray(value)) { | ||
| return "[" + value.map(jcs).join(",") + "]"; | ||
| } | ||
| const keys = Object.keys(value).sort(); | ||
| return ("{" + | ||
| keys | ||
| .map((k) => JSON.stringify(k) + ":" + jcs(value[k])) | ||
| .join(",") + | ||
| "}"); | ||
| }; | ||
| /** | ||
| * Build the base64url-encoded credential token for the `Authorization` header. | ||
| * | ||
| * Per the spec the credential is a JCS-serialised JSON object that echoes all | ||
| * challenge auth-params (id, realm, method, intent, request, expires) and | ||
| * carries the HTLC preimage that proves payment: | ||
| * | ||
| * { | ||
| * "challenge": { "id": "…", "intent": "charge", | ||
| * "method": "lightning", "realm": "…", "request": "…" }, | ||
| * "payload": { "preimage": "<64-char lowercase hex>" } | ||
| * } | ||
| * | ||
| * Keys are sorted lexicographically at every level per JCS. | ||
| */ | ||
| const buildMppCredential = (challenge, preimage, source) => { | ||
| const challengeEcho = { | ||
| id: challenge.id, | ||
| intent: challenge.intent, | ||
| method: challenge.method, | ||
| realm: challenge.realm, | ||
| request: challenge.request, | ||
| }; | ||
| if (challenge.expires) { | ||
| challengeEcho.expires = challenge.expires; | ||
| } | ||
| const credential = { | ||
| challenge: challengeEcho, | ||
| payload: { preimage }, | ||
| }; | ||
| return encodeBase64url(jcs(credential)); | ||
| }; | ||
| /** | ||
| * Handle a `WWW-Authenticate: Payment …` challenge produced by a | ||
| * draft-lightning-charge-00 server. | ||
| * | ||
| * Flow: | ||
| * 1. Parse the challenge from the header. | ||
| * 2. Decode the `request` auth-param to find the BOLT11 invoice. | ||
| * 3. Pay the invoice via the wallet; receive the HTLC preimage. | ||
| * 4. Build the `Authorization: Payment <credential>` header. | ||
| * 5. Retry the original request with the credential. | ||
| */ | ||
| const handleMppChargePayment = async (wwwAuthHeader, url, fetchArgs, headers, wallet) => { | ||
| const challenge = parseMppChallenge(wwwAuthHeader); | ||
| if (!challenge) { | ||
| throw new Error("mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)"); | ||
| } | ||
| let request; | ||
| try { | ||
| request = JSON.parse(decodeBase64url(challenge.request)); | ||
| } | ||
| catch (_) { | ||
| throw new Error("mpp: invalid request auth-param (not valid base64url-encoded JSON)"); | ||
| } | ||
| const invoice = request.methodDetails?.invoice; | ||
| if (!invoice) { | ||
| throw new Error("mpp: missing invoice in charge request"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| // Per spec: Authorization: Payment <base64url-token> (single token, no wrapper) | ||
| const credential = buildMppCredential(challenge, invResp.preimage); | ||
| headers.set("Authorization", `Payment ${credential}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| const fetchWithMpp = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const wwwAuthHeader = initResp.headers.get("www-authenticate"); | ||
| if (!wwwAuthHeader || | ||
| !wwwAuthHeader.trimStart().toLowerCase().startsWith("payment")) { | ||
| return initResp; | ||
| } | ||
| return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| }; | ||
| const fetch402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.maxAmount | ||
| ? createGuardedWallet(options.wallet, options.maxAmount) | ||
| : options.wallet; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const wwwAuthHeader = initResp.headers.get("www-authenticate"); | ||
| if (wwwAuthHeader) { | ||
| const trimmed = wwwAuthHeader.trimStart().toLowerCase(); | ||
| if (trimmed.startsWith("payment")) { | ||
| return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| } | ||
| if (trimmed.startsWith("l402") || trimmed.startsWith("lsat")) { | ||
| return handleL402Payment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| } | ||
| throw new Error(`fetch402: unsupported WWW-Authenticate scheme: ${wwwAuthHeader}`); | ||
| } | ||
| const x402Header = initResp.headers.get("PAYMENT-REQUIRED"); | ||
| if (x402Header) { | ||
| return handleX402Payment(x402Header, url, fetchArgs, headers, wallet); | ||
| } | ||
| return initResp; | ||
| }; | ||
| exports.createGuardedWallet = createGuardedWallet; | ||
| exports.fetch402 = fetch402; | ||
| exports.fetchWithL402 = fetchWithL402; | ||
| exports.fetchWithMpp = fetchWithMpp; | ||
| exports.fetchWithX402 = fetchWithX402; | ||
| //# sourceMappingURL=402.cjs.map |
Sorry, the diff of this file is too big to display
| 'use strict'; | ||
| const parseL402 = (input) => { | ||
| // Remove the L402 and LSAT identifiers | ||
| const string = input.replace("L402", "").replace("LSAT", "").trim(); | ||
| // Initialize an object to store the key-value pairs | ||
| const keyValuePairs = {}; | ||
| // Regular expression to match key and (quoted or unquoted) value | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g; | ||
| let match; | ||
| // Use regex to find all key-value pairs | ||
| while ((match = regex.exec(string)) !== null) { | ||
| // Key is always match[1] | ||
| // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted) | ||
| keyValuePairs[match[1]] = match[3] || match[4] || match[5]; | ||
| } | ||
| return keyValuePairs; | ||
| }; | ||
| const handleL402Payment = async (l402Header, url, fetchArgs, headers, wallet) => { | ||
| const details = parseL402(l402Header); | ||
| const token = details.token || details.macaroon; | ||
| const invoice = details.invoice; | ||
| if (!token) { | ||
| throw new Error("L402: missing token/macaroon in WWW-Authenticate header"); | ||
| } | ||
| if (!invoice) { | ||
| throw new Error("L402: missing invoice in WWW-Authenticate header"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| headers.set("Authorization", `L402 ${token}:${invResp.preimage}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithL402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("www-authenticate"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleL402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| exports.fetchWithL402 = fetchWithL402; | ||
| //# sourceMappingURL=l402.cjs.map |
| {"version":3,"file":"l402.cjs","sources":["../../../src/402/l402/utils.ts","../../../src/402/l402/l402.ts"],"sourcesContent":["export const parseL402 = (input: string): Record<string, string> => {\n // Remove the L402 and LSAT identifiers\n const string = input.replace(\"L402\", \"\").replace(\"LSAT\", \"\").trim();\n\n // Initialize an object to store the key-value pairs\n const keyValuePairs = {};\n\n // Regular expression to match key and (quoted or unquoted) value\n const regex = /(\\w+)=(\"([^\"]*)\"|'([^']*)'|([^,]*))/g;\n let match;\n\n // Use regex to find all key-value pairs\n while ((match = regex.exec(string)) !== null) {\n // Key is always match[1]\n // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted)\n keyValuePairs[match[1]] = match[3] || match[4] || match[5];\n }\n\n return keyValuePairs;\n};\n\nexport const makeL402AuthenticateHeader = (args: {\n macaroon?: string;\n token?: string;\n invoice: string;\n}) => {\n if (args.macaroon) {\n return `L402 version=\"0\" macaroon=\"${args.macaroon}\", invoice=\"${args.invoice}\"`;\n } else {\n return `L402 version=\"0\" token=\"${args.token}\", invoice=\"${args.invoice}\"`;\n }\n};\n","import { Wallet } from \"../utils\";\nimport { parseL402 } from \"./utils\";\n\nexport const handleL402Payment = async (\n l402Header: string,\n url: string,\n fetchArgs: RequestInit,\n headers: Headers,\n wallet: Wallet,\n): Promise<Response> => {\n const details = parseL402(l402Header);\n const token = details.token || details.macaroon;\n const invoice = details.invoice;\n\n if (!token) {\n throw new Error(\"L402: missing token/macaroon in WWW-Authenticate header\");\n }\n if (!invoice) {\n throw new Error(\"L402: missing invoice in WWW-Authenticate header\");\n }\n\n const invResp = await wallet.payInvoice({ invoice });\n headers.set(\"Authorization\", `L402 ${token}:${invResp.preimage}`);\n return fetch(url, fetchArgs);\n};\n\nexport const fetchWithL402 = async (\n url: string,\n fetchArgs: RequestInit,\n options: {\n wallet: Wallet;\n },\n) => {\n const wallet = options.wallet;\n if (!wallet) {\n throw new Error(\"wallet is missing\");\n }\n if (!fetchArgs) {\n fetchArgs = {};\n }\n fetchArgs.cache = \"no-store\";\n fetchArgs.mode = \"cors\";\n const headers = new Headers(fetchArgs.headers ?? undefined);\n fetchArgs.headers = headers;\n\n const initResp = await fetch(url, fetchArgs);\n const header = initResp.headers.get(\"www-authenticate\");\n if (!header) {\n return initResp;\n }\n\n return handleL402Payment(header, url, fetchArgs, headers, wallet);\n};\n"],"names":[],"mappings":";;AAAO,MAAM,SAAS,GAAG,CAAC,KAAa,KAA4B;;IAEjE,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE;;IAGnE,MAAM,aAAa,GAAG,EAAE;;IAGxB,MAAM,KAAK,GAAG,sCAAsC;AACpD,IAAA,IAAI,KAAK;;AAGT,IAAA,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE;;;QAG5C,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;IAC5D;AAEA,IAAA,OAAO,aAAa;AACtB,CAAC;;AChBM,MAAM,iBAAiB,GAAG,OAC/B,UAAkB,EAClB,GAAW,EACX,SAAsB,EACtB,OAAgB,EAChB,MAAc,KACO;AACrB,IAAA,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC;IACrC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ;AAC/C,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO;IAE/B,IAAI,CAAC,KAAK,EAAE;AACV,QAAA,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC;IAC5E;IACA,IAAI,CAAC,OAAO,EAAE;AACZ,QAAA,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC;IACrE;IAEA,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,CAAC;AACpD,IAAA,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,EAAI,OAAO,CAAC,QAAQ,CAAA,CAAE,CAAC;AACjE,IAAA,OAAO,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;AAC9B,CAAC;AAEM,MAAM,aAAa,GAAG,OAC3B,GAAW,EACX,SAAsB,EACtB,OAEC,KACC;AACF,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM;IAC7B,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IACtC;IACA,IAAI,CAAC,SAAS,EAAE;QACd,SAAS,GAAG,EAAE;IAChB;AACA,IAAA,SAAS,CAAC,KAAK,GAAG,UAAU;AAC5B,IAAA,SAAS,CAAC,IAAI,GAAG,MAAM;IACvB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC;AAC3D,IAAA,SAAS,CAAC,OAAO,GAAG,OAAO;IAE3B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IACvD,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,OAAO,QAAQ;IACjB;AAEA,IAAA,OAAO,iBAAiB,CAAC,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC;AACnE;;;;"} |
| 'use strict'; | ||
| /** | ||
| * Parse a `WWW-Authenticate: Payment …` header produced by a | ||
| * draft-lightning-charge-00 server. Expected format: | ||
| * | ||
| * Payment id="<id>", realm="<realm>", method="lightning", | ||
| * intent="charge", request="<base64url>" [, expires="<rfc3339>"] | ||
| * | ||
| * Returns null when the header is not a Payment lightning/charge challenge. | ||
| */ | ||
| const parseMppChallenge = (header) => { | ||
| if (!header.trimStart().toLowerCase().startsWith("payment")) { | ||
| return null; | ||
| } | ||
| const rest = header | ||
| .slice(header.toLowerCase().indexOf("payment") + "payment".length) | ||
| .trim(); | ||
| const result = {}; | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,\s]*))/g; | ||
| let match; | ||
| while ((match = regex.exec(rest)) !== null) { | ||
| result[match[1]] = match[3] ?? match[4] ?? match[5] ?? ""; | ||
| } | ||
| if (result.method !== "lightning" || | ||
| result.intent !== "charge" || | ||
| !result.id || | ||
| !result.realm || | ||
| !result.request) { | ||
| return null; | ||
| } | ||
| return { | ||
| id: result.id, | ||
| realm: result.realm, | ||
| method: result.method, | ||
| intent: result.intent, | ||
| request: result.request, | ||
| ...(result.expires ? { expires: result.expires } : {}), | ||
| }; | ||
| }; | ||
| /** Decode a base64url string (no padding required) to a UTF-8 string. */ | ||
| const decodeBase64url = (input) => { | ||
| const base64 = input.replace(/-/g, "+").replace(/_/g, "/"); | ||
| const binary = atob(base64); | ||
| const bytes = new Uint8Array(binary.length); | ||
| for (let i = 0; i < binary.length; i++) { | ||
| bytes[i] = binary.charCodeAt(i); | ||
| } | ||
| return new TextDecoder("utf-8").decode(bytes); | ||
| }; | ||
| /** Encode a UTF-8 string to base64url without padding. */ | ||
| const encodeBase64url = (input) => { | ||
| const bytes = new TextEncoder().encode(input); | ||
| let binary = ""; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| binary += String.fromCharCode(bytes[i]); | ||
| } | ||
| return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); | ||
| }; | ||
| /** | ||
| * JSON Canonicalization Scheme (RFC 8785). | ||
| * Produces compact JSON with object keys sorted lexicographically. | ||
| */ | ||
| const jcs = (value) => { | ||
| if (value === null || typeof value !== "object") { | ||
| return JSON.stringify(value); | ||
| } | ||
| if (Array.isArray(value)) { | ||
| return "[" + value.map(jcs).join(",") + "]"; | ||
| } | ||
| const keys = Object.keys(value).sort(); | ||
| return ("{" + | ||
| keys | ||
| .map((k) => JSON.stringify(k) + ":" + jcs(value[k])) | ||
| .join(",") + | ||
| "}"); | ||
| }; | ||
| /** | ||
| * Build the base64url-encoded credential token for the `Authorization` header. | ||
| * | ||
| * Per the spec the credential is a JCS-serialised JSON object that echoes all | ||
| * challenge auth-params (id, realm, method, intent, request, expires) and | ||
| * carries the HTLC preimage that proves payment: | ||
| * | ||
| * { | ||
| * "challenge": { "id": "…", "intent": "charge", | ||
| * "method": "lightning", "realm": "…", "request": "…" }, | ||
| * "payload": { "preimage": "<64-char lowercase hex>" } | ||
| * } | ||
| * | ||
| * Keys are sorted lexicographically at every level per JCS. | ||
| */ | ||
| const buildMppCredential = (challenge, preimage, source) => { | ||
| const challengeEcho = { | ||
| id: challenge.id, | ||
| intent: challenge.intent, | ||
| method: challenge.method, | ||
| realm: challenge.realm, | ||
| request: challenge.request, | ||
| }; | ||
| if (challenge.expires) { | ||
| challengeEcho.expires = challenge.expires; | ||
| } | ||
| const credential = { | ||
| challenge: challengeEcho, | ||
| payload: { preimage }, | ||
| }; | ||
| return encodeBase64url(jcs(credential)); | ||
| }; | ||
| /** | ||
| * Handle a `WWW-Authenticate: Payment …` challenge produced by a | ||
| * draft-lightning-charge-00 server. | ||
| * | ||
| * Flow: | ||
| * 1. Parse the challenge from the header. | ||
| * 2. Decode the `request` auth-param to find the BOLT11 invoice. | ||
| * 3. Pay the invoice via the wallet; receive the HTLC preimage. | ||
| * 4. Build the `Authorization: Payment <credential>` header. | ||
| * 5. Retry the original request with the credential. | ||
| */ | ||
| const handleMppChargePayment = async (wwwAuthHeader, url, fetchArgs, headers, wallet) => { | ||
| const challenge = parseMppChallenge(wwwAuthHeader); | ||
| if (!challenge) { | ||
| throw new Error("mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)"); | ||
| } | ||
| let request; | ||
| try { | ||
| request = JSON.parse(decodeBase64url(challenge.request)); | ||
| } | ||
| catch (_) { | ||
| throw new Error("mpp: invalid request auth-param (not valid base64url-encoded JSON)"); | ||
| } | ||
| const invoice = request.methodDetails?.invoice; | ||
| if (!invoice) { | ||
| throw new Error("mpp: missing invoice in charge request"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| // Per spec: Authorization: Payment <base64url-token> (single token, no wrapper) | ||
| const credential = buildMppCredential(challenge, invResp.preimage); | ||
| headers.set("Authorization", `Payment ${credential}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| const fetchWithMpp = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const wwwAuthHeader = initResp.headers.get("www-authenticate"); | ||
| if (!wwwAuthHeader || | ||
| !wwwAuthHeader.trimStart().toLowerCase().startsWith("payment")) { | ||
| return initResp; | ||
| } | ||
| return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| }; | ||
| exports.fetchWithMpp = fetchWithMpp; | ||
| //# sourceMappingURL=mpp.cjs.map |
| {"version":3,"file":"mpp.cjs","sources":["../../../src/402/mpp/utils.ts","../../../src/402/mpp/mpp.ts"],"sourcesContent":["export interface MppChallenge {\n id: string;\n realm: string;\n method: string;\n intent: string;\n request: string;\n expires?: string;\n}\n\nexport interface MppChargeRequest {\n amount: string;\n currency: string;\n description?: string;\n recipient?: string;\n externalId?: string;\n methodDetails: {\n invoice: string;\n paymentHash?: string;\n network?: string;\n };\n}\n\n/**\n * Parse a `WWW-Authenticate: Payment …` header produced by a\n * draft-lightning-charge-00 server. Expected format:\n *\n * Payment id=\"<id>\", realm=\"<realm>\", method=\"lightning\",\n * intent=\"charge\", request=\"<base64url>\" [, expires=\"<rfc3339>\"]\n *\n * Returns null when the header is not a Payment lightning/charge challenge.\n */\nexport const parseMppChallenge = (header: string): MppChallenge | null => {\n if (!header.trimStart().toLowerCase().startsWith(\"payment\")) {\n return null;\n }\n const rest = header\n .slice(header.toLowerCase().indexOf(\"payment\") + \"payment\".length)\n .trim();\n const result: Record<string, string> = {};\n const regex = /(\\w+)=(\"([^\"]*)\"|'([^']*)'|([^,\\s]*))/g;\n let match;\n while ((match = regex.exec(rest)) !== null) {\n result[match[1]] = match[3] ?? match[4] ?? match[5] ?? \"\";\n }\n\n if (\n result.method !== \"lightning\" ||\n result.intent !== \"charge\" ||\n !result.id ||\n !result.realm ||\n !result.request\n ) {\n return null;\n }\n\n return {\n id: result.id,\n realm: result.realm,\n method: result.method,\n intent: result.intent,\n request: result.request,\n ...(result.expires ? { expires: result.expires } : {}),\n };\n};\n\n/** Decode a base64url string (no padding required) to a UTF-8 string. */\nexport const decodeBase64url = (input: string): string => {\n const base64 = input.replace(/-/g, \"+\").replace(/_/g, \"/\");\n const binary = atob(base64);\n const bytes = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) {\n bytes[i] = binary.charCodeAt(i);\n }\n return new TextDecoder(\"utf-8\").decode(bytes);\n};\n\n/** Encode a UTF-8 string to base64url without padding. */\nconst encodeBase64url = (input: string): string => {\n const bytes = new TextEncoder().encode(input);\n let binary = \"\";\n for (let i = 0; i < bytes.length; i++) {\n binary += String.fromCharCode(bytes[i]);\n }\n return btoa(binary).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=/g, \"\");\n};\n\n/**\n * JSON Canonicalization Scheme (RFC 8785).\n * Produces compact JSON with object keys sorted lexicographically.\n */\nconst jcs = (value: unknown): string => {\n if (value === null || typeof value !== \"object\") {\n return JSON.stringify(value);\n }\n if (Array.isArray(value)) {\n return \"[\" + (value as unknown[]).map(jcs).join(\",\") + \"]\";\n }\n const keys = Object.keys(value as object).sort();\n return (\n \"{\" +\n keys\n .map(\n (k) =>\n JSON.stringify(k) + \":\" + jcs((value as Record<string, unknown>)[k]),\n )\n .join(\",\") +\n \"}\"\n );\n};\n\n/**\n * Build the base64url-encoded credential token for the `Authorization` header.\n *\n * Per the spec the credential is a JCS-serialised JSON object that echoes all\n * challenge auth-params (id, realm, method, intent, request, expires) and\n * carries the HTLC preimage that proves payment:\n *\n * {\n * \"challenge\": { \"id\": \"…\", \"intent\": \"charge\",\n * \"method\": \"lightning\", \"realm\": \"…\", \"request\": \"…\" },\n * \"payload\": { \"preimage\": \"<64-char lowercase hex>\" }\n * }\n *\n * Keys are sorted lexicographically at every level per JCS.\n */\nexport const buildMppCredential = (\n challenge: MppChallenge,\n preimage: string,\n source?: string,\n): string => {\n const challengeEcho: Record<string, string> = {\n id: challenge.id,\n intent: challenge.intent,\n method: challenge.method,\n realm: challenge.realm,\n request: challenge.request,\n };\n if (challenge.expires) {\n challengeEcho.expires = challenge.expires;\n }\n\n const credential: Record<string, unknown> = {\n challenge: challengeEcho,\n payload: { preimage },\n };\n if (source) {\n credential.source = source;\n }\n\n return encodeBase64url(jcs(credential));\n};\n\n/**\n * Construct a `WWW-Authenticate` header for testing / server implementations.\n *\n * The auth scheme is `Payment` per [I-D.httpauth-payment].\n */\nexport const makeMppWwwAuthenticateHeader = (args: {\n id: string;\n realm: string;\n request: string;\n expires?: string;\n}): string => {\n let header =\n `Payment id=\"${args.id}\", realm=\"${args.realm}\", method=\"lightning\",` +\n ` intent=\"charge\", request=\"${args.request}\"`;\n if (args.expires) {\n header += `, expires=\"${args.expires}\"`;\n }\n return header;\n};\n\n/** Encode an MppChargeRequest as a base64url string suitable for the `request` auth-param. */\nexport const encodeMppChargeRequest = (request: MppChargeRequest): string =>\n encodeBase64url(jcs(request));\n","import { Wallet } from \"../utils\";\nimport {\n buildMppCredential,\n decodeBase64url,\n MppChargeRequest,\n parseMppChallenge,\n} from \"./utils\";\n\n/**\n * Handle a `WWW-Authenticate: Payment …` challenge produced by a\n * draft-lightning-charge-00 server.\n *\n * Flow:\n * 1. Parse the challenge from the header.\n * 2. Decode the `request` auth-param to find the BOLT11 invoice.\n * 3. Pay the invoice via the wallet; receive the HTLC preimage.\n * 4. Build the `Authorization: Payment <credential>` header.\n * 5. Retry the original request with the credential.\n */\nexport const handleMppChargePayment = async (\n wwwAuthHeader: string,\n url: string,\n fetchArgs: RequestInit,\n headers: Headers,\n wallet: Wallet,\n): Promise<Response> => {\n const challenge = parseMppChallenge(wwwAuthHeader);\n if (!challenge) {\n throw new Error(\n \"mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)\",\n );\n }\n\n let request: MppChargeRequest;\n try {\n request = JSON.parse(decodeBase64url(challenge.request));\n } catch (_) {\n throw new Error(\n \"mpp: invalid request auth-param (not valid base64url-encoded JSON)\",\n );\n }\n\n const invoice = request.methodDetails?.invoice;\n if (!invoice) {\n throw new Error(\"mpp: missing invoice in charge request\");\n }\n\n const invResp = await wallet.payInvoice({ invoice });\n\n // Per spec: Authorization: Payment <base64url-token> (single token, no wrapper)\n const credential = buildMppCredential(challenge, invResp.preimage);\n headers.set(\"Authorization\", `Payment ${credential}`);\n\n return fetch(url, fetchArgs);\n};\n\n/**\n * Fetch a resource protected by the draft-lightning-charge-00 payment\n * authentication protocol.\n *\n * On a `402 Payment Required` response that carries a\n * `WWW-Authenticate: Payment method=\"lightning\" intent=\"charge\" …` header\n * the function pays the embedded BOLT11 invoice and retries with the\n * resulting preimage as the credential.\n *\n * Note: lightning-charge uses consume-once challenge semantics – each\n * challenge embeds a fresh invoice, so paid credentials cannot be reused.\n * The `store` option is accepted for API consistency but is not used.\n */\nexport const fetchWithMpp = async (\n url: string,\n fetchArgs: RequestInit,\n options: { wallet: Wallet },\n): Promise<Response> => {\n const wallet = options.wallet;\n if (!wallet) {\n throw new Error(\"wallet is missing\");\n }\n if (!fetchArgs) {\n fetchArgs = {};\n }\n fetchArgs.cache = \"no-store\";\n fetchArgs.mode = \"cors\";\n const headers = new Headers(fetchArgs.headers ?? undefined);\n fetchArgs.headers = headers;\n\n const initResp = await fetch(url, fetchArgs);\n const wwwAuthHeader = initResp.headers.get(\"www-authenticate\");\n if (\n !wwwAuthHeader ||\n !wwwAuthHeader.trimStart().toLowerCase().startsWith(\"payment\")\n ) {\n return initResp;\n }\n\n return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet);\n};\n"],"names":[],"mappings":";;AAsBA;;;;;;;;AAQG;AACI,MAAM,iBAAiB,GAAG,CAAC,MAAc,KAAyB;AACvE,IAAA,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;AAC3D,QAAA,OAAO,IAAI;IACb;IACA,MAAM,IAAI,GAAG;AACV,SAAA,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,MAAM;AAChE,SAAA,IAAI,EAAE;IACT,MAAM,MAAM,GAA2B,EAAE;IACzC,MAAM,KAAK,GAAG,wCAAwC;AACtD,IAAA,IAAI,KAAK;AACT,IAAA,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE;QAC1C,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;IAC3D;AAEA,IAAA,IACE,MAAM,CAAC,MAAM,KAAK,WAAW;QAC7B,MAAM,CAAC,MAAM,KAAK,QAAQ;QAC1B,CAAC,MAAM,CAAC,EAAE;QACV,CAAC,MAAM,CAAC,KAAK;AACb,QAAA,CAAC,MAAM,CAAC,OAAO,EACf;AACA,QAAA,OAAO,IAAI;IACb;IAEA,OAAO;QACL,EAAE,EAAE,MAAM,CAAC,EAAE;QACb,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;AACvB,QAAA,IAAI,MAAM,CAAC,OAAO,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC;KACvD;AACH,CAAC;AAED;AACO,MAAM,eAAe,GAAG,CAAC,KAAa,KAAY;AACvD,IAAA,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC;AAC1D,IAAA,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;AAC3C,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;IACjC;IACA,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;AAC/C,CAAC;AAED;AACA,MAAM,eAAe,GAAG,CAAC,KAAa,KAAY;IAChD,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC;IAC7C,IAAI,MAAM,GAAG,EAAE;AACf,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACrC,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzC;IACA,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;AAC/E,CAAC;AAED;;;AAGG;AACH,MAAM,GAAG,GAAG,CAAC,KAAc,KAAY;IACrC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AAC/C,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;IAC9B;AACA,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACxB,QAAA,OAAO,GAAG,GAAI,KAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG;IAC5D;IACA,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAe,CAAC,CAAC,IAAI,EAAE;AAChD,IAAA,QACE,GAAG;QACH;aACG,GAAG,CACF,CAAC,CAAC,KACA,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAE,KAAiC,CAAC,CAAC,CAAC,CAAC;aAEvE,IAAI,CAAC,GAAG,CAAC;AACZ,QAAA,GAAG;AAEP,CAAC;AAED;;;;;;;;;;;;;;AAcG;AACI,MAAM,kBAAkB,GAAG,CAChC,SAAuB,EACvB,QAAgB,EAChB,MAAe,KACL;AACV,IAAA,MAAM,aAAa,GAA2B;QAC5C,EAAE,EAAE,SAAS,CAAC,EAAE;QAChB,MAAM,EAAE,SAAS,CAAC,MAAM;QACxB,MAAM,EAAE,SAAS,CAAC,MAAM;QACxB,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,OAAO,EAAE,SAAS,CAAC,OAAO;KAC3B;AACD,IAAA,IAAI,SAAS,CAAC,OAAO,EAAE;AACrB,QAAA,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO;IAC3C;AAEA,IAAA,MAAM,UAAU,GAA4B;AAC1C,QAAA,SAAS,EAAE,aAAa;QACxB,OAAO,EAAE,EAAE,QAAQ,EAAE;KACtB;AAKD,IAAA,OAAO,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AACzC,CAAC;;AC9ID;;;;;;;;;;AAUG;AACI,MAAM,sBAAsB,GAAG,OACpC,aAAqB,EACrB,GAAW,EACX,SAAsB,EACtB,OAAgB,EAChB,MAAc,KACO;AACrB,IAAA,MAAM,SAAS,GAAG,iBAAiB,CAAC,aAAa,CAAC;IAClD,IAAI,CAAC,SAAS,EAAE;AACd,QAAA,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G;IACH;AAEA,IAAA,IAAI,OAAyB;AAC7B,IAAA,IAAI;AACF,QAAA,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC1D;IAAE,OAAO,CAAC,EAAE;AACV,QAAA,MAAM,IAAI,KAAK,CACb,oEAAoE,CACrE;IACH;AAEA,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE,OAAO;IAC9C,IAAI,CAAC,OAAO,EAAE;AACZ,QAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC;IAC3D;IAEA,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,CAAC;;IAGpD,MAAM,UAAU,GAAG,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,CAAC;IAClE,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,CAAA,QAAA,EAAW,UAAU,CAAA,CAAE,CAAC;AAErD,IAAA,OAAO,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG,OAC1B,GAAW,EACX,SAAsB,EACtB,OAA2B,KACN;AACrB,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM;IAC7B,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IACtC;IACA,IAAI,CAAC,SAAS,EAAE;QACd,SAAS,GAAG,EAAE;IAChB;AACA,IAAA,SAAS,CAAC,KAAK,GAAG,UAAU;AAC5B,IAAA,SAAS,CAAC,IAAI,GAAG,MAAM;IACvB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC;AAC3D,IAAA,SAAS,CAAC,OAAO,GAAG,OAAO;IAE3B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IAC5C,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAC9D,IAAA,IACE,CAAC,aAAa;AACd,QAAA,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAC9D;AACA,QAAA,OAAO,QAAQ;IACjB;AAEA,IAAA,OAAO,sBAAsB,CAAC,aAAa,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC;AAC/E;;;;"} |
| 'use strict'; | ||
| const buildX402PaymentSignature = (scheme, network, invoice, requirements) => { | ||
| const json = JSON.stringify({ | ||
| x402Version: 2, | ||
| scheme, | ||
| network, | ||
| payload: { invoice }, | ||
| accepted: requirements, | ||
| }); | ||
| // btoa only handles latin1; encode via UTF-8 to be safe | ||
| return btoa(unescape(encodeURIComponent(json))); | ||
| }; | ||
| var lib = {}; | ||
| var hasRequiredLib; | ||
| function requireLib () { | ||
| if (hasRequiredLib) return lib; | ||
| hasRequiredLib = 1; | ||
| (function (exports) { | ||
| /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64url = exports.base64 = exports.base32crockford = exports.base32hex = exports.base32 = exports.base16 = exports.utils = exports.assertNumber = void 0; | ||
| function assertNumber(n) { | ||
| if (!Number.isSafeInteger(n)) | ||
| throw new Error(`Wrong integer: ${n}`); | ||
| } | ||
| exports.assertNumber = assertNumber; | ||
| function chain(...args) { | ||
| const wrap = (a, b) => (c) => a(b(c)); | ||
| const encode = Array.from(args) | ||
| .reverse() | ||
| .reduce((acc, i) => (acc ? wrap(acc, i.encode) : i.encode), undefined); | ||
| const decode = args.reduce((acc, i) => (acc ? wrap(acc, i.decode) : i.decode), undefined); | ||
| return { encode, decode }; | ||
| } | ||
| function alphabet(alphabet) { | ||
| return { | ||
| encode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('alphabet.encode input should be an array of numbers'); | ||
| return digits.map((i) => { | ||
| assertNumber(i); | ||
| if (i < 0 || i >= alphabet.length) | ||
| throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`); | ||
| return alphabet[i]; | ||
| }); | ||
| }, | ||
| decode: (input) => { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('alphabet.decode input should be array of strings'); | ||
| return input.map((letter) => { | ||
| if (typeof letter !== 'string') | ||
| throw new Error(`alphabet.decode: not string element=${letter}`); | ||
| const index = alphabet.indexOf(letter); | ||
| if (index === -1) | ||
| throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`); | ||
| return index; | ||
| }); | ||
| }, | ||
| }; | ||
| } | ||
| function join(separator = '') { | ||
| if (typeof separator !== 'string') | ||
| throw new Error('join separator should be string'); | ||
| return { | ||
| encode: (from) => { | ||
| if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string')) | ||
| throw new Error('join.encode input should be array of strings'); | ||
| for (let i of from) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`join.encode: non-string input=${i}`); | ||
| return from.join(separator); | ||
| }, | ||
| decode: (to) => { | ||
| if (typeof to !== 'string') | ||
| throw new Error('join.decode input should be string'); | ||
| return to.split(separator); | ||
| }, | ||
| }; | ||
| } | ||
| function padding(bits, chr = '=') { | ||
| assertNumber(bits); | ||
| if (typeof chr !== 'string') | ||
| throw new Error('padding chr should be string'); | ||
| return { | ||
| encode(data) { | ||
| if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of data) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.encode: non-string input=${i}`); | ||
| while ((data.length * bits) % 8) | ||
| data.push(chr); | ||
| return data; | ||
| }, | ||
| decode(input) { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of input) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.decode: non-string input=${i}`); | ||
| let end = input.length; | ||
| if ((end * bits) % 8) | ||
| throw new Error('Invalid padding: string should have whole number of bytes'); | ||
| for (; end > 0 && input[end - 1] === chr; end--) { | ||
| if (!(((end - 1) * bits) % 8)) | ||
| throw new Error('Invalid padding: string has too much padding'); | ||
| } | ||
| return input.slice(0, end); | ||
| }, | ||
| }; | ||
| } | ||
| function normalize(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('normalize fn should be function'); | ||
| return { encode: (from) => from, decode: (to) => fn(to) }; | ||
| } | ||
| function convertRadix(data, from, to) { | ||
| if (from < 2) | ||
| throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`); | ||
| if (to < 2) | ||
| throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`); | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix: data should be array'); | ||
| if (!data.length) | ||
| return []; | ||
| let pos = 0; | ||
| const res = []; | ||
| const digits = Array.from(data); | ||
| digits.forEach((d) => { | ||
| assertNumber(d); | ||
| if (d < 0 || d >= from) | ||
| throw new Error(`Wrong integer: ${d}`); | ||
| }); | ||
| while (true) { | ||
| let carry = 0; | ||
| let done = true; | ||
| for (let i = pos; i < digits.length; i++) { | ||
| const digit = digits[i]; | ||
| const digitBase = from * carry + digit; | ||
| if (!Number.isSafeInteger(digitBase) || | ||
| (from * carry) / from !== carry || | ||
| digitBase - digit !== from * carry) { | ||
| throw new Error('convertRadix: carry overflow'); | ||
| } | ||
| carry = digitBase % to; | ||
| digits[i] = Math.floor(digitBase / to); | ||
| if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase) | ||
| throw new Error('convertRadix: carry overflow'); | ||
| if (!done) | ||
| continue; | ||
| else if (!digits[i]) | ||
| pos = i; | ||
| else | ||
| done = false; | ||
| } | ||
| res.push(carry); | ||
| if (done) | ||
| break; | ||
| } | ||
| for (let i = 0; i < data.length - 1 && data[i] === 0; i++) | ||
| res.push(0); | ||
| return res.reverse(); | ||
| } | ||
| const gcd = (a, b) => (!b ? a : gcd(b, a % b)); | ||
| const radix2carry = (from, to) => from + (to - gcd(from, to)); | ||
| function convertRadix2(data, from, to, padding) { | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix2: data should be array'); | ||
| if (from <= 0 || from > 32) | ||
| throw new Error(`convertRadix2: wrong from=${from}`); | ||
| if (to <= 0 || to > 32) | ||
| throw new Error(`convertRadix2: wrong to=${to}`); | ||
| if (radix2carry(from, to) > 32) { | ||
| throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`); | ||
| } | ||
| let carry = 0; | ||
| let pos = 0; | ||
| const mask = 2 ** to - 1; | ||
| const res = []; | ||
| for (const n of data) { | ||
| assertNumber(n); | ||
| if (n >= 2 ** from) | ||
| throw new Error(`convertRadix2: invalid data word=${n} from=${from}`); | ||
| carry = (carry << from) | n; | ||
| if (pos + from > 32) | ||
| throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`); | ||
| pos += from; | ||
| for (; pos >= to; pos -= to) | ||
| res.push(((carry >> (pos - to)) & mask) >>> 0); | ||
| carry &= 2 ** pos - 1; | ||
| } | ||
| carry = (carry << (to - pos)) & mask; | ||
| if (!padding && pos >= from) | ||
| throw new Error('Excess padding'); | ||
| if (!padding && carry) | ||
| throw new Error(`Non-zero padding: ${carry}`); | ||
| if (padding && pos > 0) | ||
| res.push(carry >>> 0); | ||
| return res; | ||
| } | ||
| function radix(num) { | ||
| assertNumber(num); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix.encode input should be Uint8Array'); | ||
| return convertRadix(Array.from(bytes), 2 ** 8, num); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix(digits, num, 2 ** 8)); | ||
| }, | ||
| }; | ||
| } | ||
| function radix2(bits, revPadding = false) { | ||
| assertNumber(bits); | ||
| if (bits <= 0 || bits > 32) | ||
| throw new Error('radix2: bits should be in (0..32]'); | ||
| if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32) | ||
| throw new Error('radix2: carry overflow'); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix2.encode input should be Uint8Array'); | ||
| return convertRadix2(Array.from(bytes), 8, bits, !revPadding); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix2.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding)); | ||
| }, | ||
| }; | ||
| } | ||
| function unsafeWrapper(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('unsafeWrapper fn should be function'); | ||
| return function (...args) { | ||
| try { | ||
| return fn.apply(null, args); | ||
| } | ||
| catch (e) { } | ||
| }; | ||
| } | ||
| function checksum(len, fn) { | ||
| assertNumber(len); | ||
| if (typeof fn !== 'function') | ||
| throw new Error('checksum fn should be function'); | ||
| return { | ||
| encode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.encode: input should be Uint8Array'); | ||
| const checksum = fn(data).slice(0, len); | ||
| const res = new Uint8Array(data.length + len); | ||
| res.set(data); | ||
| res.set(checksum, data.length); | ||
| return res; | ||
| }, | ||
| decode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.decode: input should be Uint8Array'); | ||
| const payload = data.slice(0, -len); | ||
| const newChecksum = fn(payload).slice(0, len); | ||
| const oldChecksum = data.slice(-len); | ||
| for (let i = 0; i < len; i++) | ||
| if (newChecksum[i] !== oldChecksum[i]) | ||
| throw new Error('Invalid checksum'); | ||
| return payload; | ||
| }, | ||
| }; | ||
| } | ||
| exports.utils = { alphabet, chain, checksum, radix, radix2, join, padding }; | ||
| exports.base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join('')); | ||
| exports.base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join('')); | ||
| exports.base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join('')); | ||
| exports.base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1'))); | ||
| exports.base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join('')); | ||
| exports.base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join('')); | ||
| const genBase58 = (abc) => chain(radix(58), alphabet(abc), join('')); | ||
| exports.base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'); | ||
| exports.base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'); | ||
| exports.base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz'); | ||
| const XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11]; | ||
| exports.base58xmr = { | ||
| encode(data) { | ||
| let res = ''; | ||
| for (let i = 0; i < data.length; i += 8) { | ||
| const block = data.subarray(i, i + 8); | ||
| res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1'); | ||
| } | ||
| return res; | ||
| }, | ||
| decode(str) { | ||
| let res = []; | ||
| for (let i = 0; i < str.length; i += 11) { | ||
| const slice = str.slice(i, i + 11); | ||
| const blockLen = XMR_BLOCK_LEN.indexOf(slice.length); | ||
| const block = exports.base58.decode(slice); | ||
| for (let j = 0; j < block.length - blockLen; j++) { | ||
| if (block[j] !== 0) | ||
| throw new Error('base58xmr: wrong padding'); | ||
| } | ||
| res = res.concat(Array.from(block.slice(block.length - blockLen))); | ||
| } | ||
| return Uint8Array.from(res); | ||
| }, | ||
| }; | ||
| const base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), exports.base58); | ||
| exports.base58check = base58check; | ||
| const BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join('')); | ||
| const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; | ||
| function bech32Polymod(pre) { | ||
| const b = pre >> 25; | ||
| let chk = (pre & 0x1ffffff) << 5; | ||
| for (let i = 0; i < POLYMOD_GENERATORS.length; i++) { | ||
| if (((b >> i) & 1) === 1) | ||
| chk ^= POLYMOD_GENERATORS[i]; | ||
| } | ||
| return chk; | ||
| } | ||
| function bechChecksum(prefix, words, encodingConst = 1) { | ||
| const len = prefix.length; | ||
| let chk = 1; | ||
| for (let i = 0; i < len; i++) { | ||
| const c = prefix.charCodeAt(i); | ||
| if (c < 33 || c > 126) | ||
| throw new Error(`Invalid prefix (${prefix})`); | ||
| chk = bech32Polymod(chk) ^ (c >> 5); | ||
| } | ||
| chk = bech32Polymod(chk); | ||
| for (let i = 0; i < len; i++) | ||
| chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f); | ||
| for (let v of words) | ||
| chk = bech32Polymod(chk) ^ v; | ||
| for (let i = 0; i < 6; i++) | ||
| chk = bech32Polymod(chk); | ||
| chk ^= encodingConst; | ||
| return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false)); | ||
| } | ||
| function genBech32(encoding) { | ||
| const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3; | ||
| const _words = radix2(5); | ||
| const fromWords = _words.decode; | ||
| const toWords = _words.encode; | ||
| const fromWordsUnsafe = unsafeWrapper(fromWords); | ||
| function encode(prefix, words, limit = 90) { | ||
| if (typeof prefix !== 'string') | ||
| throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`); | ||
| if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number')) | ||
| throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`); | ||
| const actualLength = prefix.length + 7 + words.length; | ||
| if (limit !== false && actualLength > limit) | ||
| throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); | ||
| prefix = prefix.toLowerCase(); | ||
| return `${prefix}1${BECH_ALPHABET.encode(words)}${bechChecksum(prefix, words, ENCODING_CONST)}`; | ||
| } | ||
| function decode(str, limit = 90) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`bech32.decode input should be string, not ${typeof str}`); | ||
| if (str.length < 8 || (limit !== false && str.length > limit)) | ||
| throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`); | ||
| const lowered = str.toLowerCase(); | ||
| if (str !== lowered && str !== str.toUpperCase()) | ||
| throw new Error(`String must be lowercase or uppercase`); | ||
| str = lowered; | ||
| const sepIndex = str.lastIndexOf('1'); | ||
| if (sepIndex === 0 || sepIndex === -1) | ||
| throw new Error(`Letter "1" must be present between prefix and data only`); | ||
| const prefix = str.slice(0, sepIndex); | ||
| const _words = str.slice(sepIndex + 1); | ||
| if (_words.length < 6) | ||
| throw new Error('Data must be at least 6 characters long'); | ||
| const words = BECH_ALPHABET.decode(_words).slice(0, -6); | ||
| const sum = bechChecksum(prefix, words, ENCODING_CONST); | ||
| if (!_words.endsWith(sum)) | ||
| throw new Error(`Invalid checksum in ${str}: expected "${sum}"`); | ||
| return { prefix, words }; | ||
| } | ||
| const decodeUnsafe = unsafeWrapper(decode); | ||
| function decodeToBytes(str) { | ||
| const { prefix, words } = decode(str, false); | ||
| return { prefix, words, bytes: fromWords(words) }; | ||
| } | ||
| return { encode, decode, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords }; | ||
| } | ||
| exports.bech32 = genBech32('bech32'); | ||
| exports.bech32m = genBech32('bech32m'); | ||
| exports.utf8 = { | ||
| encode: (data) => new TextDecoder().decode(data), | ||
| decode: (str) => new TextEncoder().encode(str), | ||
| }; | ||
| exports.hex = chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => { | ||
| if (typeof s !== 'string' || s.length % 2) | ||
| throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`); | ||
| return s.toLowerCase(); | ||
| })); | ||
| const CODERS = { | ||
| utf8: exports.utf8, hex: exports.hex, base16: exports.base16, base32: exports.base32, base64: exports.base64, base64url: exports.base64url, base58: exports.base58, base58xmr: exports.base58xmr | ||
| }; | ||
| const coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`; | ||
| const bytesToString = (type, bytes) => { | ||
| if (typeof type !== 'string' || !CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new TypeError('bytesToString() expects Uint8Array'); | ||
| return CODERS[type].encode(bytes); | ||
| }; | ||
| exports.bytesToString = bytesToString; | ||
| exports.str = exports.bytesToString; | ||
| const stringToBytes = (type, str) => { | ||
| if (!CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (typeof str !== 'string') | ||
| throw new TypeError('stringToBytes() expects string'); | ||
| return CODERS[type].decode(str); | ||
| }; | ||
| exports.stringToBytes = stringToBytes; | ||
| exports.bytes = exports.stringToBytes; | ||
| } (lib)); | ||
| return lib; | ||
| } | ||
| var bolt11; | ||
| var hasRequiredBolt11; | ||
| function requireBolt11 () { | ||
| if (hasRequiredBolt11) return bolt11; | ||
| hasRequiredBolt11 = 1; | ||
| const {bech32, hex, utf8} = requireLib(); | ||
| // defaults for encode; default timestamp is current time at call | ||
| const DEFAULTNETWORK = { | ||
| // default network is bitcoin | ||
| bech32: 'bc', | ||
| pubKeyHash: 0x00, | ||
| scriptHash: 0x05, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const TESTNETWORK = { | ||
| bech32: 'tb', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIGNETNETWORK = { | ||
| bech32: 'tbs', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const REGTESTNETWORK = { | ||
| bech32: 'bcrt', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIMNETWORK = { | ||
| bech32: 'sb', | ||
| pubKeyHash: 0x3f, | ||
| scriptHash: 0x7b, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const FEATUREBIT_ORDER = [ | ||
| 'option_data_loss_protect', | ||
| 'initial_routing_sync', | ||
| 'option_upfront_shutdown_script', | ||
| 'gossip_queries', | ||
| 'var_onion_optin', | ||
| 'gossip_queries_ex', | ||
| 'option_static_remotekey', | ||
| 'payment_secret', | ||
| 'basic_mpp', | ||
| 'option_support_large_channel' | ||
| ]; | ||
| const DIVISORS = { | ||
| m: BigInt(1e3), | ||
| u: BigInt(1e6), | ||
| n: BigInt(1e9), | ||
| p: BigInt(1e12) | ||
| }; | ||
| const MAX_MILLISATS = BigInt('2100000000000000000'); | ||
| const MILLISATS_PER_BTC = BigInt(1e11); | ||
| const TAGCODES = { | ||
| payment_hash: 1, | ||
| payment_secret: 16, | ||
| description: 13, | ||
| payee: 19, | ||
| description_hash: 23, // commit to longer descriptions (used by lnurl-pay) | ||
| expiry: 6, // default: 3600 (1 hour) | ||
| min_final_cltv_expiry: 24, // default: 9 | ||
| fallback_address: 9, | ||
| route_hint: 3, // for extra routing info (private etc.) | ||
| feature_bits: 5, | ||
| metadata: 27 | ||
| }; | ||
| // reverse the keys and values of TAGCODES and insert into TAGNAMES | ||
| const TAGNAMES = {}; | ||
| for (let i = 0, keys = Object.keys(TAGCODES); i < keys.length; i++) { | ||
| const currentName = keys[i]; | ||
| const currentCode = TAGCODES[keys[i]].toString(); | ||
| TAGNAMES[currentCode] = currentName; | ||
| } | ||
| const TAGPARSERS = { | ||
| 1: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 16: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 13: words => utf8.encode(bech32.fromWordsUnsafe(words)), // string variable length | ||
| 19: words => hex.encode(bech32.fromWordsUnsafe(words)), // 264 bits | ||
| 23: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 27: words => hex.encode(bech32.fromWordsUnsafe(words)), // variable | ||
| 6: wordsToIntBE, // default: 3600 (1 hour) | ||
| 24: wordsToIntBE, // default: 9 | ||
| 3: routingInfoParser, // for extra routing info (private etc.) | ||
| 5: featureBitsParser // keep feature bits as array of 5 bit words | ||
| }; | ||
| function getUnknownParser(tagCode) { | ||
| return words => ({ | ||
| tagCode: parseInt(tagCode), | ||
| words: bech32.encode('unknown', words, Number.MAX_SAFE_INTEGER) | ||
| }) | ||
| } | ||
| function wordsToIntBE(words) { | ||
| return words.reverse().reduce((total, item, index) => { | ||
| return total + item * Math.pow(32, index) | ||
| }, 0) | ||
| } | ||
| // first convert from words to buffer, trimming padding where necessary | ||
| // parse in 51 byte chunks. See encoder for details. | ||
| function routingInfoParser(words) { | ||
| const routes = []; | ||
| let pubkey, | ||
| shortChannelId, | ||
| feeBaseMSats, | ||
| feeProportionalMillionths, | ||
| cltvExpiryDelta; | ||
| let routesBuffer = bech32.fromWordsUnsafe(words); | ||
| while (routesBuffer.length > 0) { | ||
| pubkey = hex.encode(routesBuffer.slice(0, 33)); // 33 bytes | ||
| shortChannelId = hex.encode(routesBuffer.slice(33, 41)); // 8 bytes | ||
| feeBaseMSats = parseInt(hex.encode(routesBuffer.slice(41, 45)), 16); // 4 bytes | ||
| feeProportionalMillionths = parseInt( | ||
| hex.encode(routesBuffer.slice(45, 49)), | ||
| 16 | ||
| ); // 4 bytes | ||
| cltvExpiryDelta = parseInt(hex.encode(routesBuffer.slice(49, 51)), 16); // 2 bytes | ||
| routesBuffer = routesBuffer.slice(51); | ||
| routes.push({ | ||
| pubkey, | ||
| short_channel_id: shortChannelId, | ||
| fee_base_msat: feeBaseMSats, | ||
| fee_proportional_millionths: feeProportionalMillionths, | ||
| cltv_expiry_delta: cltvExpiryDelta | ||
| }); | ||
| } | ||
| return routes | ||
| } | ||
| function featureBitsParser(words) { | ||
| const bools = words | ||
| .slice() | ||
| .reverse() | ||
| .map(word => [ | ||
| !!(word & 0b1), | ||
| !!(word & 0b10), | ||
| !!(word & 0b100), | ||
| !!(word & 0b1000), | ||
| !!(word & 0b10000) | ||
| ]) | ||
| .reduce((finalArr, itemArr) => finalArr.concat(itemArr), []); | ||
| while (bools.length < FEATUREBIT_ORDER.length * 2) { | ||
| bools.push(false); | ||
| } | ||
| const featureBits = {}; | ||
| FEATUREBIT_ORDER.forEach((featureName, index) => { | ||
| let status; | ||
| if (bools[index * 2]) { | ||
| status = 'required'; | ||
| } else if (bools[index * 2 + 1]) { | ||
| status = 'supported'; | ||
| } else { | ||
| status = 'unsupported'; | ||
| } | ||
| featureBits[featureName] = status; | ||
| }); | ||
| const extraBits = bools.slice(FEATUREBIT_ORDER.length * 2); | ||
| featureBits.extra_bits = { | ||
| start_bit: FEATUREBIT_ORDER.length * 2, | ||
| bits: extraBits, | ||
| has_required: extraBits.reduce( | ||
| (result, bit, index) => | ||
| index % 2 !== 0 ? result || false : result || bit, | ||
| false | ||
| ) | ||
| }; | ||
| return featureBits | ||
| } | ||
| function hrpToMillisat(hrpString, outputString) { | ||
| let divisor, value; | ||
| if (hrpString.slice(-1).match(/^[munp]$/)) { | ||
| divisor = hrpString.slice(-1); | ||
| value = hrpString.slice(0, -1); | ||
| } else if (hrpString.slice(-1).match(/^[^munp0-9]$/)) { | ||
| throw new Error('Not a valid multiplier for the amount') | ||
| } else { | ||
| value = hrpString; | ||
| } | ||
| if (!value.match(/^\d+$/)) | ||
| throw new Error('Not a valid human readable amount') | ||
| const valueBN = BigInt(value); | ||
| const millisatoshisBN = divisor | ||
| ? (valueBN * MILLISATS_PER_BTC) / DIVISORS[divisor] | ||
| : valueBN * MILLISATS_PER_BTC; | ||
| if ( | ||
| (divisor === 'p' && !(valueBN % BigInt(10) === BigInt(0))) || | ||
| millisatoshisBN > MAX_MILLISATS | ||
| ) { | ||
| throw new Error('Amount is outside of valid range') | ||
| } | ||
| return outputString ? millisatoshisBN.toString() : millisatoshisBN | ||
| } | ||
| // decode will only have extra comments that aren't covered in encode comments. | ||
| // also if anything is hard to read I'll comment. | ||
| function decode(paymentRequest, network) { | ||
| if (typeof paymentRequest !== 'string') | ||
| throw new Error('Lightning Payment Request must be string') | ||
| if (paymentRequest.slice(0, 2).toLowerCase() !== 'ln') | ||
| throw new Error('Not a proper lightning payment request') | ||
| const sections = []; | ||
| const decoded = bech32.decode(paymentRequest, Number.MAX_SAFE_INTEGER); | ||
| paymentRequest = paymentRequest.toLowerCase(); | ||
| const prefix = decoded.prefix; | ||
| let words = decoded.words; | ||
| let letters = paymentRequest.slice(prefix.length + 1); | ||
| let sigWords = words.slice(-104); | ||
| words = words.slice(0, -104); | ||
| // Without reverse lookups, can't say that the multipier at the end must | ||
| // have a number before it, so instead we parse, and if the second group | ||
| // doesn't have anything, there's a good chance the last letter of the | ||
| // coin type got captured by the third group, so just re-regex without | ||
| // the number. | ||
| let prefixMatches = prefix.match(/^ln(\S+?)(\d*)([a-zA-Z]?)$/); | ||
| if (prefixMatches && !prefixMatches[2]) | ||
| prefixMatches = prefix.match(/^ln(\S+)$/); | ||
| if (!prefixMatches) { | ||
| throw new Error('Not a proper lightning payment request') | ||
| } | ||
| // "ln" section | ||
| sections.push({ | ||
| name: 'lightning_network', | ||
| letters: 'ln' | ||
| }); | ||
| // "bc" section | ||
| const bech32Prefix = prefixMatches[1]; | ||
| let coinNetwork; | ||
| if (!network) { | ||
| switch (bech32Prefix) { | ||
| case DEFAULTNETWORK.bech32: | ||
| coinNetwork = DEFAULTNETWORK; | ||
| break | ||
| case TESTNETWORK.bech32: | ||
| coinNetwork = TESTNETWORK; | ||
| break | ||
| case SIGNETNETWORK.bech32: | ||
| coinNetwork = SIGNETNETWORK; | ||
| break | ||
| case REGTESTNETWORK.bech32: | ||
| coinNetwork = REGTESTNETWORK; | ||
| break | ||
| case SIMNETWORK.bech32: | ||
| coinNetwork = SIMNETWORK; | ||
| break | ||
| } | ||
| } else { | ||
| if ( | ||
| network.bech32 === undefined || | ||
| network.pubKeyHash === undefined || | ||
| network.scriptHash === undefined || | ||
| !Array.isArray(network.validWitnessVersions) | ||
| ) | ||
| throw new Error('Invalid network') | ||
| coinNetwork = network; | ||
| } | ||
| if (!coinNetwork || coinNetwork.bech32 !== bech32Prefix) { | ||
| throw new Error('Unknown coin bech32 prefix') | ||
| } | ||
| sections.push({ | ||
| name: 'coin_network', | ||
| letters: bech32Prefix, | ||
| value: coinNetwork | ||
| }); | ||
| // amount section | ||
| const value = prefixMatches[2]; | ||
| let millisatoshis; | ||
| if (value) { | ||
| const divisor = prefixMatches[3]; | ||
| millisatoshis = hrpToMillisat(value + divisor, true); | ||
| sections.push({ | ||
| name: 'amount', | ||
| letters: prefixMatches[2] + prefixMatches[3], | ||
| value: millisatoshis | ||
| }); | ||
| } else { | ||
| millisatoshis = null; | ||
| } | ||
| // "1" separator | ||
| sections.push({ | ||
| name: 'separator', | ||
| letters: '1' | ||
| }); | ||
| // timestamp | ||
| const timestamp = wordsToIntBE(words.slice(0, 7)); | ||
| words = words.slice(7); // trim off the left 7 words | ||
| sections.push({ | ||
| name: 'timestamp', | ||
| letters: letters.slice(0, 7), | ||
| value: timestamp | ||
| }); | ||
| letters = letters.slice(7); | ||
| let tagName, parser, tagLength, tagWords; | ||
| // we have no tag count to go on, so just keep hacking off words | ||
| // until we have none. | ||
| while (words.length > 0) { | ||
| const tagCode = words[0].toString(); | ||
| tagName = TAGNAMES[tagCode] || 'unknown_tag'; | ||
| parser = TAGPARSERS[tagCode] || getUnknownParser(tagCode); | ||
| words = words.slice(1); | ||
| tagLength = wordsToIntBE(words.slice(0, 2)); | ||
| words = words.slice(2); | ||
| tagWords = words.slice(0, tagLength); | ||
| words = words.slice(tagLength); | ||
| sections.push({ | ||
| name: tagName, | ||
| tag: letters[0], | ||
| letters: letters.slice(0, 1 + 2 + tagLength), | ||
| value: parser(tagWords) // see: parsers for more comments | ||
| }); | ||
| letters = letters.slice(1 + 2 + tagLength); | ||
| } | ||
| // signature | ||
| sections.push({ | ||
| name: 'signature', | ||
| letters: letters.slice(0, 104), | ||
| value: hex.encode(bech32.fromWordsUnsafe(sigWords)) | ||
| }); | ||
| letters = letters.slice(104); | ||
| // checksum | ||
| sections.push({ | ||
| name: 'checksum', | ||
| letters: letters | ||
| }); | ||
| let result = { | ||
| paymentRequest, | ||
| sections, | ||
| get expiry() { | ||
| let exp = sections.find(s => s.name === 'expiry'); | ||
| if (exp) return getValue('timestamp') + exp.value | ||
| }, | ||
| get route_hints() { | ||
| return sections.filter(s => s.name === 'route_hint').map(s => s.value) | ||
| } | ||
| }; | ||
| for (let name in TAGCODES) { | ||
| if (name === 'route_hint') { | ||
| // route hints can be multiple, so this won't work for them | ||
| continue | ||
| } | ||
| Object.defineProperty(result, name, { | ||
| get() { | ||
| return getValue(name) | ||
| } | ||
| }); | ||
| } | ||
| return result | ||
| function getValue(name) { | ||
| let section = sections.find(s => s.name === name); | ||
| return section ? section.value : undefined | ||
| } | ||
| } | ||
| bolt11 = { | ||
| decode, | ||
| hrpToMillisat | ||
| }; | ||
| return bolt11; | ||
| } | ||
| var bolt11Exports = requireBolt11(); | ||
| // from https://stackoverflow.com/a/50868276 | ||
| const fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))); | ||
| const decodeInvoice = (paymentRequest) => { | ||
| if (!paymentRequest) | ||
| return null; | ||
| try { | ||
| const decoded = bolt11Exports.decode(paymentRequest); | ||
| if (!decoded || !decoded.sections) | ||
| return null; | ||
| const hashTag = decoded.sections.find((value) => value.name === "payment_hash"); | ||
| if (hashTag?.name !== "payment_hash" || !hashTag.value) | ||
| return null; | ||
| const paymentHash = hashTag.value; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
| } | ||
| const timestampTag = decoded.sections.find((value) => value.name === "timestamp"); | ||
| if (timestampTag?.name !== "timestamp" || !timestampTag.value) | ||
| return null; | ||
| const timestamp = timestampTag.value; | ||
| let expiry; | ||
| const expiryTag = decoded.sections.find((value) => value.name === "expiry"); | ||
| if (expiryTag?.name === "expiry") { | ||
| expiry = expiryTag.value; | ||
| } | ||
| const descriptionTag = decoded.sections.find((value) => value.name === "description"); | ||
| const description = descriptionTag?.name === "description" | ||
| ? descriptionTag?.value | ||
| : undefined; | ||
| return { | ||
| paymentHash, | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
| expiry, | ||
| description, | ||
| }; | ||
| } | ||
| catch { | ||
| return null; | ||
| } | ||
| }; | ||
| function bytes(b, ...lengths) { | ||
| if (!(b instanceof Uint8Array)) | ||
| throw new Error('Expected Uint8Array'); | ||
| if (lengths.length > 0 && !lengths.includes(b.length)) | ||
| throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`); | ||
| } | ||
| function exists(instance, checkFinished = true) { | ||
| if (instance.destroyed) | ||
| throw new Error('Hash instance has been destroyed'); | ||
| if (checkFinished && instance.finished) | ||
| throw new Error('Hash#digest() has already been called'); | ||
| } | ||
| function output(out, instance) { | ||
| bytes(out); | ||
| const min = instance.outputLen; | ||
| if (out.length < min) { | ||
| throw new Error(`digestInto() expects output buffer of length at least ${min}`); | ||
| } | ||
| } | ||
| /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| // We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+. | ||
| // node.js versions earlier than v19 don't declare it in global scope. | ||
| // For node.js, package.json#exports field mapping rewrites import | ||
| // from `crypto` to `cryptoNode`, which imports native module. | ||
| // Makes the utils un-importable in browsers without a bundler. | ||
| // Once node.js 18 is deprecated, we can just drop the import. | ||
| const u8a = (a) => a instanceof Uint8Array; | ||
| // Cast array to view | ||
| const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength); | ||
| // The rotate right (circular right shift) operation for uint32 | ||
| const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift); | ||
| // big-endian hardware is rare. Just in case someone still decides to run hashes: | ||
| // early-throw an error because we don't support BE yet. | ||
| const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44; | ||
| if (!isLE) | ||
| throw new Error('Non little-endian hardware is not supported'); | ||
| const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0')); | ||
| /** | ||
| * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123' | ||
| */ | ||
| function bytesToHex(bytes) { | ||
| if (!u8a(bytes)) | ||
| throw new Error('Uint8Array expected'); | ||
| // pre-caching improves the speed 6x | ||
| let hex = ''; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| hex += hexes[bytes[i]]; | ||
| } | ||
| return hex; | ||
| } | ||
| /** | ||
| * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99]) | ||
| */ | ||
| function utf8ToBytes(str) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`utf8ToBytes expected string, got ${typeof str}`); | ||
| return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809 | ||
| } | ||
| /** | ||
| * Normalizes (non-hex) string or Uint8Array to Uint8Array. | ||
| * Warning: when Uint8Array is passed, it would NOT get copied. | ||
| * Keep in mind for future mutable operations. | ||
| */ | ||
| function toBytes(data) { | ||
| if (typeof data === 'string') | ||
| data = utf8ToBytes(data); | ||
| if (!u8a(data)) | ||
| throw new Error(`expected Uint8Array, got ${typeof data}`); | ||
| return data; | ||
| } | ||
| // For runtime check if class implements interface | ||
| class Hash { | ||
| // Safe version that clones internal state | ||
| clone() { | ||
| return this._cloneInto(); | ||
| } | ||
| } | ||
| function wrapConstructor(hashCons) { | ||
| const hashC = (msg) => hashCons().update(toBytes(msg)).digest(); | ||
| const tmp = hashCons(); | ||
| hashC.outputLen = tmp.outputLen; | ||
| hashC.blockLen = tmp.blockLen; | ||
| hashC.create = () => hashCons(); | ||
| return hashC; | ||
| } | ||
| // Polyfill for Safari 14 | ||
| function setBigUint64(view, byteOffset, value, isLE) { | ||
| if (typeof view.setBigUint64 === 'function') | ||
| return view.setBigUint64(byteOffset, value, isLE); | ||
| const _32n = BigInt(32); | ||
| const _u32_max = BigInt(0xffffffff); | ||
| const wh = Number((value >> _32n) & _u32_max); | ||
| const wl = Number(value & _u32_max); | ||
| const h = isLE ? 4 : 0; | ||
| const l = isLE ? 0 : 4; | ||
| view.setUint32(byteOffset + h, wh, isLE); | ||
| view.setUint32(byteOffset + l, wl, isLE); | ||
| } | ||
| // Base SHA2 class (RFC 6234) | ||
| class SHA2 extends Hash { | ||
| constructor(blockLen, outputLen, padOffset, isLE) { | ||
| super(); | ||
| this.blockLen = blockLen; | ||
| this.outputLen = outputLen; | ||
| this.padOffset = padOffset; | ||
| this.isLE = isLE; | ||
| this.finished = false; | ||
| this.length = 0; | ||
| this.pos = 0; | ||
| this.destroyed = false; | ||
| this.buffer = new Uint8Array(blockLen); | ||
| this.view = createView(this.buffer); | ||
| } | ||
| update(data) { | ||
| exists(this); | ||
| const { view, buffer, blockLen } = this; | ||
| data = toBytes(data); | ||
| const len = data.length; | ||
| for (let pos = 0; pos < len;) { | ||
| const take = Math.min(blockLen - this.pos, len - pos); | ||
| // Fast path: we have at least one block in input, cast it to view and process | ||
| if (take === blockLen) { | ||
| const dataView = createView(data); | ||
| for (; blockLen <= len - pos; pos += blockLen) | ||
| this.process(dataView, pos); | ||
| continue; | ||
| } | ||
| buffer.set(data.subarray(pos, pos + take), this.pos); | ||
| this.pos += take; | ||
| pos += take; | ||
| if (this.pos === blockLen) { | ||
| this.process(view, 0); | ||
| this.pos = 0; | ||
| } | ||
| } | ||
| this.length += data.length; | ||
| this.roundClean(); | ||
| return this; | ||
| } | ||
| digestInto(out) { | ||
| exists(this); | ||
| output(out, this); | ||
| this.finished = true; | ||
| // Padding | ||
| // We can avoid allocation of buffer for padding completely if it | ||
| // was previously not allocated here. But it won't change performance. | ||
| const { buffer, view, blockLen, isLE } = this; | ||
| let { pos } = this; | ||
| // append the bit '1' to the message | ||
| buffer[pos++] = 0b10000000; | ||
| this.buffer.subarray(pos).fill(0); | ||
| // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again | ||
| if (this.padOffset > blockLen - pos) { | ||
| this.process(view, 0); | ||
| pos = 0; | ||
| } | ||
| // Pad until full block byte with zeros | ||
| for (let i = pos; i < blockLen; i++) | ||
| buffer[i] = 0; | ||
| // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that | ||
| // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen. | ||
| // So we just write lowest 64 bits of that value. | ||
| setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE); | ||
| this.process(view, 0); | ||
| const oview = createView(out); | ||
| const len = this.outputLen; | ||
| // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT | ||
| if (len % 4) | ||
| throw new Error('_sha2: outputLen should be aligned to 32bit'); | ||
| const outLen = len / 4; | ||
| const state = this.get(); | ||
| if (outLen > state.length) | ||
| throw new Error('_sha2: outputLen bigger than state'); | ||
| for (let i = 0; i < outLen; i++) | ||
| oview.setUint32(4 * i, state[i], isLE); | ||
| } | ||
| digest() { | ||
| const { buffer, outputLen } = this; | ||
| this.digestInto(buffer); | ||
| const res = buffer.slice(0, outputLen); | ||
| this.destroy(); | ||
| return res; | ||
| } | ||
| _cloneInto(to) { | ||
| to || (to = new this.constructor()); | ||
| to.set(...this.get()); | ||
| const { blockLen, buffer, length, finished, destroyed, pos } = this; | ||
| to.length = length; | ||
| to.pos = pos; | ||
| to.finished = finished; | ||
| to.destroyed = destroyed; | ||
| if (length % blockLen) | ||
| to.buffer.set(buffer); | ||
| return to; | ||
| } | ||
| } | ||
| // SHA2-256 need to try 2^128 hashes to execute birthday attack. | ||
| // BTC network is doing 2^67 hashes/sec as per early 2023. | ||
| // Choice: a ? b : c | ||
| const Chi = (a, b, c) => (a & b) ^ (~a & c); | ||
| // Majority function, true if any two inpust is true | ||
| const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c); | ||
| // Round constants: | ||
| // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311) | ||
| // prettier-ignore | ||
| const SHA256_K = /* @__PURE__ */ new Uint32Array([ | ||
| 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | ||
| 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | ||
| 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | ||
| 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | ||
| 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | ||
| 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | ||
| 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | ||
| 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 | ||
| ]); | ||
| // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19): | ||
| // prettier-ignore | ||
| const IV = /* @__PURE__ */ new Uint32Array([ | ||
| 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 | ||
| ]); | ||
| // Temporary buffer, not used to store anything between runs | ||
| // Named this way because it matches specification. | ||
| const SHA256_W = /* @__PURE__ */ new Uint32Array(64); | ||
| class SHA256 extends SHA2 { | ||
| constructor() { | ||
| super(64, 32, 8, false); | ||
| // We cannot use array here since array allows indexing by variable | ||
| // which means optimizer/compiler cannot use registers. | ||
| this.A = IV[0] | 0; | ||
| this.B = IV[1] | 0; | ||
| this.C = IV[2] | 0; | ||
| this.D = IV[3] | 0; | ||
| this.E = IV[4] | 0; | ||
| this.F = IV[5] | 0; | ||
| this.G = IV[6] | 0; | ||
| this.H = IV[7] | 0; | ||
| } | ||
| get() { | ||
| const { A, B, C, D, E, F, G, H } = this; | ||
| return [A, B, C, D, E, F, G, H]; | ||
| } | ||
| // prettier-ignore | ||
| set(A, B, C, D, E, F, G, H) { | ||
| this.A = A | 0; | ||
| this.B = B | 0; | ||
| this.C = C | 0; | ||
| this.D = D | 0; | ||
| this.E = E | 0; | ||
| this.F = F | 0; | ||
| this.G = G | 0; | ||
| this.H = H | 0; | ||
| } | ||
| process(view, offset) { | ||
| // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array | ||
| for (let i = 0; i < 16; i++, offset += 4) | ||
| SHA256_W[i] = view.getUint32(offset, false); | ||
| for (let i = 16; i < 64; i++) { | ||
| const W15 = SHA256_W[i - 15]; | ||
| const W2 = SHA256_W[i - 2]; | ||
| const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3); | ||
| const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10); | ||
| SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0; | ||
| } | ||
| // Compression function main loop, 64 rounds | ||
| let { A, B, C, D, E, F, G, H } = this; | ||
| for (let i = 0; i < 64; i++) { | ||
| const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25); | ||
| const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0; | ||
| const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22); | ||
| const T2 = (sigma0 + Maj(A, B, C)) | 0; | ||
| H = G; | ||
| G = F; | ||
| F = E; | ||
| E = (D + T1) | 0; | ||
| D = C; | ||
| C = B; | ||
| B = A; | ||
| A = (T1 + T2) | 0; | ||
| } | ||
| // Add the compressed chunk to the current hash value | ||
| A = (A + this.A) | 0; | ||
| B = (B + this.B) | 0; | ||
| C = (C + this.C) | 0; | ||
| D = (D + this.D) | 0; | ||
| E = (E + this.E) | 0; | ||
| F = (F + this.F) | 0; | ||
| G = (G + this.G) | 0; | ||
| H = (H + this.H) | 0; | ||
| this.set(A, B, C, D, E, F, G, H); | ||
| } | ||
| roundClean() { | ||
| SHA256_W.fill(0); | ||
| } | ||
| destroy() { | ||
| this.set(0, 0, 0, 0, 0, 0, 0, 0); | ||
| this.buffer.fill(0); | ||
| } | ||
| } | ||
| /** | ||
| * SHA2-256 hash function | ||
| * @param message - data that would be hashed | ||
| */ | ||
| const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256()); | ||
| class Invoice { | ||
| constructor(args) { | ||
| this.paymentRequest = args.pr; | ||
| if (!this.paymentRequest) { | ||
| throw new Error("Invalid payment request"); | ||
| } | ||
| const decodedInvoice = decodeInvoice(this.paymentRequest); | ||
| if (!decodedInvoice) { | ||
| throw new Error("Failed to decode payment request"); | ||
| } | ||
| this.paymentHash = decodedInvoice.paymentHash; | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
| this.expiry = decodedInvoice.expiry; | ||
| this.createdDate = new Date(this.timestamp * 1000); | ||
| this.expiryDate = this.expiry | ||
| ? new Date((this.timestamp + this.expiry) * 1000) | ||
| : undefined; | ||
| this.description = decodedInvoice.description ?? null; | ||
| this.verify = args.verify ?? null; | ||
| this.preimage = args.preimage ?? null; | ||
| this.successAction = args.successAction ?? null; | ||
| } | ||
| async isPaid() { | ||
| if (this.preimage) | ||
| return this.validatePreimage(this.preimage); | ||
| else if (this.verify) { | ||
| return await this.verifyPayment(); | ||
| } | ||
| else { | ||
| throw new Error("Could not verify payment"); | ||
| } | ||
| } | ||
| validatePreimage(preimage) { | ||
| if (!preimage || !this.paymentHash) | ||
| return false; | ||
| try { | ||
| const preimageHash = bytesToHex(sha256(fromHexString(preimage))); | ||
| return this.paymentHash === preimageHash; | ||
| } | ||
| catch { | ||
| return false; | ||
| } | ||
| } | ||
| async verifyPayment() { | ||
| try { | ||
| if (!this.verify) { | ||
| throw new Error("LNURL verify not available"); | ||
| } | ||
| const response = await fetch(this.verify); | ||
| if (!response.ok) { | ||
| throw new Error(`Verification request failed: ${response.status} ${response.statusText}`); | ||
| } | ||
| const json = await response.json(); | ||
| if (json.preimage) { | ||
| this.preimage = json.preimage; | ||
| } | ||
| return json.settled; | ||
| } | ||
| catch (error) { | ||
| console.error("Failed to check LNURL-verify", error); | ||
| return false; | ||
| } | ||
| } | ||
| hasExpired() { | ||
| const { expiryDate } = this; | ||
| if (expiryDate) { | ||
| return expiryDate.getTime() < Date.now(); | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| const handleX402Payment = async (x402Header, url, fetchArgs, headers, wallet) => { | ||
| let parsed; | ||
| try { | ||
| parsed = JSON.parse(decodeURIComponent(escape(atob(x402Header)))); | ||
| } | ||
| catch (_) { | ||
| throw new Error("x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)"); | ||
| } | ||
| if (!Array.isArray(parsed.accepts) || parsed.accepts.length === 0) { | ||
| throw new Error("x402: PAYMENT-REQUIRED header contains no payment options"); | ||
| } | ||
| const requirements = parsed.accepts.find((e) => { | ||
| return e.extra?.paymentMethod === "lightning"; | ||
| }); | ||
| if (!requirements) { | ||
| throw new Error("x402: unsupported x402 network, only Bitcoin lightning network is supported."); | ||
| } | ||
| if (!requirements.extra?.invoice) { | ||
| throw new Error("x402: payment requirements missing lightning invoice"); | ||
| } | ||
| const invoice = new Invoice({ pr: requirements.extra.invoice }); | ||
| if (invoice.amountRaw != requirements.amount) { | ||
| throw new Error(`Invalid invoice amount: ${invoice.amountRaw}. expected ${requirements.amount}`); | ||
| } | ||
| await wallet.payInvoice({ invoice: invoice.paymentRequest }); | ||
| headers.set("payment-signature", buildX402PaymentSignature(requirements.scheme, requirements.network, invoice.paymentRequest, requirements)); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithX402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("PAYMENT-REQUIRED"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleX402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| exports.fetchWithX402 = fetchWithX402; | ||
| //# sourceMappingURL=x402.cjs.map |
Sorry, the diff of this file is too big to display
+1579
| function bytes(b, ...lengths) { | ||
| if (!(b instanceof Uint8Array)) | ||
| throw new Error('Expected Uint8Array'); | ||
| if (lengths.length > 0 && !lengths.includes(b.length)) | ||
| throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`); | ||
| } | ||
| function exists(instance, checkFinished = true) { | ||
| if (instance.destroyed) | ||
| throw new Error('Hash instance has been destroyed'); | ||
| if (checkFinished && instance.finished) | ||
| throw new Error('Hash#digest() has already been called'); | ||
| } | ||
| function output(out, instance) { | ||
| bytes(out); | ||
| const min = instance.outputLen; | ||
| if (out.length < min) { | ||
| throw new Error(`digestInto() expects output buffer of length at least ${min}`); | ||
| } | ||
| } | ||
| /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| // We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+. | ||
| // node.js versions earlier than v19 don't declare it in global scope. | ||
| // For node.js, package.json#exports field mapping rewrites import | ||
| // from `crypto` to `cryptoNode`, which imports native module. | ||
| // Makes the utils un-importable in browsers without a bundler. | ||
| // Once node.js 18 is deprecated, we can just drop the import. | ||
| const u8a = (a) => a instanceof Uint8Array; | ||
| // Cast array to view | ||
| const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength); | ||
| // The rotate right (circular right shift) operation for uint32 | ||
| const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift); | ||
| // big-endian hardware is rare. Just in case someone still decides to run hashes: | ||
| // early-throw an error because we don't support BE yet. | ||
| const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44; | ||
| if (!isLE) | ||
| throw new Error('Non little-endian hardware is not supported'); | ||
| const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0')); | ||
| /** | ||
| * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123' | ||
| */ | ||
| function bytesToHex(bytes) { | ||
| if (!u8a(bytes)) | ||
| throw new Error('Uint8Array expected'); | ||
| // pre-caching improves the speed 6x | ||
| let hex = ''; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| hex += hexes[bytes[i]]; | ||
| } | ||
| return hex; | ||
| } | ||
| /** | ||
| * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99]) | ||
| */ | ||
| function utf8ToBytes(str) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`utf8ToBytes expected string, got ${typeof str}`); | ||
| return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809 | ||
| } | ||
| /** | ||
| * Normalizes (non-hex) string or Uint8Array to Uint8Array. | ||
| * Warning: when Uint8Array is passed, it would NOT get copied. | ||
| * Keep in mind for future mutable operations. | ||
| */ | ||
| function toBytes(data) { | ||
| if (typeof data === 'string') | ||
| data = utf8ToBytes(data); | ||
| if (!u8a(data)) | ||
| throw new Error(`expected Uint8Array, got ${typeof data}`); | ||
| return data; | ||
| } | ||
| // For runtime check if class implements interface | ||
| class Hash { | ||
| // Safe version that clones internal state | ||
| clone() { | ||
| return this._cloneInto(); | ||
| } | ||
| } | ||
| function wrapConstructor(hashCons) { | ||
| const hashC = (msg) => hashCons().update(toBytes(msg)).digest(); | ||
| const tmp = hashCons(); | ||
| hashC.outputLen = tmp.outputLen; | ||
| hashC.blockLen = tmp.blockLen; | ||
| hashC.create = () => hashCons(); | ||
| return hashC; | ||
| } | ||
| // Polyfill for Safari 14 | ||
| function setBigUint64(view, byteOffset, value, isLE) { | ||
| if (typeof view.setBigUint64 === 'function') | ||
| return view.setBigUint64(byteOffset, value, isLE); | ||
| const _32n = BigInt(32); | ||
| const _u32_max = BigInt(0xffffffff); | ||
| const wh = Number((value >> _32n) & _u32_max); | ||
| const wl = Number(value & _u32_max); | ||
| const h = isLE ? 4 : 0; | ||
| const l = isLE ? 0 : 4; | ||
| view.setUint32(byteOffset + h, wh, isLE); | ||
| view.setUint32(byteOffset + l, wl, isLE); | ||
| } | ||
| // Base SHA2 class (RFC 6234) | ||
| class SHA2 extends Hash { | ||
| constructor(blockLen, outputLen, padOffset, isLE) { | ||
| super(); | ||
| this.blockLen = blockLen; | ||
| this.outputLen = outputLen; | ||
| this.padOffset = padOffset; | ||
| this.isLE = isLE; | ||
| this.finished = false; | ||
| this.length = 0; | ||
| this.pos = 0; | ||
| this.destroyed = false; | ||
| this.buffer = new Uint8Array(blockLen); | ||
| this.view = createView(this.buffer); | ||
| } | ||
| update(data) { | ||
| exists(this); | ||
| const { view, buffer, blockLen } = this; | ||
| data = toBytes(data); | ||
| const len = data.length; | ||
| for (let pos = 0; pos < len;) { | ||
| const take = Math.min(blockLen - this.pos, len - pos); | ||
| // Fast path: we have at least one block in input, cast it to view and process | ||
| if (take === blockLen) { | ||
| const dataView = createView(data); | ||
| for (; blockLen <= len - pos; pos += blockLen) | ||
| this.process(dataView, pos); | ||
| continue; | ||
| } | ||
| buffer.set(data.subarray(pos, pos + take), this.pos); | ||
| this.pos += take; | ||
| pos += take; | ||
| if (this.pos === blockLen) { | ||
| this.process(view, 0); | ||
| this.pos = 0; | ||
| } | ||
| } | ||
| this.length += data.length; | ||
| this.roundClean(); | ||
| return this; | ||
| } | ||
| digestInto(out) { | ||
| exists(this); | ||
| output(out, this); | ||
| this.finished = true; | ||
| // Padding | ||
| // We can avoid allocation of buffer for padding completely if it | ||
| // was previously not allocated here. But it won't change performance. | ||
| const { buffer, view, blockLen, isLE } = this; | ||
| let { pos } = this; | ||
| // append the bit '1' to the message | ||
| buffer[pos++] = 0b10000000; | ||
| this.buffer.subarray(pos).fill(0); | ||
| // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again | ||
| if (this.padOffset > blockLen - pos) { | ||
| this.process(view, 0); | ||
| pos = 0; | ||
| } | ||
| // Pad until full block byte with zeros | ||
| for (let i = pos; i < blockLen; i++) | ||
| buffer[i] = 0; | ||
| // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that | ||
| // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen. | ||
| // So we just write lowest 64 bits of that value. | ||
| setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE); | ||
| this.process(view, 0); | ||
| const oview = createView(out); | ||
| const len = this.outputLen; | ||
| // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT | ||
| if (len % 4) | ||
| throw new Error('_sha2: outputLen should be aligned to 32bit'); | ||
| const outLen = len / 4; | ||
| const state = this.get(); | ||
| if (outLen > state.length) | ||
| throw new Error('_sha2: outputLen bigger than state'); | ||
| for (let i = 0; i < outLen; i++) | ||
| oview.setUint32(4 * i, state[i], isLE); | ||
| } | ||
| digest() { | ||
| const { buffer, outputLen } = this; | ||
| this.digestInto(buffer); | ||
| const res = buffer.slice(0, outputLen); | ||
| this.destroy(); | ||
| return res; | ||
| } | ||
| _cloneInto(to) { | ||
| to || (to = new this.constructor()); | ||
| to.set(...this.get()); | ||
| const { blockLen, buffer, length, finished, destroyed, pos } = this; | ||
| to.length = length; | ||
| to.pos = pos; | ||
| to.finished = finished; | ||
| to.destroyed = destroyed; | ||
| if (length % blockLen) | ||
| to.buffer.set(buffer); | ||
| return to; | ||
| } | ||
| } | ||
| // SHA2-256 need to try 2^128 hashes to execute birthday attack. | ||
| // BTC network is doing 2^67 hashes/sec as per early 2023. | ||
| // Choice: a ? b : c | ||
| const Chi = (a, b, c) => (a & b) ^ (~a & c); | ||
| // Majority function, true if any two inpust is true | ||
| const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c); | ||
| // Round constants: | ||
| // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311) | ||
| // prettier-ignore | ||
| const SHA256_K = /* @__PURE__ */ new Uint32Array([ | ||
| 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | ||
| 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | ||
| 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | ||
| 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | ||
| 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | ||
| 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | ||
| 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | ||
| 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 | ||
| ]); | ||
| // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19): | ||
| // prettier-ignore | ||
| const IV = /* @__PURE__ */ new Uint32Array([ | ||
| 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 | ||
| ]); | ||
| // Temporary buffer, not used to store anything between runs | ||
| // Named this way because it matches specification. | ||
| const SHA256_W = /* @__PURE__ */ new Uint32Array(64); | ||
| class SHA256 extends SHA2 { | ||
| constructor() { | ||
| super(64, 32, 8, false); | ||
| // We cannot use array here since array allows indexing by variable | ||
| // which means optimizer/compiler cannot use registers. | ||
| this.A = IV[0] | 0; | ||
| this.B = IV[1] | 0; | ||
| this.C = IV[2] | 0; | ||
| this.D = IV[3] | 0; | ||
| this.E = IV[4] | 0; | ||
| this.F = IV[5] | 0; | ||
| this.G = IV[6] | 0; | ||
| this.H = IV[7] | 0; | ||
| } | ||
| get() { | ||
| const { A, B, C, D, E, F, G, H } = this; | ||
| return [A, B, C, D, E, F, G, H]; | ||
| } | ||
| // prettier-ignore | ||
| set(A, B, C, D, E, F, G, H) { | ||
| this.A = A | 0; | ||
| this.B = B | 0; | ||
| this.C = C | 0; | ||
| this.D = D | 0; | ||
| this.E = E | 0; | ||
| this.F = F | 0; | ||
| this.G = G | 0; | ||
| this.H = H | 0; | ||
| } | ||
| process(view, offset) { | ||
| // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array | ||
| for (let i = 0; i < 16; i++, offset += 4) | ||
| SHA256_W[i] = view.getUint32(offset, false); | ||
| for (let i = 16; i < 64; i++) { | ||
| const W15 = SHA256_W[i - 15]; | ||
| const W2 = SHA256_W[i - 2]; | ||
| const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3); | ||
| const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10); | ||
| SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0; | ||
| } | ||
| // Compression function main loop, 64 rounds | ||
| let { A, B, C, D, E, F, G, H } = this; | ||
| for (let i = 0; i < 64; i++) { | ||
| const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25); | ||
| const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0; | ||
| const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22); | ||
| const T2 = (sigma0 + Maj(A, B, C)) | 0; | ||
| H = G; | ||
| G = F; | ||
| F = E; | ||
| E = (D + T1) | 0; | ||
| D = C; | ||
| C = B; | ||
| B = A; | ||
| A = (T1 + T2) | 0; | ||
| } | ||
| // Add the compressed chunk to the current hash value | ||
| A = (A + this.A) | 0; | ||
| B = (B + this.B) | 0; | ||
| C = (C + this.C) | 0; | ||
| D = (D + this.D) | 0; | ||
| E = (E + this.E) | 0; | ||
| F = (F + this.F) | 0; | ||
| G = (G + this.G) | 0; | ||
| H = (H + this.H) | 0; | ||
| this.set(A, B, C, D, E, F, G, H); | ||
| } | ||
| roundClean() { | ||
| SHA256_W.fill(0); | ||
| } | ||
| destroy() { | ||
| this.set(0, 0, 0, 0, 0, 0, 0, 0); | ||
| this.buffer.fill(0); | ||
| } | ||
| } | ||
| /** | ||
| * SHA2-256 hash function | ||
| * @param message - data that would be hashed | ||
| */ | ||
| const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256()); | ||
| var lib = {}; | ||
| var hasRequiredLib; | ||
| function requireLib () { | ||
| if (hasRequiredLib) return lib; | ||
| hasRequiredLib = 1; | ||
| (function (exports) { | ||
| /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64url = exports.base64 = exports.base32crockford = exports.base32hex = exports.base32 = exports.base16 = exports.utils = exports.assertNumber = void 0; | ||
| function assertNumber(n) { | ||
| if (!Number.isSafeInteger(n)) | ||
| throw new Error(`Wrong integer: ${n}`); | ||
| } | ||
| exports.assertNumber = assertNumber; | ||
| function chain(...args) { | ||
| const wrap = (a, b) => (c) => a(b(c)); | ||
| const encode = Array.from(args) | ||
| .reverse() | ||
| .reduce((acc, i) => (acc ? wrap(acc, i.encode) : i.encode), undefined); | ||
| const decode = args.reduce((acc, i) => (acc ? wrap(acc, i.decode) : i.decode), undefined); | ||
| return { encode, decode }; | ||
| } | ||
| function alphabet(alphabet) { | ||
| return { | ||
| encode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('alphabet.encode input should be an array of numbers'); | ||
| return digits.map((i) => { | ||
| assertNumber(i); | ||
| if (i < 0 || i >= alphabet.length) | ||
| throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`); | ||
| return alphabet[i]; | ||
| }); | ||
| }, | ||
| decode: (input) => { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('alphabet.decode input should be array of strings'); | ||
| return input.map((letter) => { | ||
| if (typeof letter !== 'string') | ||
| throw new Error(`alphabet.decode: not string element=${letter}`); | ||
| const index = alphabet.indexOf(letter); | ||
| if (index === -1) | ||
| throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`); | ||
| return index; | ||
| }); | ||
| }, | ||
| }; | ||
| } | ||
| function join(separator = '') { | ||
| if (typeof separator !== 'string') | ||
| throw new Error('join separator should be string'); | ||
| return { | ||
| encode: (from) => { | ||
| if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string')) | ||
| throw new Error('join.encode input should be array of strings'); | ||
| for (let i of from) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`join.encode: non-string input=${i}`); | ||
| return from.join(separator); | ||
| }, | ||
| decode: (to) => { | ||
| if (typeof to !== 'string') | ||
| throw new Error('join.decode input should be string'); | ||
| return to.split(separator); | ||
| }, | ||
| }; | ||
| } | ||
| function padding(bits, chr = '=') { | ||
| assertNumber(bits); | ||
| if (typeof chr !== 'string') | ||
| throw new Error('padding chr should be string'); | ||
| return { | ||
| encode(data) { | ||
| if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of data) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.encode: non-string input=${i}`); | ||
| while ((data.length * bits) % 8) | ||
| data.push(chr); | ||
| return data; | ||
| }, | ||
| decode(input) { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of input) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.decode: non-string input=${i}`); | ||
| let end = input.length; | ||
| if ((end * bits) % 8) | ||
| throw new Error('Invalid padding: string should have whole number of bytes'); | ||
| for (; end > 0 && input[end - 1] === chr; end--) { | ||
| if (!(((end - 1) * bits) % 8)) | ||
| throw new Error('Invalid padding: string has too much padding'); | ||
| } | ||
| return input.slice(0, end); | ||
| }, | ||
| }; | ||
| } | ||
| function normalize(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('normalize fn should be function'); | ||
| return { encode: (from) => from, decode: (to) => fn(to) }; | ||
| } | ||
| function convertRadix(data, from, to) { | ||
| if (from < 2) | ||
| throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`); | ||
| if (to < 2) | ||
| throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`); | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix: data should be array'); | ||
| if (!data.length) | ||
| return []; | ||
| let pos = 0; | ||
| const res = []; | ||
| const digits = Array.from(data); | ||
| digits.forEach((d) => { | ||
| assertNumber(d); | ||
| if (d < 0 || d >= from) | ||
| throw new Error(`Wrong integer: ${d}`); | ||
| }); | ||
| while (true) { | ||
| let carry = 0; | ||
| let done = true; | ||
| for (let i = pos; i < digits.length; i++) { | ||
| const digit = digits[i]; | ||
| const digitBase = from * carry + digit; | ||
| if (!Number.isSafeInteger(digitBase) || | ||
| (from * carry) / from !== carry || | ||
| digitBase - digit !== from * carry) { | ||
| throw new Error('convertRadix: carry overflow'); | ||
| } | ||
| carry = digitBase % to; | ||
| digits[i] = Math.floor(digitBase / to); | ||
| if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase) | ||
| throw new Error('convertRadix: carry overflow'); | ||
| if (!done) | ||
| continue; | ||
| else if (!digits[i]) | ||
| pos = i; | ||
| else | ||
| done = false; | ||
| } | ||
| res.push(carry); | ||
| if (done) | ||
| break; | ||
| } | ||
| for (let i = 0; i < data.length - 1 && data[i] === 0; i++) | ||
| res.push(0); | ||
| return res.reverse(); | ||
| } | ||
| const gcd = (a, b) => (!b ? a : gcd(b, a % b)); | ||
| const radix2carry = (from, to) => from + (to - gcd(from, to)); | ||
| function convertRadix2(data, from, to, padding) { | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix2: data should be array'); | ||
| if (from <= 0 || from > 32) | ||
| throw new Error(`convertRadix2: wrong from=${from}`); | ||
| if (to <= 0 || to > 32) | ||
| throw new Error(`convertRadix2: wrong to=${to}`); | ||
| if (radix2carry(from, to) > 32) { | ||
| throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`); | ||
| } | ||
| let carry = 0; | ||
| let pos = 0; | ||
| const mask = 2 ** to - 1; | ||
| const res = []; | ||
| for (const n of data) { | ||
| assertNumber(n); | ||
| if (n >= 2 ** from) | ||
| throw new Error(`convertRadix2: invalid data word=${n} from=${from}`); | ||
| carry = (carry << from) | n; | ||
| if (pos + from > 32) | ||
| throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`); | ||
| pos += from; | ||
| for (; pos >= to; pos -= to) | ||
| res.push(((carry >> (pos - to)) & mask) >>> 0); | ||
| carry &= 2 ** pos - 1; | ||
| } | ||
| carry = (carry << (to - pos)) & mask; | ||
| if (!padding && pos >= from) | ||
| throw new Error('Excess padding'); | ||
| if (!padding && carry) | ||
| throw new Error(`Non-zero padding: ${carry}`); | ||
| if (padding && pos > 0) | ||
| res.push(carry >>> 0); | ||
| return res; | ||
| } | ||
| function radix(num) { | ||
| assertNumber(num); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix.encode input should be Uint8Array'); | ||
| return convertRadix(Array.from(bytes), 2 ** 8, num); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix(digits, num, 2 ** 8)); | ||
| }, | ||
| }; | ||
| } | ||
| function radix2(bits, revPadding = false) { | ||
| assertNumber(bits); | ||
| if (bits <= 0 || bits > 32) | ||
| throw new Error('radix2: bits should be in (0..32]'); | ||
| if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32) | ||
| throw new Error('radix2: carry overflow'); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix2.encode input should be Uint8Array'); | ||
| return convertRadix2(Array.from(bytes), 8, bits, !revPadding); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix2.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding)); | ||
| }, | ||
| }; | ||
| } | ||
| function unsafeWrapper(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('unsafeWrapper fn should be function'); | ||
| return function (...args) { | ||
| try { | ||
| return fn.apply(null, args); | ||
| } | ||
| catch (e) { } | ||
| }; | ||
| } | ||
| function checksum(len, fn) { | ||
| assertNumber(len); | ||
| if (typeof fn !== 'function') | ||
| throw new Error('checksum fn should be function'); | ||
| return { | ||
| encode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.encode: input should be Uint8Array'); | ||
| const checksum = fn(data).slice(0, len); | ||
| const res = new Uint8Array(data.length + len); | ||
| res.set(data); | ||
| res.set(checksum, data.length); | ||
| return res; | ||
| }, | ||
| decode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.decode: input should be Uint8Array'); | ||
| const payload = data.slice(0, -len); | ||
| const newChecksum = fn(payload).slice(0, len); | ||
| const oldChecksum = data.slice(-len); | ||
| for (let i = 0; i < len; i++) | ||
| if (newChecksum[i] !== oldChecksum[i]) | ||
| throw new Error('Invalid checksum'); | ||
| return payload; | ||
| }, | ||
| }; | ||
| } | ||
| exports.utils = { alphabet, chain, checksum, radix, radix2, join, padding }; | ||
| exports.base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join('')); | ||
| exports.base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join('')); | ||
| exports.base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join('')); | ||
| exports.base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1'))); | ||
| exports.base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join('')); | ||
| exports.base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join('')); | ||
| const genBase58 = (abc) => chain(radix(58), alphabet(abc), join('')); | ||
| exports.base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'); | ||
| exports.base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'); | ||
| exports.base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz'); | ||
| const XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11]; | ||
| exports.base58xmr = { | ||
| encode(data) { | ||
| let res = ''; | ||
| for (let i = 0; i < data.length; i += 8) { | ||
| const block = data.subarray(i, i + 8); | ||
| res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1'); | ||
| } | ||
| return res; | ||
| }, | ||
| decode(str) { | ||
| let res = []; | ||
| for (let i = 0; i < str.length; i += 11) { | ||
| const slice = str.slice(i, i + 11); | ||
| const blockLen = XMR_BLOCK_LEN.indexOf(slice.length); | ||
| const block = exports.base58.decode(slice); | ||
| for (let j = 0; j < block.length - blockLen; j++) { | ||
| if (block[j] !== 0) | ||
| throw new Error('base58xmr: wrong padding'); | ||
| } | ||
| res = res.concat(Array.from(block.slice(block.length - blockLen))); | ||
| } | ||
| return Uint8Array.from(res); | ||
| }, | ||
| }; | ||
| const base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), exports.base58); | ||
| exports.base58check = base58check; | ||
| const BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join('')); | ||
| const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; | ||
| function bech32Polymod(pre) { | ||
| const b = pre >> 25; | ||
| let chk = (pre & 0x1ffffff) << 5; | ||
| for (let i = 0; i < POLYMOD_GENERATORS.length; i++) { | ||
| if (((b >> i) & 1) === 1) | ||
| chk ^= POLYMOD_GENERATORS[i]; | ||
| } | ||
| return chk; | ||
| } | ||
| function bechChecksum(prefix, words, encodingConst = 1) { | ||
| const len = prefix.length; | ||
| let chk = 1; | ||
| for (let i = 0; i < len; i++) { | ||
| const c = prefix.charCodeAt(i); | ||
| if (c < 33 || c > 126) | ||
| throw new Error(`Invalid prefix (${prefix})`); | ||
| chk = bech32Polymod(chk) ^ (c >> 5); | ||
| } | ||
| chk = bech32Polymod(chk); | ||
| for (let i = 0; i < len; i++) | ||
| chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f); | ||
| for (let v of words) | ||
| chk = bech32Polymod(chk) ^ v; | ||
| for (let i = 0; i < 6; i++) | ||
| chk = bech32Polymod(chk); | ||
| chk ^= encodingConst; | ||
| return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false)); | ||
| } | ||
| function genBech32(encoding) { | ||
| const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3; | ||
| const _words = radix2(5); | ||
| const fromWords = _words.decode; | ||
| const toWords = _words.encode; | ||
| const fromWordsUnsafe = unsafeWrapper(fromWords); | ||
| function encode(prefix, words, limit = 90) { | ||
| if (typeof prefix !== 'string') | ||
| throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`); | ||
| if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number')) | ||
| throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`); | ||
| const actualLength = prefix.length + 7 + words.length; | ||
| if (limit !== false && actualLength > limit) | ||
| throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); | ||
| prefix = prefix.toLowerCase(); | ||
| return `${prefix}1${BECH_ALPHABET.encode(words)}${bechChecksum(prefix, words, ENCODING_CONST)}`; | ||
| } | ||
| function decode(str, limit = 90) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`bech32.decode input should be string, not ${typeof str}`); | ||
| if (str.length < 8 || (limit !== false && str.length > limit)) | ||
| throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`); | ||
| const lowered = str.toLowerCase(); | ||
| if (str !== lowered && str !== str.toUpperCase()) | ||
| throw new Error(`String must be lowercase or uppercase`); | ||
| str = lowered; | ||
| const sepIndex = str.lastIndexOf('1'); | ||
| if (sepIndex === 0 || sepIndex === -1) | ||
| throw new Error(`Letter "1" must be present between prefix and data only`); | ||
| const prefix = str.slice(0, sepIndex); | ||
| const _words = str.slice(sepIndex + 1); | ||
| if (_words.length < 6) | ||
| throw new Error('Data must be at least 6 characters long'); | ||
| const words = BECH_ALPHABET.decode(_words).slice(0, -6); | ||
| const sum = bechChecksum(prefix, words, ENCODING_CONST); | ||
| if (!_words.endsWith(sum)) | ||
| throw new Error(`Invalid checksum in ${str}: expected "${sum}"`); | ||
| return { prefix, words }; | ||
| } | ||
| const decodeUnsafe = unsafeWrapper(decode); | ||
| function decodeToBytes(str) { | ||
| const { prefix, words } = decode(str, false); | ||
| return { prefix, words, bytes: fromWords(words) }; | ||
| } | ||
| return { encode, decode, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords }; | ||
| } | ||
| exports.bech32 = genBech32('bech32'); | ||
| exports.bech32m = genBech32('bech32m'); | ||
| exports.utf8 = { | ||
| encode: (data) => new TextDecoder().decode(data), | ||
| decode: (str) => new TextEncoder().encode(str), | ||
| }; | ||
| exports.hex = chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => { | ||
| if (typeof s !== 'string' || s.length % 2) | ||
| throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`); | ||
| return s.toLowerCase(); | ||
| })); | ||
| const CODERS = { | ||
| utf8: exports.utf8, hex: exports.hex, base16: exports.base16, base32: exports.base32, base64: exports.base64, base64url: exports.base64url, base58: exports.base58, base58xmr: exports.base58xmr | ||
| }; | ||
| const coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`; | ||
| const bytesToString = (type, bytes) => { | ||
| if (typeof type !== 'string' || !CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new TypeError('bytesToString() expects Uint8Array'); | ||
| return CODERS[type].encode(bytes); | ||
| }; | ||
| exports.bytesToString = bytesToString; | ||
| exports.str = exports.bytesToString; | ||
| const stringToBytes = (type, str) => { | ||
| if (!CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (typeof str !== 'string') | ||
| throw new TypeError('stringToBytes() expects string'); | ||
| return CODERS[type].decode(str); | ||
| }; | ||
| exports.stringToBytes = stringToBytes; | ||
| exports.bytes = exports.stringToBytes; | ||
| } (lib)); | ||
| return lib; | ||
| } | ||
| var bolt11; | ||
| var hasRequiredBolt11; | ||
| function requireBolt11 () { | ||
| if (hasRequiredBolt11) return bolt11; | ||
| hasRequiredBolt11 = 1; | ||
| const {bech32, hex, utf8} = requireLib(); | ||
| // defaults for encode; default timestamp is current time at call | ||
| const DEFAULTNETWORK = { | ||
| // default network is bitcoin | ||
| bech32: 'bc', | ||
| pubKeyHash: 0x00, | ||
| scriptHash: 0x05, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const TESTNETWORK = { | ||
| bech32: 'tb', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIGNETNETWORK = { | ||
| bech32: 'tbs', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const REGTESTNETWORK = { | ||
| bech32: 'bcrt', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIMNETWORK = { | ||
| bech32: 'sb', | ||
| pubKeyHash: 0x3f, | ||
| scriptHash: 0x7b, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const FEATUREBIT_ORDER = [ | ||
| 'option_data_loss_protect', | ||
| 'initial_routing_sync', | ||
| 'option_upfront_shutdown_script', | ||
| 'gossip_queries', | ||
| 'var_onion_optin', | ||
| 'gossip_queries_ex', | ||
| 'option_static_remotekey', | ||
| 'payment_secret', | ||
| 'basic_mpp', | ||
| 'option_support_large_channel' | ||
| ]; | ||
| const DIVISORS = { | ||
| m: BigInt(1e3), | ||
| u: BigInt(1e6), | ||
| n: BigInt(1e9), | ||
| p: BigInt(1e12) | ||
| }; | ||
| const MAX_MILLISATS = BigInt('2100000000000000000'); | ||
| const MILLISATS_PER_BTC = BigInt(1e11); | ||
| const TAGCODES = { | ||
| payment_hash: 1, | ||
| payment_secret: 16, | ||
| description: 13, | ||
| payee: 19, | ||
| description_hash: 23, // commit to longer descriptions (used by lnurl-pay) | ||
| expiry: 6, // default: 3600 (1 hour) | ||
| min_final_cltv_expiry: 24, // default: 9 | ||
| fallback_address: 9, | ||
| route_hint: 3, // for extra routing info (private etc.) | ||
| feature_bits: 5, | ||
| metadata: 27 | ||
| }; | ||
| // reverse the keys and values of TAGCODES and insert into TAGNAMES | ||
| const TAGNAMES = {}; | ||
| for (let i = 0, keys = Object.keys(TAGCODES); i < keys.length; i++) { | ||
| const currentName = keys[i]; | ||
| const currentCode = TAGCODES[keys[i]].toString(); | ||
| TAGNAMES[currentCode] = currentName; | ||
| } | ||
| const TAGPARSERS = { | ||
| 1: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 16: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 13: words => utf8.encode(bech32.fromWordsUnsafe(words)), // string variable length | ||
| 19: words => hex.encode(bech32.fromWordsUnsafe(words)), // 264 bits | ||
| 23: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 27: words => hex.encode(bech32.fromWordsUnsafe(words)), // variable | ||
| 6: wordsToIntBE, // default: 3600 (1 hour) | ||
| 24: wordsToIntBE, // default: 9 | ||
| 3: routingInfoParser, // for extra routing info (private etc.) | ||
| 5: featureBitsParser // keep feature bits as array of 5 bit words | ||
| }; | ||
| function getUnknownParser(tagCode) { | ||
| return words => ({ | ||
| tagCode: parseInt(tagCode), | ||
| words: bech32.encode('unknown', words, Number.MAX_SAFE_INTEGER) | ||
| }) | ||
| } | ||
| function wordsToIntBE(words) { | ||
| return words.reverse().reduce((total, item, index) => { | ||
| return total + item * Math.pow(32, index) | ||
| }, 0) | ||
| } | ||
| // first convert from words to buffer, trimming padding where necessary | ||
| // parse in 51 byte chunks. See encoder for details. | ||
| function routingInfoParser(words) { | ||
| const routes = []; | ||
| let pubkey, | ||
| shortChannelId, | ||
| feeBaseMSats, | ||
| feeProportionalMillionths, | ||
| cltvExpiryDelta; | ||
| let routesBuffer = bech32.fromWordsUnsafe(words); | ||
| while (routesBuffer.length > 0) { | ||
| pubkey = hex.encode(routesBuffer.slice(0, 33)); // 33 bytes | ||
| shortChannelId = hex.encode(routesBuffer.slice(33, 41)); // 8 bytes | ||
| feeBaseMSats = parseInt(hex.encode(routesBuffer.slice(41, 45)), 16); // 4 bytes | ||
| feeProportionalMillionths = parseInt( | ||
| hex.encode(routesBuffer.slice(45, 49)), | ||
| 16 | ||
| ); // 4 bytes | ||
| cltvExpiryDelta = parseInt(hex.encode(routesBuffer.slice(49, 51)), 16); // 2 bytes | ||
| routesBuffer = routesBuffer.slice(51); | ||
| routes.push({ | ||
| pubkey, | ||
| short_channel_id: shortChannelId, | ||
| fee_base_msat: feeBaseMSats, | ||
| fee_proportional_millionths: feeProportionalMillionths, | ||
| cltv_expiry_delta: cltvExpiryDelta | ||
| }); | ||
| } | ||
| return routes | ||
| } | ||
| function featureBitsParser(words) { | ||
| const bools = words | ||
| .slice() | ||
| .reverse() | ||
| .map(word => [ | ||
| !!(word & 0b1), | ||
| !!(word & 0b10), | ||
| !!(word & 0b100), | ||
| !!(word & 0b1000), | ||
| !!(word & 0b10000) | ||
| ]) | ||
| .reduce((finalArr, itemArr) => finalArr.concat(itemArr), []); | ||
| while (bools.length < FEATUREBIT_ORDER.length * 2) { | ||
| bools.push(false); | ||
| } | ||
| const featureBits = {}; | ||
| FEATUREBIT_ORDER.forEach((featureName, index) => { | ||
| let status; | ||
| if (bools[index * 2]) { | ||
| status = 'required'; | ||
| } else if (bools[index * 2 + 1]) { | ||
| status = 'supported'; | ||
| } else { | ||
| status = 'unsupported'; | ||
| } | ||
| featureBits[featureName] = status; | ||
| }); | ||
| const extraBits = bools.slice(FEATUREBIT_ORDER.length * 2); | ||
| featureBits.extra_bits = { | ||
| start_bit: FEATUREBIT_ORDER.length * 2, | ||
| bits: extraBits, | ||
| has_required: extraBits.reduce( | ||
| (result, bit, index) => | ||
| index % 2 !== 0 ? result || false : result || bit, | ||
| false | ||
| ) | ||
| }; | ||
| return featureBits | ||
| } | ||
| function hrpToMillisat(hrpString, outputString) { | ||
| let divisor, value; | ||
| if (hrpString.slice(-1).match(/^[munp]$/)) { | ||
| divisor = hrpString.slice(-1); | ||
| value = hrpString.slice(0, -1); | ||
| } else if (hrpString.slice(-1).match(/^[^munp0-9]$/)) { | ||
| throw new Error('Not a valid multiplier for the amount') | ||
| } else { | ||
| value = hrpString; | ||
| } | ||
| if (!value.match(/^\d+$/)) | ||
| throw new Error('Not a valid human readable amount') | ||
| const valueBN = BigInt(value); | ||
| const millisatoshisBN = divisor | ||
| ? (valueBN * MILLISATS_PER_BTC) / DIVISORS[divisor] | ||
| : valueBN * MILLISATS_PER_BTC; | ||
| if ( | ||
| (divisor === 'p' && !(valueBN % BigInt(10) === BigInt(0))) || | ||
| millisatoshisBN > MAX_MILLISATS | ||
| ) { | ||
| throw new Error('Amount is outside of valid range') | ||
| } | ||
| return outputString ? millisatoshisBN.toString() : millisatoshisBN | ||
| } | ||
| // decode will only have extra comments that aren't covered in encode comments. | ||
| // also if anything is hard to read I'll comment. | ||
| function decode(paymentRequest, network) { | ||
| if (typeof paymentRequest !== 'string') | ||
| throw new Error('Lightning Payment Request must be string') | ||
| if (paymentRequest.slice(0, 2).toLowerCase() !== 'ln') | ||
| throw new Error('Not a proper lightning payment request') | ||
| const sections = []; | ||
| const decoded = bech32.decode(paymentRequest, Number.MAX_SAFE_INTEGER); | ||
| paymentRequest = paymentRequest.toLowerCase(); | ||
| const prefix = decoded.prefix; | ||
| let words = decoded.words; | ||
| let letters = paymentRequest.slice(prefix.length + 1); | ||
| let sigWords = words.slice(-104); | ||
| words = words.slice(0, -104); | ||
| // Without reverse lookups, can't say that the multipier at the end must | ||
| // have a number before it, so instead we parse, and if the second group | ||
| // doesn't have anything, there's a good chance the last letter of the | ||
| // coin type got captured by the third group, so just re-regex without | ||
| // the number. | ||
| let prefixMatches = prefix.match(/^ln(\S+?)(\d*)([a-zA-Z]?)$/); | ||
| if (prefixMatches && !prefixMatches[2]) | ||
| prefixMatches = prefix.match(/^ln(\S+)$/); | ||
| if (!prefixMatches) { | ||
| throw new Error('Not a proper lightning payment request') | ||
| } | ||
| // "ln" section | ||
| sections.push({ | ||
| name: 'lightning_network', | ||
| letters: 'ln' | ||
| }); | ||
| // "bc" section | ||
| const bech32Prefix = prefixMatches[1]; | ||
| let coinNetwork; | ||
| if (!network) { | ||
| switch (bech32Prefix) { | ||
| case DEFAULTNETWORK.bech32: | ||
| coinNetwork = DEFAULTNETWORK; | ||
| break | ||
| case TESTNETWORK.bech32: | ||
| coinNetwork = TESTNETWORK; | ||
| break | ||
| case SIGNETNETWORK.bech32: | ||
| coinNetwork = SIGNETNETWORK; | ||
| break | ||
| case REGTESTNETWORK.bech32: | ||
| coinNetwork = REGTESTNETWORK; | ||
| break | ||
| case SIMNETWORK.bech32: | ||
| coinNetwork = SIMNETWORK; | ||
| break | ||
| } | ||
| } else { | ||
| if ( | ||
| network.bech32 === undefined || | ||
| network.pubKeyHash === undefined || | ||
| network.scriptHash === undefined || | ||
| !Array.isArray(network.validWitnessVersions) | ||
| ) | ||
| throw new Error('Invalid network') | ||
| coinNetwork = network; | ||
| } | ||
| if (!coinNetwork || coinNetwork.bech32 !== bech32Prefix) { | ||
| throw new Error('Unknown coin bech32 prefix') | ||
| } | ||
| sections.push({ | ||
| name: 'coin_network', | ||
| letters: bech32Prefix, | ||
| value: coinNetwork | ||
| }); | ||
| // amount section | ||
| const value = prefixMatches[2]; | ||
| let millisatoshis; | ||
| if (value) { | ||
| const divisor = prefixMatches[3]; | ||
| millisatoshis = hrpToMillisat(value + divisor, true); | ||
| sections.push({ | ||
| name: 'amount', | ||
| letters: prefixMatches[2] + prefixMatches[3], | ||
| value: millisatoshis | ||
| }); | ||
| } else { | ||
| millisatoshis = null; | ||
| } | ||
| // "1" separator | ||
| sections.push({ | ||
| name: 'separator', | ||
| letters: '1' | ||
| }); | ||
| // timestamp | ||
| const timestamp = wordsToIntBE(words.slice(0, 7)); | ||
| words = words.slice(7); // trim off the left 7 words | ||
| sections.push({ | ||
| name: 'timestamp', | ||
| letters: letters.slice(0, 7), | ||
| value: timestamp | ||
| }); | ||
| letters = letters.slice(7); | ||
| let tagName, parser, tagLength, tagWords; | ||
| // we have no tag count to go on, so just keep hacking off words | ||
| // until we have none. | ||
| while (words.length > 0) { | ||
| const tagCode = words[0].toString(); | ||
| tagName = TAGNAMES[tagCode] || 'unknown_tag'; | ||
| parser = TAGPARSERS[tagCode] || getUnknownParser(tagCode); | ||
| words = words.slice(1); | ||
| tagLength = wordsToIntBE(words.slice(0, 2)); | ||
| words = words.slice(2); | ||
| tagWords = words.slice(0, tagLength); | ||
| words = words.slice(tagLength); | ||
| sections.push({ | ||
| name: tagName, | ||
| tag: letters[0], | ||
| letters: letters.slice(0, 1 + 2 + tagLength), | ||
| value: parser(tagWords) // see: parsers for more comments | ||
| }); | ||
| letters = letters.slice(1 + 2 + tagLength); | ||
| } | ||
| // signature | ||
| sections.push({ | ||
| name: 'signature', | ||
| letters: letters.slice(0, 104), | ||
| value: hex.encode(bech32.fromWordsUnsafe(sigWords)) | ||
| }); | ||
| letters = letters.slice(104); | ||
| // checksum | ||
| sections.push({ | ||
| name: 'checksum', | ||
| letters: letters | ||
| }); | ||
| let result = { | ||
| paymentRequest, | ||
| sections, | ||
| get expiry() { | ||
| let exp = sections.find(s => s.name === 'expiry'); | ||
| if (exp) return getValue('timestamp') + exp.value | ||
| }, | ||
| get route_hints() { | ||
| return sections.filter(s => s.name === 'route_hint').map(s => s.value) | ||
| } | ||
| }; | ||
| for (let name in TAGCODES) { | ||
| if (name === 'route_hint') { | ||
| // route hints can be multiple, so this won't work for them | ||
| continue | ||
| } | ||
| Object.defineProperty(result, name, { | ||
| get() { | ||
| return getValue(name) | ||
| } | ||
| }); | ||
| } | ||
| return result | ||
| function getValue(name) { | ||
| let section = sections.find(s => s.name === name); | ||
| return section ? section.value : undefined | ||
| } | ||
| } | ||
| bolt11 = { | ||
| decode, | ||
| hrpToMillisat | ||
| }; | ||
| return bolt11; | ||
| } | ||
| var bolt11Exports = requireBolt11(); | ||
| // from https://stackoverflow.com/a/50868276 | ||
| const fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))); | ||
| const decodeInvoice = (paymentRequest) => { | ||
| if (!paymentRequest) | ||
| return null; | ||
| try { | ||
| const decoded = bolt11Exports.decode(paymentRequest); | ||
| if (!decoded || !decoded.sections) | ||
| return null; | ||
| const hashTag = decoded.sections.find((value) => value.name === "payment_hash"); | ||
| if (hashTag?.name !== "payment_hash" || !hashTag.value) | ||
| return null; | ||
| const paymentHash = hashTag.value; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
| } | ||
| const timestampTag = decoded.sections.find((value) => value.name === "timestamp"); | ||
| if (timestampTag?.name !== "timestamp" || !timestampTag.value) | ||
| return null; | ||
| const timestamp = timestampTag.value; | ||
| let expiry; | ||
| const expiryTag = decoded.sections.find((value) => value.name === "expiry"); | ||
| if (expiryTag?.name === "expiry") { | ||
| expiry = expiryTag.value; | ||
| } | ||
| const descriptionTag = decoded.sections.find((value) => value.name === "description"); | ||
| const description = descriptionTag?.name === "description" | ||
| ? descriptionTag?.value | ||
| : undefined; | ||
| return { | ||
| paymentHash, | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
| expiry, | ||
| description, | ||
| }; | ||
| } | ||
| catch { | ||
| return null; | ||
| } | ||
| }; | ||
| class Invoice { | ||
| constructor(args) { | ||
| this.paymentRequest = args.pr; | ||
| if (!this.paymentRequest) { | ||
| throw new Error("Invalid payment request"); | ||
| } | ||
| const decodedInvoice = decodeInvoice(this.paymentRequest); | ||
| if (!decodedInvoice) { | ||
| throw new Error("Failed to decode payment request"); | ||
| } | ||
| this.paymentHash = decodedInvoice.paymentHash; | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
| this.expiry = decodedInvoice.expiry; | ||
| this.createdDate = new Date(this.timestamp * 1000); | ||
| this.expiryDate = this.expiry | ||
| ? new Date((this.timestamp + this.expiry) * 1000) | ||
| : undefined; | ||
| this.description = decodedInvoice.description ?? null; | ||
| this.verify = args.verify ?? null; | ||
| this.preimage = args.preimage ?? null; | ||
| this.successAction = args.successAction ?? null; | ||
| } | ||
| async isPaid() { | ||
| if (this.preimage) | ||
| return this.validatePreimage(this.preimage); | ||
| else if (this.verify) { | ||
| return await this.verifyPayment(); | ||
| } | ||
| else { | ||
| throw new Error("Could not verify payment"); | ||
| } | ||
| } | ||
| validatePreimage(preimage) { | ||
| if (!preimage || !this.paymentHash) | ||
| return false; | ||
| try { | ||
| const preimageHash = bytesToHex(sha256(fromHexString(preimage))); | ||
| return this.paymentHash === preimageHash; | ||
| } | ||
| catch { | ||
| return false; | ||
| } | ||
| } | ||
| async verifyPayment() { | ||
| try { | ||
| if (!this.verify) { | ||
| throw new Error("LNURL verify not available"); | ||
| } | ||
| const response = await fetch(this.verify); | ||
| if (!response.ok) { | ||
| throw new Error(`Verification request failed: ${response.status} ${response.statusText}`); | ||
| } | ||
| const json = await response.json(); | ||
| if (json.preimage) { | ||
| this.preimage = json.preimage; | ||
| } | ||
| return json.settled; | ||
| } | ||
| catch (error) { | ||
| console.error("Failed to check LNURL-verify", error); | ||
| return false; | ||
| } | ||
| } | ||
| hasExpired() { | ||
| const { expiryDate } = this; | ||
| if (expiryDate) { | ||
| return expiryDate.getTime() < Date.now(); | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| function createGuardedWallet(wallet, maxAmountSats) { | ||
| return { | ||
| payInvoice: async (args) => { | ||
| const invoice = new Invoice({ pr: args.invoice }); | ||
| if (invoice.satoshi > maxAmountSats) { | ||
| throw new Error(`Invoice amount (${invoice.satoshi} sats) exceeds maxAmount (${maxAmountSats} sats)`); | ||
| } | ||
| return wallet.payInvoice(args); | ||
| }, | ||
| }; | ||
| } | ||
| const parseL402 = (input) => { | ||
| // Remove the L402 and LSAT identifiers | ||
| const string = input.replace("L402", "").replace("LSAT", "").trim(); | ||
| // Initialize an object to store the key-value pairs | ||
| const keyValuePairs = {}; | ||
| // Regular expression to match key and (quoted or unquoted) value | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g; | ||
| let match; | ||
| // Use regex to find all key-value pairs | ||
| while ((match = regex.exec(string)) !== null) { | ||
| // Key is always match[1] | ||
| // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted) | ||
| keyValuePairs[match[1]] = match[3] || match[4] || match[5]; | ||
| } | ||
| return keyValuePairs; | ||
| }; | ||
| const handleL402Payment = async (l402Header, url, fetchArgs, headers, wallet) => { | ||
| const details = parseL402(l402Header); | ||
| const token = details.token || details.macaroon; | ||
| const invoice = details.invoice; | ||
| if (!token) { | ||
| throw new Error("L402: missing token/macaroon in WWW-Authenticate header"); | ||
| } | ||
| if (!invoice) { | ||
| throw new Error("L402: missing invoice in WWW-Authenticate header"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| headers.set("Authorization", `L402 ${token}:${invResp.preimage}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithL402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("www-authenticate"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleL402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| const buildX402PaymentSignature = (scheme, network, invoice, requirements) => { | ||
| const json = JSON.stringify({ | ||
| x402Version: 2, | ||
| scheme, | ||
| network, | ||
| payload: { invoice }, | ||
| accepted: requirements, | ||
| }); | ||
| // btoa only handles latin1; encode via UTF-8 to be safe | ||
| return btoa(unescape(encodeURIComponent(json))); | ||
| }; | ||
| const handleX402Payment = async (x402Header, url, fetchArgs, headers, wallet) => { | ||
| let parsed; | ||
| try { | ||
| parsed = JSON.parse(decodeURIComponent(escape(atob(x402Header)))); | ||
| } | ||
| catch (_) { | ||
| throw new Error("x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)"); | ||
| } | ||
| if (!Array.isArray(parsed.accepts) || parsed.accepts.length === 0) { | ||
| throw new Error("x402: PAYMENT-REQUIRED header contains no payment options"); | ||
| } | ||
| const requirements = parsed.accepts.find((e) => { | ||
| return e.extra?.paymentMethod === "lightning"; | ||
| }); | ||
| if (!requirements) { | ||
| throw new Error("x402: unsupported x402 network, only Bitcoin lightning network is supported."); | ||
| } | ||
| if (!requirements.extra?.invoice) { | ||
| throw new Error("x402: payment requirements missing lightning invoice"); | ||
| } | ||
| const invoice = new Invoice({ pr: requirements.extra.invoice }); | ||
| if (invoice.amountRaw != requirements.amount) { | ||
| throw new Error(`Invalid invoice amount: ${invoice.amountRaw}. expected ${requirements.amount}`); | ||
| } | ||
| await wallet.payInvoice({ invoice: invoice.paymentRequest }); | ||
| headers.set("payment-signature", buildX402PaymentSignature(requirements.scheme, requirements.network, invoice.paymentRequest, requirements)); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithX402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("PAYMENT-REQUIRED"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleX402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| /** | ||
| * Parse a `WWW-Authenticate: Payment …` header produced by a | ||
| * draft-lightning-charge-00 server. Expected format: | ||
| * | ||
| * Payment id="<id>", realm="<realm>", method="lightning", | ||
| * intent="charge", request="<base64url>" [, expires="<rfc3339>"] | ||
| * | ||
| * Returns null when the header is not a Payment lightning/charge challenge. | ||
| */ | ||
| const parseMppChallenge = (header) => { | ||
| if (!header.trimStart().toLowerCase().startsWith("payment")) { | ||
| return null; | ||
| } | ||
| const rest = header | ||
| .slice(header.toLowerCase().indexOf("payment") + "payment".length) | ||
| .trim(); | ||
| const result = {}; | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,\s]*))/g; | ||
| let match; | ||
| while ((match = regex.exec(rest)) !== null) { | ||
| result[match[1]] = match[3] ?? match[4] ?? match[5] ?? ""; | ||
| } | ||
| if (result.method !== "lightning" || | ||
| result.intent !== "charge" || | ||
| !result.id || | ||
| !result.realm || | ||
| !result.request) { | ||
| return null; | ||
| } | ||
| return { | ||
| id: result.id, | ||
| realm: result.realm, | ||
| method: result.method, | ||
| intent: result.intent, | ||
| request: result.request, | ||
| ...(result.expires ? { expires: result.expires } : {}), | ||
| }; | ||
| }; | ||
| /** Decode a base64url string (no padding required) to a UTF-8 string. */ | ||
| const decodeBase64url = (input) => { | ||
| const base64 = input.replace(/-/g, "+").replace(/_/g, "/"); | ||
| const binary = atob(base64); | ||
| const bytes = new Uint8Array(binary.length); | ||
| for (let i = 0; i < binary.length; i++) { | ||
| bytes[i] = binary.charCodeAt(i); | ||
| } | ||
| return new TextDecoder("utf-8").decode(bytes); | ||
| }; | ||
| /** Encode a UTF-8 string to base64url without padding. */ | ||
| const encodeBase64url = (input) => { | ||
| const bytes = new TextEncoder().encode(input); | ||
| let binary = ""; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| binary += String.fromCharCode(bytes[i]); | ||
| } | ||
| return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); | ||
| }; | ||
| /** | ||
| * JSON Canonicalization Scheme (RFC 8785). | ||
| * Produces compact JSON with object keys sorted lexicographically. | ||
| */ | ||
| const jcs = (value) => { | ||
| if (value === null || typeof value !== "object") { | ||
| return JSON.stringify(value); | ||
| } | ||
| if (Array.isArray(value)) { | ||
| return "[" + value.map(jcs).join(",") + "]"; | ||
| } | ||
| const keys = Object.keys(value).sort(); | ||
| return ("{" + | ||
| keys | ||
| .map((k) => JSON.stringify(k) + ":" + jcs(value[k])) | ||
| .join(",") + | ||
| "}"); | ||
| }; | ||
| /** | ||
| * Build the base64url-encoded credential token for the `Authorization` header. | ||
| * | ||
| * Per the spec the credential is a JCS-serialised JSON object that echoes all | ||
| * challenge auth-params (id, realm, method, intent, request, expires) and | ||
| * carries the HTLC preimage that proves payment: | ||
| * | ||
| * { | ||
| * "challenge": { "id": "…", "intent": "charge", | ||
| * "method": "lightning", "realm": "…", "request": "…" }, | ||
| * "payload": { "preimage": "<64-char lowercase hex>" } | ||
| * } | ||
| * | ||
| * Keys are sorted lexicographically at every level per JCS. | ||
| */ | ||
| const buildMppCredential = (challenge, preimage, source) => { | ||
| const challengeEcho = { | ||
| id: challenge.id, | ||
| intent: challenge.intent, | ||
| method: challenge.method, | ||
| realm: challenge.realm, | ||
| request: challenge.request, | ||
| }; | ||
| if (challenge.expires) { | ||
| challengeEcho.expires = challenge.expires; | ||
| } | ||
| const credential = { | ||
| challenge: challengeEcho, | ||
| payload: { preimage }, | ||
| }; | ||
| return encodeBase64url(jcs(credential)); | ||
| }; | ||
| /** | ||
| * Handle a `WWW-Authenticate: Payment …` challenge produced by a | ||
| * draft-lightning-charge-00 server. | ||
| * | ||
| * Flow: | ||
| * 1. Parse the challenge from the header. | ||
| * 2. Decode the `request` auth-param to find the BOLT11 invoice. | ||
| * 3. Pay the invoice via the wallet; receive the HTLC preimage. | ||
| * 4. Build the `Authorization: Payment <credential>` header. | ||
| * 5. Retry the original request with the credential. | ||
| */ | ||
| const handleMppChargePayment = async (wwwAuthHeader, url, fetchArgs, headers, wallet) => { | ||
| const challenge = parseMppChallenge(wwwAuthHeader); | ||
| if (!challenge) { | ||
| throw new Error("mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)"); | ||
| } | ||
| let request; | ||
| try { | ||
| request = JSON.parse(decodeBase64url(challenge.request)); | ||
| } | ||
| catch (_) { | ||
| throw new Error("mpp: invalid request auth-param (not valid base64url-encoded JSON)"); | ||
| } | ||
| const invoice = request.methodDetails?.invoice; | ||
| if (!invoice) { | ||
| throw new Error("mpp: missing invoice in charge request"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| // Per spec: Authorization: Payment <base64url-token> (single token, no wrapper) | ||
| const credential = buildMppCredential(challenge, invResp.preimage); | ||
| headers.set("Authorization", `Payment ${credential}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| const fetchWithMpp = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const wwwAuthHeader = initResp.headers.get("www-authenticate"); | ||
| if (!wwwAuthHeader || | ||
| !wwwAuthHeader.trimStart().toLowerCase().startsWith("payment")) { | ||
| return initResp; | ||
| } | ||
| return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| }; | ||
| const fetch402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.maxAmount | ||
| ? createGuardedWallet(options.wallet, options.maxAmount) | ||
| : options.wallet; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const wwwAuthHeader = initResp.headers.get("www-authenticate"); | ||
| if (wwwAuthHeader) { | ||
| const trimmed = wwwAuthHeader.trimStart().toLowerCase(); | ||
| if (trimmed.startsWith("payment")) { | ||
| return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| } | ||
| if (trimmed.startsWith("l402") || trimmed.startsWith("lsat")) { | ||
| return handleL402Payment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| } | ||
| throw new Error(`fetch402: unsupported WWW-Authenticate scheme: ${wwwAuthHeader}`); | ||
| } | ||
| const x402Header = initResp.headers.get("PAYMENT-REQUIRED"); | ||
| if (x402Header) { | ||
| return handleX402Payment(x402Header, url, fetchArgs, headers, wallet); | ||
| } | ||
| return initResp; | ||
| }; | ||
| export { createGuardedWallet, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402 }; | ||
| //# sourceMappingURL=402.js.map |
Sorry, the diff of this file is too big to display
| const parseL402 = (input) => { | ||
| // Remove the L402 and LSAT identifiers | ||
| const string = input.replace("L402", "").replace("LSAT", "").trim(); | ||
| // Initialize an object to store the key-value pairs | ||
| const keyValuePairs = {}; | ||
| // Regular expression to match key and (quoted or unquoted) value | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g; | ||
| let match; | ||
| // Use regex to find all key-value pairs | ||
| while ((match = regex.exec(string)) !== null) { | ||
| // Key is always match[1] | ||
| // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted) | ||
| keyValuePairs[match[1]] = match[3] || match[4] || match[5]; | ||
| } | ||
| return keyValuePairs; | ||
| }; | ||
| const handleL402Payment = async (l402Header, url, fetchArgs, headers, wallet) => { | ||
| const details = parseL402(l402Header); | ||
| const token = details.token || details.macaroon; | ||
| const invoice = details.invoice; | ||
| if (!token) { | ||
| throw new Error("L402: missing token/macaroon in WWW-Authenticate header"); | ||
| } | ||
| if (!invoice) { | ||
| throw new Error("L402: missing invoice in WWW-Authenticate header"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| headers.set("Authorization", `L402 ${token}:${invResp.preimage}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithL402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("www-authenticate"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleL402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| export { fetchWithL402 }; | ||
| //# sourceMappingURL=l402.js.map |
| {"version":3,"file":"l402.js","sources":["../../../src/402/l402/utils.ts","../../../src/402/l402/l402.ts"],"sourcesContent":["export const parseL402 = (input: string): Record<string, string> => {\n // Remove the L402 and LSAT identifiers\n const string = input.replace(\"L402\", \"\").replace(\"LSAT\", \"\").trim();\n\n // Initialize an object to store the key-value pairs\n const keyValuePairs = {};\n\n // Regular expression to match key and (quoted or unquoted) value\n const regex = /(\\w+)=(\"([^\"]*)\"|'([^']*)'|([^,]*))/g;\n let match;\n\n // Use regex to find all key-value pairs\n while ((match = regex.exec(string)) !== null) {\n // Key is always match[1]\n // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted)\n keyValuePairs[match[1]] = match[3] || match[4] || match[5];\n }\n\n return keyValuePairs;\n};\n\nexport const makeL402AuthenticateHeader = (args: {\n macaroon?: string;\n token?: string;\n invoice: string;\n}) => {\n if (args.macaroon) {\n return `L402 version=\"0\" macaroon=\"${args.macaroon}\", invoice=\"${args.invoice}\"`;\n } else {\n return `L402 version=\"0\" token=\"${args.token}\", invoice=\"${args.invoice}\"`;\n }\n};\n","import { Wallet } from \"../utils\";\nimport { parseL402 } from \"./utils\";\n\nexport const handleL402Payment = async (\n l402Header: string,\n url: string,\n fetchArgs: RequestInit,\n headers: Headers,\n wallet: Wallet,\n): Promise<Response> => {\n const details = parseL402(l402Header);\n const token = details.token || details.macaroon;\n const invoice = details.invoice;\n\n if (!token) {\n throw new Error(\"L402: missing token/macaroon in WWW-Authenticate header\");\n }\n if (!invoice) {\n throw new Error(\"L402: missing invoice in WWW-Authenticate header\");\n }\n\n const invResp = await wallet.payInvoice({ invoice });\n headers.set(\"Authorization\", `L402 ${token}:${invResp.preimage}`);\n return fetch(url, fetchArgs);\n};\n\nexport const fetchWithL402 = async (\n url: string,\n fetchArgs: RequestInit,\n options: {\n wallet: Wallet;\n },\n) => {\n const wallet = options.wallet;\n if (!wallet) {\n throw new Error(\"wallet is missing\");\n }\n if (!fetchArgs) {\n fetchArgs = {};\n }\n fetchArgs.cache = \"no-store\";\n fetchArgs.mode = \"cors\";\n const headers = new Headers(fetchArgs.headers ?? undefined);\n fetchArgs.headers = headers;\n\n const initResp = await fetch(url, fetchArgs);\n const header = initResp.headers.get(\"www-authenticate\");\n if (!header) {\n return initResp;\n }\n\n return handleL402Payment(header, url, fetchArgs, headers, wallet);\n};\n"],"names":[],"mappings":"AAAO,MAAM,SAAS,GAAG,CAAC,KAAa,KAA4B;;IAEjE,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE;;IAGnE,MAAM,aAAa,GAAG,EAAE;;IAGxB,MAAM,KAAK,GAAG,sCAAsC;AACpD,IAAA,IAAI,KAAK;;AAGT,IAAA,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE;;;QAG5C,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;IAC5D;AAEA,IAAA,OAAO,aAAa;AACtB,CAAC;;AChBM,MAAM,iBAAiB,GAAG,OAC/B,UAAkB,EAClB,GAAW,EACX,SAAsB,EACtB,OAAgB,EAChB,MAAc,KACO;AACrB,IAAA,MAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC;IACrC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ;AAC/C,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO;IAE/B,IAAI,CAAC,KAAK,EAAE;AACV,QAAA,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC;IAC5E;IACA,IAAI,CAAC,OAAO,EAAE;AACZ,QAAA,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC;IACrE;IAEA,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,CAAC;AACpD,IAAA,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,EAAI,OAAO,CAAC,QAAQ,CAAA,CAAE,CAAC;AACjE,IAAA,OAAO,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;AAC9B,CAAC;AAEM,MAAM,aAAa,GAAG,OAC3B,GAAW,EACX,SAAsB,EACtB,OAEC,KACC;AACF,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM;IAC7B,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IACtC;IACA,IAAI,CAAC,SAAS,EAAE;QACd,SAAS,GAAG,EAAE;IAChB;AACA,IAAA,SAAS,CAAC,KAAK,GAAG,UAAU;AAC5B,IAAA,SAAS,CAAC,IAAI,GAAG,MAAM;IACvB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC;AAC3D,IAAA,SAAS,CAAC,OAAO,GAAG,OAAO;IAE3B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IACvD,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,OAAO,QAAQ;IACjB;AAEA,IAAA,OAAO,iBAAiB,CAAC,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC;AACnE;;;;"} |
| /** | ||
| * Parse a `WWW-Authenticate: Payment …` header produced by a | ||
| * draft-lightning-charge-00 server. Expected format: | ||
| * | ||
| * Payment id="<id>", realm="<realm>", method="lightning", | ||
| * intent="charge", request="<base64url>" [, expires="<rfc3339>"] | ||
| * | ||
| * Returns null when the header is not a Payment lightning/charge challenge. | ||
| */ | ||
| const parseMppChallenge = (header) => { | ||
| if (!header.trimStart().toLowerCase().startsWith("payment")) { | ||
| return null; | ||
| } | ||
| const rest = header | ||
| .slice(header.toLowerCase().indexOf("payment") + "payment".length) | ||
| .trim(); | ||
| const result = {}; | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,\s]*))/g; | ||
| let match; | ||
| while ((match = regex.exec(rest)) !== null) { | ||
| result[match[1]] = match[3] ?? match[4] ?? match[5] ?? ""; | ||
| } | ||
| if (result.method !== "lightning" || | ||
| result.intent !== "charge" || | ||
| !result.id || | ||
| !result.realm || | ||
| !result.request) { | ||
| return null; | ||
| } | ||
| return { | ||
| id: result.id, | ||
| realm: result.realm, | ||
| method: result.method, | ||
| intent: result.intent, | ||
| request: result.request, | ||
| ...(result.expires ? { expires: result.expires } : {}), | ||
| }; | ||
| }; | ||
| /** Decode a base64url string (no padding required) to a UTF-8 string. */ | ||
| const decodeBase64url = (input) => { | ||
| const base64 = input.replace(/-/g, "+").replace(/_/g, "/"); | ||
| const binary = atob(base64); | ||
| const bytes = new Uint8Array(binary.length); | ||
| for (let i = 0; i < binary.length; i++) { | ||
| bytes[i] = binary.charCodeAt(i); | ||
| } | ||
| return new TextDecoder("utf-8").decode(bytes); | ||
| }; | ||
| /** Encode a UTF-8 string to base64url without padding. */ | ||
| const encodeBase64url = (input) => { | ||
| const bytes = new TextEncoder().encode(input); | ||
| let binary = ""; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| binary += String.fromCharCode(bytes[i]); | ||
| } | ||
| return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); | ||
| }; | ||
| /** | ||
| * JSON Canonicalization Scheme (RFC 8785). | ||
| * Produces compact JSON with object keys sorted lexicographically. | ||
| */ | ||
| const jcs = (value) => { | ||
| if (value === null || typeof value !== "object") { | ||
| return JSON.stringify(value); | ||
| } | ||
| if (Array.isArray(value)) { | ||
| return "[" + value.map(jcs).join(",") + "]"; | ||
| } | ||
| const keys = Object.keys(value).sort(); | ||
| return ("{" + | ||
| keys | ||
| .map((k) => JSON.stringify(k) + ":" + jcs(value[k])) | ||
| .join(",") + | ||
| "}"); | ||
| }; | ||
| /** | ||
| * Build the base64url-encoded credential token for the `Authorization` header. | ||
| * | ||
| * Per the spec the credential is a JCS-serialised JSON object that echoes all | ||
| * challenge auth-params (id, realm, method, intent, request, expires) and | ||
| * carries the HTLC preimage that proves payment: | ||
| * | ||
| * { | ||
| * "challenge": { "id": "…", "intent": "charge", | ||
| * "method": "lightning", "realm": "…", "request": "…" }, | ||
| * "payload": { "preimage": "<64-char lowercase hex>" } | ||
| * } | ||
| * | ||
| * Keys are sorted lexicographically at every level per JCS. | ||
| */ | ||
| const buildMppCredential = (challenge, preimage, source) => { | ||
| const challengeEcho = { | ||
| id: challenge.id, | ||
| intent: challenge.intent, | ||
| method: challenge.method, | ||
| realm: challenge.realm, | ||
| request: challenge.request, | ||
| }; | ||
| if (challenge.expires) { | ||
| challengeEcho.expires = challenge.expires; | ||
| } | ||
| const credential = { | ||
| challenge: challengeEcho, | ||
| payload: { preimage }, | ||
| }; | ||
| return encodeBase64url(jcs(credential)); | ||
| }; | ||
| /** | ||
| * Handle a `WWW-Authenticate: Payment …` challenge produced by a | ||
| * draft-lightning-charge-00 server. | ||
| * | ||
| * Flow: | ||
| * 1. Parse the challenge from the header. | ||
| * 2. Decode the `request` auth-param to find the BOLT11 invoice. | ||
| * 3. Pay the invoice via the wallet; receive the HTLC preimage. | ||
| * 4. Build the `Authorization: Payment <credential>` header. | ||
| * 5. Retry the original request with the credential. | ||
| */ | ||
| const handleMppChargePayment = async (wwwAuthHeader, url, fetchArgs, headers, wallet) => { | ||
| const challenge = parseMppChallenge(wwwAuthHeader); | ||
| if (!challenge) { | ||
| throw new Error("mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)"); | ||
| } | ||
| let request; | ||
| try { | ||
| request = JSON.parse(decodeBase64url(challenge.request)); | ||
| } | ||
| catch (_) { | ||
| throw new Error("mpp: invalid request auth-param (not valid base64url-encoded JSON)"); | ||
| } | ||
| const invoice = request.methodDetails?.invoice; | ||
| if (!invoice) { | ||
| throw new Error("mpp: missing invoice in charge request"); | ||
| } | ||
| const invResp = await wallet.payInvoice({ invoice }); | ||
| // Per spec: Authorization: Payment <base64url-token> (single token, no wrapper) | ||
| const credential = buildMppCredential(challenge, invResp.preimage); | ||
| headers.set("Authorization", `Payment ${credential}`); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| const fetchWithMpp = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const wwwAuthHeader = initResp.headers.get("www-authenticate"); | ||
| if (!wwwAuthHeader || | ||
| !wwwAuthHeader.trimStart().toLowerCase().startsWith("payment")) { | ||
| return initResp; | ||
| } | ||
| return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet); | ||
| }; | ||
| export { fetchWithMpp }; | ||
| //# sourceMappingURL=mpp.js.map |
| {"version":3,"file":"mpp.js","sources":["../../../src/402/mpp/utils.ts","../../../src/402/mpp/mpp.ts"],"sourcesContent":["export interface MppChallenge {\n id: string;\n realm: string;\n method: string;\n intent: string;\n request: string;\n expires?: string;\n}\n\nexport interface MppChargeRequest {\n amount: string;\n currency: string;\n description?: string;\n recipient?: string;\n externalId?: string;\n methodDetails: {\n invoice: string;\n paymentHash?: string;\n network?: string;\n };\n}\n\n/**\n * Parse a `WWW-Authenticate: Payment …` header produced by a\n * draft-lightning-charge-00 server. Expected format:\n *\n * Payment id=\"<id>\", realm=\"<realm>\", method=\"lightning\",\n * intent=\"charge\", request=\"<base64url>\" [, expires=\"<rfc3339>\"]\n *\n * Returns null when the header is not a Payment lightning/charge challenge.\n */\nexport const parseMppChallenge = (header: string): MppChallenge | null => {\n if (!header.trimStart().toLowerCase().startsWith(\"payment\")) {\n return null;\n }\n const rest = header\n .slice(header.toLowerCase().indexOf(\"payment\") + \"payment\".length)\n .trim();\n const result: Record<string, string> = {};\n const regex = /(\\w+)=(\"([^\"]*)\"|'([^']*)'|([^,\\s]*))/g;\n let match;\n while ((match = regex.exec(rest)) !== null) {\n result[match[1]] = match[3] ?? match[4] ?? match[5] ?? \"\";\n }\n\n if (\n result.method !== \"lightning\" ||\n result.intent !== \"charge\" ||\n !result.id ||\n !result.realm ||\n !result.request\n ) {\n return null;\n }\n\n return {\n id: result.id,\n realm: result.realm,\n method: result.method,\n intent: result.intent,\n request: result.request,\n ...(result.expires ? { expires: result.expires } : {}),\n };\n};\n\n/** Decode a base64url string (no padding required) to a UTF-8 string. */\nexport const decodeBase64url = (input: string): string => {\n const base64 = input.replace(/-/g, \"+\").replace(/_/g, \"/\");\n const binary = atob(base64);\n const bytes = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) {\n bytes[i] = binary.charCodeAt(i);\n }\n return new TextDecoder(\"utf-8\").decode(bytes);\n};\n\n/** Encode a UTF-8 string to base64url without padding. */\nconst encodeBase64url = (input: string): string => {\n const bytes = new TextEncoder().encode(input);\n let binary = \"\";\n for (let i = 0; i < bytes.length; i++) {\n binary += String.fromCharCode(bytes[i]);\n }\n return btoa(binary).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=/g, \"\");\n};\n\n/**\n * JSON Canonicalization Scheme (RFC 8785).\n * Produces compact JSON with object keys sorted lexicographically.\n */\nconst jcs = (value: unknown): string => {\n if (value === null || typeof value !== \"object\") {\n return JSON.stringify(value);\n }\n if (Array.isArray(value)) {\n return \"[\" + (value as unknown[]).map(jcs).join(\",\") + \"]\";\n }\n const keys = Object.keys(value as object).sort();\n return (\n \"{\" +\n keys\n .map(\n (k) =>\n JSON.stringify(k) + \":\" + jcs((value as Record<string, unknown>)[k]),\n )\n .join(\",\") +\n \"}\"\n );\n};\n\n/**\n * Build the base64url-encoded credential token for the `Authorization` header.\n *\n * Per the spec the credential is a JCS-serialised JSON object that echoes all\n * challenge auth-params (id, realm, method, intent, request, expires) and\n * carries the HTLC preimage that proves payment:\n *\n * {\n * \"challenge\": { \"id\": \"…\", \"intent\": \"charge\",\n * \"method\": \"lightning\", \"realm\": \"…\", \"request\": \"…\" },\n * \"payload\": { \"preimage\": \"<64-char lowercase hex>\" }\n * }\n *\n * Keys are sorted lexicographically at every level per JCS.\n */\nexport const buildMppCredential = (\n challenge: MppChallenge,\n preimage: string,\n source?: string,\n): string => {\n const challengeEcho: Record<string, string> = {\n id: challenge.id,\n intent: challenge.intent,\n method: challenge.method,\n realm: challenge.realm,\n request: challenge.request,\n };\n if (challenge.expires) {\n challengeEcho.expires = challenge.expires;\n }\n\n const credential: Record<string, unknown> = {\n challenge: challengeEcho,\n payload: { preimage },\n };\n if (source) {\n credential.source = source;\n }\n\n return encodeBase64url(jcs(credential));\n};\n\n/**\n * Construct a `WWW-Authenticate` header for testing / server implementations.\n *\n * The auth scheme is `Payment` per [I-D.httpauth-payment].\n */\nexport const makeMppWwwAuthenticateHeader = (args: {\n id: string;\n realm: string;\n request: string;\n expires?: string;\n}): string => {\n let header =\n `Payment id=\"${args.id}\", realm=\"${args.realm}\", method=\"lightning\",` +\n ` intent=\"charge\", request=\"${args.request}\"`;\n if (args.expires) {\n header += `, expires=\"${args.expires}\"`;\n }\n return header;\n};\n\n/** Encode an MppChargeRequest as a base64url string suitable for the `request` auth-param. */\nexport const encodeMppChargeRequest = (request: MppChargeRequest): string =>\n encodeBase64url(jcs(request));\n","import { Wallet } from \"../utils\";\nimport {\n buildMppCredential,\n decodeBase64url,\n MppChargeRequest,\n parseMppChallenge,\n} from \"./utils\";\n\n/**\n * Handle a `WWW-Authenticate: Payment …` challenge produced by a\n * draft-lightning-charge-00 server.\n *\n * Flow:\n * 1. Parse the challenge from the header.\n * 2. Decode the `request` auth-param to find the BOLT11 invoice.\n * 3. Pay the invoice via the wallet; receive the HTLC preimage.\n * 4. Build the `Authorization: Payment <credential>` header.\n * 5. Retry the original request with the credential.\n */\nexport const handleMppChargePayment = async (\n wwwAuthHeader: string,\n url: string,\n fetchArgs: RequestInit,\n headers: Headers,\n wallet: Wallet,\n): Promise<Response> => {\n const challenge = parseMppChallenge(wwwAuthHeader);\n if (!challenge) {\n throw new Error(\n \"mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)\",\n );\n }\n\n let request: MppChargeRequest;\n try {\n request = JSON.parse(decodeBase64url(challenge.request));\n } catch (_) {\n throw new Error(\n \"mpp: invalid request auth-param (not valid base64url-encoded JSON)\",\n );\n }\n\n const invoice = request.methodDetails?.invoice;\n if (!invoice) {\n throw new Error(\"mpp: missing invoice in charge request\");\n }\n\n const invResp = await wallet.payInvoice({ invoice });\n\n // Per spec: Authorization: Payment <base64url-token> (single token, no wrapper)\n const credential = buildMppCredential(challenge, invResp.preimage);\n headers.set(\"Authorization\", `Payment ${credential}`);\n\n return fetch(url, fetchArgs);\n};\n\n/**\n * Fetch a resource protected by the draft-lightning-charge-00 payment\n * authentication protocol.\n *\n * On a `402 Payment Required` response that carries a\n * `WWW-Authenticate: Payment method=\"lightning\" intent=\"charge\" …` header\n * the function pays the embedded BOLT11 invoice and retries with the\n * resulting preimage as the credential.\n *\n * Note: lightning-charge uses consume-once challenge semantics – each\n * challenge embeds a fresh invoice, so paid credentials cannot be reused.\n * The `store` option is accepted for API consistency but is not used.\n */\nexport const fetchWithMpp = async (\n url: string,\n fetchArgs: RequestInit,\n options: { wallet: Wallet },\n): Promise<Response> => {\n const wallet = options.wallet;\n if (!wallet) {\n throw new Error(\"wallet is missing\");\n }\n if (!fetchArgs) {\n fetchArgs = {};\n }\n fetchArgs.cache = \"no-store\";\n fetchArgs.mode = \"cors\";\n const headers = new Headers(fetchArgs.headers ?? undefined);\n fetchArgs.headers = headers;\n\n const initResp = await fetch(url, fetchArgs);\n const wwwAuthHeader = initResp.headers.get(\"www-authenticate\");\n if (\n !wwwAuthHeader ||\n !wwwAuthHeader.trimStart().toLowerCase().startsWith(\"payment\")\n ) {\n return initResp;\n }\n\n return handleMppChargePayment(wwwAuthHeader, url, fetchArgs, headers, wallet);\n};\n"],"names":[],"mappings":"AAsBA;;;;;;;;AAQG;AACI,MAAM,iBAAiB,GAAG,CAAC,MAAc,KAAyB;AACvE,IAAA,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE;AAC3D,QAAA,OAAO,IAAI;IACb;IACA,MAAM,IAAI,GAAG;AACV,SAAA,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,MAAM;AAChE,SAAA,IAAI,EAAE;IACT,MAAM,MAAM,GAA2B,EAAE;IACzC,MAAM,KAAK,GAAG,wCAAwC;AACtD,IAAA,IAAI,KAAK;AACT,IAAA,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE;QAC1C,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;IAC3D;AAEA,IAAA,IACE,MAAM,CAAC,MAAM,KAAK,WAAW;QAC7B,MAAM,CAAC,MAAM,KAAK,QAAQ;QAC1B,CAAC,MAAM,CAAC,EAAE;QACV,CAAC,MAAM,CAAC,KAAK;AACb,QAAA,CAAC,MAAM,CAAC,OAAO,EACf;AACA,QAAA,OAAO,IAAI;IACb;IAEA,OAAO;QACL,EAAE,EAAE,MAAM,CAAC,EAAE;QACb,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;AACvB,QAAA,IAAI,MAAM,CAAC,OAAO,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC;KACvD;AACH,CAAC;AAED;AACO,MAAM,eAAe,GAAG,CAAC,KAAa,KAAY;AACvD,IAAA,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC;AAC1D,IAAA,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;AAC3C,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtC,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;IACjC;IACA,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;AAC/C,CAAC;AAED;AACA,MAAM,eAAe,GAAG,CAAC,KAAa,KAAY;IAChD,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC;IAC7C,IAAI,MAAM,GAAG,EAAE;AACf,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACrC,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzC;IACA,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;AAC/E,CAAC;AAED;;;AAGG;AACH,MAAM,GAAG,GAAG,CAAC,KAAc,KAAY;IACrC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AAC/C,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;IAC9B;AACA,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACxB,QAAA,OAAO,GAAG,GAAI,KAAmB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG;IAC5D;IACA,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAe,CAAC,CAAC,IAAI,EAAE;AAChD,IAAA,QACE,GAAG;QACH;aACG,GAAG,CACF,CAAC,CAAC,KACA,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,GAAG,CAAE,KAAiC,CAAC,CAAC,CAAC,CAAC;aAEvE,IAAI,CAAC,GAAG,CAAC;AACZ,QAAA,GAAG;AAEP,CAAC;AAED;;;;;;;;;;;;;;AAcG;AACI,MAAM,kBAAkB,GAAG,CAChC,SAAuB,EACvB,QAAgB,EAChB,MAAe,KACL;AACV,IAAA,MAAM,aAAa,GAA2B;QAC5C,EAAE,EAAE,SAAS,CAAC,EAAE;QAChB,MAAM,EAAE,SAAS,CAAC,MAAM;QACxB,MAAM,EAAE,SAAS,CAAC,MAAM;QACxB,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,OAAO,EAAE,SAAS,CAAC,OAAO;KAC3B;AACD,IAAA,IAAI,SAAS,CAAC,OAAO,EAAE;AACrB,QAAA,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO;IAC3C;AAEA,IAAA,MAAM,UAAU,GAA4B;AAC1C,QAAA,SAAS,EAAE,aAAa;QACxB,OAAO,EAAE,EAAE,QAAQ,EAAE;KACtB;AAKD,IAAA,OAAO,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AACzC,CAAC;;AC9ID;;;;;;;;;;AAUG;AACI,MAAM,sBAAsB,GAAG,OACpC,aAAqB,EACrB,GAAW,EACX,SAAsB,EACtB,OAAgB,EAChB,MAAc,KACO;AACrB,IAAA,MAAM,SAAS,GAAG,iBAAiB,CAAC,aAAa,CAAC;IAClD,IAAI,CAAC,SAAS,EAAE;AACd,QAAA,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G;IACH;AAEA,IAAA,IAAI,OAAyB;AAC7B,IAAA,IAAI;AACF,QAAA,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC1D;IAAE,OAAO,CAAC,EAAE;AACV,QAAA,MAAM,IAAI,KAAK,CACb,oEAAoE,CACrE;IACH;AAEA,IAAA,MAAM,OAAO,GAAG,OAAO,CAAC,aAAa,EAAE,OAAO;IAC9C,IAAI,CAAC,OAAO,EAAE;AACZ,QAAA,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC;IAC3D;IAEA,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,CAAC;;IAGpD,MAAM,UAAU,GAAG,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,CAAC;IAClE,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,CAAA,QAAA,EAAW,UAAU,CAAA,CAAE,CAAC;AAErD,IAAA,OAAO,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;AAYG;AACI,MAAM,YAAY,GAAG,OAC1B,GAAW,EACX,SAAsB,EACtB,OAA2B,KACN;AACrB,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM;IAC7B,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IACtC;IACA,IAAI,CAAC,SAAS,EAAE;QACd,SAAS,GAAG,EAAE;IAChB;AACA,IAAA,SAAS,CAAC,KAAK,GAAG,UAAU;AAC5B,IAAA,SAAS,CAAC,IAAI,GAAG,MAAM;IACvB,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC;AAC3D,IAAA,SAAS,CAAC,OAAO,GAAG,OAAO;IAE3B,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IAC5C,MAAM,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAC9D,IAAA,IACE,CAAC,aAAa;AACd,QAAA,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAC9D;AACA,QAAA,OAAO,QAAQ;IACjB;AAEA,IAAA,OAAO,sBAAsB,CAAC,aAAa,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC;AAC/E;;;;"} |
+1311
| const buildX402PaymentSignature = (scheme, network, invoice, requirements) => { | ||
| const json = JSON.stringify({ | ||
| x402Version: 2, | ||
| scheme, | ||
| network, | ||
| payload: { invoice }, | ||
| accepted: requirements, | ||
| }); | ||
| // btoa only handles latin1; encode via UTF-8 to be safe | ||
| return btoa(unescape(encodeURIComponent(json))); | ||
| }; | ||
| var lib = {}; | ||
| var hasRequiredLib; | ||
| function requireLib () { | ||
| if (hasRequiredLib) return lib; | ||
| hasRequiredLib = 1; | ||
| (function (exports) { | ||
| /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64url = exports.base64 = exports.base32crockford = exports.base32hex = exports.base32 = exports.base16 = exports.utils = exports.assertNumber = void 0; | ||
| function assertNumber(n) { | ||
| if (!Number.isSafeInteger(n)) | ||
| throw new Error(`Wrong integer: ${n}`); | ||
| } | ||
| exports.assertNumber = assertNumber; | ||
| function chain(...args) { | ||
| const wrap = (a, b) => (c) => a(b(c)); | ||
| const encode = Array.from(args) | ||
| .reverse() | ||
| .reduce((acc, i) => (acc ? wrap(acc, i.encode) : i.encode), undefined); | ||
| const decode = args.reduce((acc, i) => (acc ? wrap(acc, i.decode) : i.decode), undefined); | ||
| return { encode, decode }; | ||
| } | ||
| function alphabet(alphabet) { | ||
| return { | ||
| encode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('alphabet.encode input should be an array of numbers'); | ||
| return digits.map((i) => { | ||
| assertNumber(i); | ||
| if (i < 0 || i >= alphabet.length) | ||
| throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`); | ||
| return alphabet[i]; | ||
| }); | ||
| }, | ||
| decode: (input) => { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('alphabet.decode input should be array of strings'); | ||
| return input.map((letter) => { | ||
| if (typeof letter !== 'string') | ||
| throw new Error(`alphabet.decode: not string element=${letter}`); | ||
| const index = alphabet.indexOf(letter); | ||
| if (index === -1) | ||
| throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`); | ||
| return index; | ||
| }); | ||
| }, | ||
| }; | ||
| } | ||
| function join(separator = '') { | ||
| if (typeof separator !== 'string') | ||
| throw new Error('join separator should be string'); | ||
| return { | ||
| encode: (from) => { | ||
| if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string')) | ||
| throw new Error('join.encode input should be array of strings'); | ||
| for (let i of from) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`join.encode: non-string input=${i}`); | ||
| return from.join(separator); | ||
| }, | ||
| decode: (to) => { | ||
| if (typeof to !== 'string') | ||
| throw new Error('join.decode input should be string'); | ||
| return to.split(separator); | ||
| }, | ||
| }; | ||
| } | ||
| function padding(bits, chr = '=') { | ||
| assertNumber(bits); | ||
| if (typeof chr !== 'string') | ||
| throw new Error('padding chr should be string'); | ||
| return { | ||
| encode(data) { | ||
| if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of data) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.encode: non-string input=${i}`); | ||
| while ((data.length * bits) % 8) | ||
| data.push(chr); | ||
| return data; | ||
| }, | ||
| decode(input) { | ||
| if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string')) | ||
| throw new Error('padding.encode input should be array of strings'); | ||
| for (let i of input) | ||
| if (typeof i !== 'string') | ||
| throw new Error(`padding.decode: non-string input=${i}`); | ||
| let end = input.length; | ||
| if ((end * bits) % 8) | ||
| throw new Error('Invalid padding: string should have whole number of bytes'); | ||
| for (; end > 0 && input[end - 1] === chr; end--) { | ||
| if (!(((end - 1) * bits) % 8)) | ||
| throw new Error('Invalid padding: string has too much padding'); | ||
| } | ||
| return input.slice(0, end); | ||
| }, | ||
| }; | ||
| } | ||
| function normalize(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('normalize fn should be function'); | ||
| return { encode: (from) => from, decode: (to) => fn(to) }; | ||
| } | ||
| function convertRadix(data, from, to) { | ||
| if (from < 2) | ||
| throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`); | ||
| if (to < 2) | ||
| throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`); | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix: data should be array'); | ||
| if (!data.length) | ||
| return []; | ||
| let pos = 0; | ||
| const res = []; | ||
| const digits = Array.from(data); | ||
| digits.forEach((d) => { | ||
| assertNumber(d); | ||
| if (d < 0 || d >= from) | ||
| throw new Error(`Wrong integer: ${d}`); | ||
| }); | ||
| while (true) { | ||
| let carry = 0; | ||
| let done = true; | ||
| for (let i = pos; i < digits.length; i++) { | ||
| const digit = digits[i]; | ||
| const digitBase = from * carry + digit; | ||
| if (!Number.isSafeInteger(digitBase) || | ||
| (from * carry) / from !== carry || | ||
| digitBase - digit !== from * carry) { | ||
| throw new Error('convertRadix: carry overflow'); | ||
| } | ||
| carry = digitBase % to; | ||
| digits[i] = Math.floor(digitBase / to); | ||
| if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase) | ||
| throw new Error('convertRadix: carry overflow'); | ||
| if (!done) | ||
| continue; | ||
| else if (!digits[i]) | ||
| pos = i; | ||
| else | ||
| done = false; | ||
| } | ||
| res.push(carry); | ||
| if (done) | ||
| break; | ||
| } | ||
| for (let i = 0; i < data.length - 1 && data[i] === 0; i++) | ||
| res.push(0); | ||
| return res.reverse(); | ||
| } | ||
| const gcd = (a, b) => (!b ? a : gcd(b, a % b)); | ||
| const radix2carry = (from, to) => from + (to - gcd(from, to)); | ||
| function convertRadix2(data, from, to, padding) { | ||
| if (!Array.isArray(data)) | ||
| throw new Error('convertRadix2: data should be array'); | ||
| if (from <= 0 || from > 32) | ||
| throw new Error(`convertRadix2: wrong from=${from}`); | ||
| if (to <= 0 || to > 32) | ||
| throw new Error(`convertRadix2: wrong to=${to}`); | ||
| if (radix2carry(from, to) > 32) { | ||
| throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`); | ||
| } | ||
| let carry = 0; | ||
| let pos = 0; | ||
| const mask = 2 ** to - 1; | ||
| const res = []; | ||
| for (const n of data) { | ||
| assertNumber(n); | ||
| if (n >= 2 ** from) | ||
| throw new Error(`convertRadix2: invalid data word=${n} from=${from}`); | ||
| carry = (carry << from) | n; | ||
| if (pos + from > 32) | ||
| throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`); | ||
| pos += from; | ||
| for (; pos >= to; pos -= to) | ||
| res.push(((carry >> (pos - to)) & mask) >>> 0); | ||
| carry &= 2 ** pos - 1; | ||
| } | ||
| carry = (carry << (to - pos)) & mask; | ||
| if (!padding && pos >= from) | ||
| throw new Error('Excess padding'); | ||
| if (!padding && carry) | ||
| throw new Error(`Non-zero padding: ${carry}`); | ||
| if (padding && pos > 0) | ||
| res.push(carry >>> 0); | ||
| return res; | ||
| } | ||
| function radix(num) { | ||
| assertNumber(num); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix.encode input should be Uint8Array'); | ||
| return convertRadix(Array.from(bytes), 2 ** 8, num); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix(digits, num, 2 ** 8)); | ||
| }, | ||
| }; | ||
| } | ||
| function radix2(bits, revPadding = false) { | ||
| assertNumber(bits); | ||
| if (bits <= 0 || bits > 32) | ||
| throw new Error('radix2: bits should be in (0..32]'); | ||
| if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32) | ||
| throw new Error('radix2: carry overflow'); | ||
| return { | ||
| encode: (bytes) => { | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new Error('radix2.encode input should be Uint8Array'); | ||
| return convertRadix2(Array.from(bytes), 8, bits, !revPadding); | ||
| }, | ||
| decode: (digits) => { | ||
| if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number')) | ||
| throw new Error('radix2.decode input should be array of strings'); | ||
| return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding)); | ||
| }, | ||
| }; | ||
| } | ||
| function unsafeWrapper(fn) { | ||
| if (typeof fn !== 'function') | ||
| throw new Error('unsafeWrapper fn should be function'); | ||
| return function (...args) { | ||
| try { | ||
| return fn.apply(null, args); | ||
| } | ||
| catch (e) { } | ||
| }; | ||
| } | ||
| function checksum(len, fn) { | ||
| assertNumber(len); | ||
| if (typeof fn !== 'function') | ||
| throw new Error('checksum fn should be function'); | ||
| return { | ||
| encode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.encode: input should be Uint8Array'); | ||
| const checksum = fn(data).slice(0, len); | ||
| const res = new Uint8Array(data.length + len); | ||
| res.set(data); | ||
| res.set(checksum, data.length); | ||
| return res; | ||
| }, | ||
| decode(data) { | ||
| if (!(data instanceof Uint8Array)) | ||
| throw new Error('checksum.decode: input should be Uint8Array'); | ||
| const payload = data.slice(0, -len); | ||
| const newChecksum = fn(payload).slice(0, len); | ||
| const oldChecksum = data.slice(-len); | ||
| for (let i = 0; i < len; i++) | ||
| if (newChecksum[i] !== oldChecksum[i]) | ||
| throw new Error('Invalid checksum'); | ||
| return payload; | ||
| }, | ||
| }; | ||
| } | ||
| exports.utils = { alphabet, chain, checksum, radix, radix2, join, padding }; | ||
| exports.base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join('')); | ||
| exports.base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join('')); | ||
| exports.base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join('')); | ||
| exports.base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1'))); | ||
| exports.base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join('')); | ||
| exports.base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join('')); | ||
| const genBase58 = (abc) => chain(radix(58), alphabet(abc), join('')); | ||
| exports.base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'); | ||
| exports.base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'); | ||
| exports.base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz'); | ||
| const XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11]; | ||
| exports.base58xmr = { | ||
| encode(data) { | ||
| let res = ''; | ||
| for (let i = 0; i < data.length; i += 8) { | ||
| const block = data.subarray(i, i + 8); | ||
| res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1'); | ||
| } | ||
| return res; | ||
| }, | ||
| decode(str) { | ||
| let res = []; | ||
| for (let i = 0; i < str.length; i += 11) { | ||
| const slice = str.slice(i, i + 11); | ||
| const blockLen = XMR_BLOCK_LEN.indexOf(slice.length); | ||
| const block = exports.base58.decode(slice); | ||
| for (let j = 0; j < block.length - blockLen; j++) { | ||
| if (block[j] !== 0) | ||
| throw new Error('base58xmr: wrong padding'); | ||
| } | ||
| res = res.concat(Array.from(block.slice(block.length - blockLen))); | ||
| } | ||
| return Uint8Array.from(res); | ||
| }, | ||
| }; | ||
| const base58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), exports.base58); | ||
| exports.base58check = base58check; | ||
| const BECH_ALPHABET = chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join('')); | ||
| const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; | ||
| function bech32Polymod(pre) { | ||
| const b = pre >> 25; | ||
| let chk = (pre & 0x1ffffff) << 5; | ||
| for (let i = 0; i < POLYMOD_GENERATORS.length; i++) { | ||
| if (((b >> i) & 1) === 1) | ||
| chk ^= POLYMOD_GENERATORS[i]; | ||
| } | ||
| return chk; | ||
| } | ||
| function bechChecksum(prefix, words, encodingConst = 1) { | ||
| const len = prefix.length; | ||
| let chk = 1; | ||
| for (let i = 0; i < len; i++) { | ||
| const c = prefix.charCodeAt(i); | ||
| if (c < 33 || c > 126) | ||
| throw new Error(`Invalid prefix (${prefix})`); | ||
| chk = bech32Polymod(chk) ^ (c >> 5); | ||
| } | ||
| chk = bech32Polymod(chk); | ||
| for (let i = 0; i < len; i++) | ||
| chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f); | ||
| for (let v of words) | ||
| chk = bech32Polymod(chk) ^ v; | ||
| for (let i = 0; i < 6; i++) | ||
| chk = bech32Polymod(chk); | ||
| chk ^= encodingConst; | ||
| return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false)); | ||
| } | ||
| function genBech32(encoding) { | ||
| const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3; | ||
| const _words = radix2(5); | ||
| const fromWords = _words.decode; | ||
| const toWords = _words.encode; | ||
| const fromWordsUnsafe = unsafeWrapper(fromWords); | ||
| function encode(prefix, words, limit = 90) { | ||
| if (typeof prefix !== 'string') | ||
| throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`); | ||
| if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number')) | ||
| throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`); | ||
| const actualLength = prefix.length + 7 + words.length; | ||
| if (limit !== false && actualLength > limit) | ||
| throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); | ||
| prefix = prefix.toLowerCase(); | ||
| return `${prefix}1${BECH_ALPHABET.encode(words)}${bechChecksum(prefix, words, ENCODING_CONST)}`; | ||
| } | ||
| function decode(str, limit = 90) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`bech32.decode input should be string, not ${typeof str}`); | ||
| if (str.length < 8 || (limit !== false && str.length > limit)) | ||
| throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`); | ||
| const lowered = str.toLowerCase(); | ||
| if (str !== lowered && str !== str.toUpperCase()) | ||
| throw new Error(`String must be lowercase or uppercase`); | ||
| str = lowered; | ||
| const sepIndex = str.lastIndexOf('1'); | ||
| if (sepIndex === 0 || sepIndex === -1) | ||
| throw new Error(`Letter "1" must be present between prefix and data only`); | ||
| const prefix = str.slice(0, sepIndex); | ||
| const _words = str.slice(sepIndex + 1); | ||
| if (_words.length < 6) | ||
| throw new Error('Data must be at least 6 characters long'); | ||
| const words = BECH_ALPHABET.decode(_words).slice(0, -6); | ||
| const sum = bechChecksum(prefix, words, ENCODING_CONST); | ||
| if (!_words.endsWith(sum)) | ||
| throw new Error(`Invalid checksum in ${str}: expected "${sum}"`); | ||
| return { prefix, words }; | ||
| } | ||
| const decodeUnsafe = unsafeWrapper(decode); | ||
| function decodeToBytes(str) { | ||
| const { prefix, words } = decode(str, false); | ||
| return { prefix, words, bytes: fromWords(words) }; | ||
| } | ||
| return { encode, decode, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords }; | ||
| } | ||
| exports.bech32 = genBech32('bech32'); | ||
| exports.bech32m = genBech32('bech32m'); | ||
| exports.utf8 = { | ||
| encode: (data) => new TextDecoder().decode(data), | ||
| decode: (str) => new TextEncoder().encode(str), | ||
| }; | ||
| exports.hex = chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => { | ||
| if (typeof s !== 'string' || s.length % 2) | ||
| throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`); | ||
| return s.toLowerCase(); | ||
| })); | ||
| const CODERS = { | ||
| utf8: exports.utf8, hex: exports.hex, base16: exports.base16, base32: exports.base32, base64: exports.base64, base64url: exports.base64url, base58: exports.base58, base58xmr: exports.base58xmr | ||
| }; | ||
| const coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(', ')}`; | ||
| const bytesToString = (type, bytes) => { | ||
| if (typeof type !== 'string' || !CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (!(bytes instanceof Uint8Array)) | ||
| throw new TypeError('bytesToString() expects Uint8Array'); | ||
| return CODERS[type].encode(bytes); | ||
| }; | ||
| exports.bytesToString = bytesToString; | ||
| exports.str = exports.bytesToString; | ||
| const stringToBytes = (type, str) => { | ||
| if (!CODERS.hasOwnProperty(type)) | ||
| throw new TypeError(coderTypeError); | ||
| if (typeof str !== 'string') | ||
| throw new TypeError('stringToBytes() expects string'); | ||
| return CODERS[type].decode(str); | ||
| }; | ||
| exports.stringToBytes = stringToBytes; | ||
| exports.bytes = exports.stringToBytes; | ||
| } (lib)); | ||
| return lib; | ||
| } | ||
| var bolt11; | ||
| var hasRequiredBolt11; | ||
| function requireBolt11 () { | ||
| if (hasRequiredBolt11) return bolt11; | ||
| hasRequiredBolt11 = 1; | ||
| const {bech32, hex, utf8} = requireLib(); | ||
| // defaults for encode; default timestamp is current time at call | ||
| const DEFAULTNETWORK = { | ||
| // default network is bitcoin | ||
| bech32: 'bc', | ||
| pubKeyHash: 0x00, | ||
| scriptHash: 0x05, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const TESTNETWORK = { | ||
| bech32: 'tb', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIGNETNETWORK = { | ||
| bech32: 'tbs', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const REGTESTNETWORK = { | ||
| bech32: 'bcrt', | ||
| pubKeyHash: 0x6f, | ||
| scriptHash: 0xc4, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const SIMNETWORK = { | ||
| bech32: 'sb', | ||
| pubKeyHash: 0x3f, | ||
| scriptHash: 0x7b, | ||
| validWitnessVersions: [0] | ||
| }; | ||
| const FEATUREBIT_ORDER = [ | ||
| 'option_data_loss_protect', | ||
| 'initial_routing_sync', | ||
| 'option_upfront_shutdown_script', | ||
| 'gossip_queries', | ||
| 'var_onion_optin', | ||
| 'gossip_queries_ex', | ||
| 'option_static_remotekey', | ||
| 'payment_secret', | ||
| 'basic_mpp', | ||
| 'option_support_large_channel' | ||
| ]; | ||
| const DIVISORS = { | ||
| m: BigInt(1e3), | ||
| u: BigInt(1e6), | ||
| n: BigInt(1e9), | ||
| p: BigInt(1e12) | ||
| }; | ||
| const MAX_MILLISATS = BigInt('2100000000000000000'); | ||
| const MILLISATS_PER_BTC = BigInt(1e11); | ||
| const TAGCODES = { | ||
| payment_hash: 1, | ||
| payment_secret: 16, | ||
| description: 13, | ||
| payee: 19, | ||
| description_hash: 23, // commit to longer descriptions (used by lnurl-pay) | ||
| expiry: 6, // default: 3600 (1 hour) | ||
| min_final_cltv_expiry: 24, // default: 9 | ||
| fallback_address: 9, | ||
| route_hint: 3, // for extra routing info (private etc.) | ||
| feature_bits: 5, | ||
| metadata: 27 | ||
| }; | ||
| // reverse the keys and values of TAGCODES and insert into TAGNAMES | ||
| const TAGNAMES = {}; | ||
| for (let i = 0, keys = Object.keys(TAGCODES); i < keys.length; i++) { | ||
| const currentName = keys[i]; | ||
| const currentCode = TAGCODES[keys[i]].toString(); | ||
| TAGNAMES[currentCode] = currentName; | ||
| } | ||
| const TAGPARSERS = { | ||
| 1: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 16: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 13: words => utf8.encode(bech32.fromWordsUnsafe(words)), // string variable length | ||
| 19: words => hex.encode(bech32.fromWordsUnsafe(words)), // 264 bits | ||
| 23: words => hex.encode(bech32.fromWordsUnsafe(words)), // 256 bits | ||
| 27: words => hex.encode(bech32.fromWordsUnsafe(words)), // variable | ||
| 6: wordsToIntBE, // default: 3600 (1 hour) | ||
| 24: wordsToIntBE, // default: 9 | ||
| 3: routingInfoParser, // for extra routing info (private etc.) | ||
| 5: featureBitsParser // keep feature bits as array of 5 bit words | ||
| }; | ||
| function getUnknownParser(tagCode) { | ||
| return words => ({ | ||
| tagCode: parseInt(tagCode), | ||
| words: bech32.encode('unknown', words, Number.MAX_SAFE_INTEGER) | ||
| }) | ||
| } | ||
| function wordsToIntBE(words) { | ||
| return words.reverse().reduce((total, item, index) => { | ||
| return total + item * Math.pow(32, index) | ||
| }, 0) | ||
| } | ||
| // first convert from words to buffer, trimming padding where necessary | ||
| // parse in 51 byte chunks. See encoder for details. | ||
| function routingInfoParser(words) { | ||
| const routes = []; | ||
| let pubkey, | ||
| shortChannelId, | ||
| feeBaseMSats, | ||
| feeProportionalMillionths, | ||
| cltvExpiryDelta; | ||
| let routesBuffer = bech32.fromWordsUnsafe(words); | ||
| while (routesBuffer.length > 0) { | ||
| pubkey = hex.encode(routesBuffer.slice(0, 33)); // 33 bytes | ||
| shortChannelId = hex.encode(routesBuffer.slice(33, 41)); // 8 bytes | ||
| feeBaseMSats = parseInt(hex.encode(routesBuffer.slice(41, 45)), 16); // 4 bytes | ||
| feeProportionalMillionths = parseInt( | ||
| hex.encode(routesBuffer.slice(45, 49)), | ||
| 16 | ||
| ); // 4 bytes | ||
| cltvExpiryDelta = parseInt(hex.encode(routesBuffer.slice(49, 51)), 16); // 2 bytes | ||
| routesBuffer = routesBuffer.slice(51); | ||
| routes.push({ | ||
| pubkey, | ||
| short_channel_id: shortChannelId, | ||
| fee_base_msat: feeBaseMSats, | ||
| fee_proportional_millionths: feeProportionalMillionths, | ||
| cltv_expiry_delta: cltvExpiryDelta | ||
| }); | ||
| } | ||
| return routes | ||
| } | ||
| function featureBitsParser(words) { | ||
| const bools = words | ||
| .slice() | ||
| .reverse() | ||
| .map(word => [ | ||
| !!(word & 0b1), | ||
| !!(word & 0b10), | ||
| !!(word & 0b100), | ||
| !!(word & 0b1000), | ||
| !!(word & 0b10000) | ||
| ]) | ||
| .reduce((finalArr, itemArr) => finalArr.concat(itemArr), []); | ||
| while (bools.length < FEATUREBIT_ORDER.length * 2) { | ||
| bools.push(false); | ||
| } | ||
| const featureBits = {}; | ||
| FEATUREBIT_ORDER.forEach((featureName, index) => { | ||
| let status; | ||
| if (bools[index * 2]) { | ||
| status = 'required'; | ||
| } else if (bools[index * 2 + 1]) { | ||
| status = 'supported'; | ||
| } else { | ||
| status = 'unsupported'; | ||
| } | ||
| featureBits[featureName] = status; | ||
| }); | ||
| const extraBits = bools.slice(FEATUREBIT_ORDER.length * 2); | ||
| featureBits.extra_bits = { | ||
| start_bit: FEATUREBIT_ORDER.length * 2, | ||
| bits: extraBits, | ||
| has_required: extraBits.reduce( | ||
| (result, bit, index) => | ||
| index % 2 !== 0 ? result || false : result || bit, | ||
| false | ||
| ) | ||
| }; | ||
| return featureBits | ||
| } | ||
| function hrpToMillisat(hrpString, outputString) { | ||
| let divisor, value; | ||
| if (hrpString.slice(-1).match(/^[munp]$/)) { | ||
| divisor = hrpString.slice(-1); | ||
| value = hrpString.slice(0, -1); | ||
| } else if (hrpString.slice(-1).match(/^[^munp0-9]$/)) { | ||
| throw new Error('Not a valid multiplier for the amount') | ||
| } else { | ||
| value = hrpString; | ||
| } | ||
| if (!value.match(/^\d+$/)) | ||
| throw new Error('Not a valid human readable amount') | ||
| const valueBN = BigInt(value); | ||
| const millisatoshisBN = divisor | ||
| ? (valueBN * MILLISATS_PER_BTC) / DIVISORS[divisor] | ||
| : valueBN * MILLISATS_PER_BTC; | ||
| if ( | ||
| (divisor === 'p' && !(valueBN % BigInt(10) === BigInt(0))) || | ||
| millisatoshisBN > MAX_MILLISATS | ||
| ) { | ||
| throw new Error('Amount is outside of valid range') | ||
| } | ||
| return outputString ? millisatoshisBN.toString() : millisatoshisBN | ||
| } | ||
| // decode will only have extra comments that aren't covered in encode comments. | ||
| // also if anything is hard to read I'll comment. | ||
| function decode(paymentRequest, network) { | ||
| if (typeof paymentRequest !== 'string') | ||
| throw new Error('Lightning Payment Request must be string') | ||
| if (paymentRequest.slice(0, 2).toLowerCase() !== 'ln') | ||
| throw new Error('Not a proper lightning payment request') | ||
| const sections = []; | ||
| const decoded = bech32.decode(paymentRequest, Number.MAX_SAFE_INTEGER); | ||
| paymentRequest = paymentRequest.toLowerCase(); | ||
| const prefix = decoded.prefix; | ||
| let words = decoded.words; | ||
| let letters = paymentRequest.slice(prefix.length + 1); | ||
| let sigWords = words.slice(-104); | ||
| words = words.slice(0, -104); | ||
| // Without reverse lookups, can't say that the multipier at the end must | ||
| // have a number before it, so instead we parse, and if the second group | ||
| // doesn't have anything, there's a good chance the last letter of the | ||
| // coin type got captured by the third group, so just re-regex without | ||
| // the number. | ||
| let prefixMatches = prefix.match(/^ln(\S+?)(\d*)([a-zA-Z]?)$/); | ||
| if (prefixMatches && !prefixMatches[2]) | ||
| prefixMatches = prefix.match(/^ln(\S+)$/); | ||
| if (!prefixMatches) { | ||
| throw new Error('Not a proper lightning payment request') | ||
| } | ||
| // "ln" section | ||
| sections.push({ | ||
| name: 'lightning_network', | ||
| letters: 'ln' | ||
| }); | ||
| // "bc" section | ||
| const bech32Prefix = prefixMatches[1]; | ||
| let coinNetwork; | ||
| if (!network) { | ||
| switch (bech32Prefix) { | ||
| case DEFAULTNETWORK.bech32: | ||
| coinNetwork = DEFAULTNETWORK; | ||
| break | ||
| case TESTNETWORK.bech32: | ||
| coinNetwork = TESTNETWORK; | ||
| break | ||
| case SIGNETNETWORK.bech32: | ||
| coinNetwork = SIGNETNETWORK; | ||
| break | ||
| case REGTESTNETWORK.bech32: | ||
| coinNetwork = REGTESTNETWORK; | ||
| break | ||
| case SIMNETWORK.bech32: | ||
| coinNetwork = SIMNETWORK; | ||
| break | ||
| } | ||
| } else { | ||
| if ( | ||
| network.bech32 === undefined || | ||
| network.pubKeyHash === undefined || | ||
| network.scriptHash === undefined || | ||
| !Array.isArray(network.validWitnessVersions) | ||
| ) | ||
| throw new Error('Invalid network') | ||
| coinNetwork = network; | ||
| } | ||
| if (!coinNetwork || coinNetwork.bech32 !== bech32Prefix) { | ||
| throw new Error('Unknown coin bech32 prefix') | ||
| } | ||
| sections.push({ | ||
| name: 'coin_network', | ||
| letters: bech32Prefix, | ||
| value: coinNetwork | ||
| }); | ||
| // amount section | ||
| const value = prefixMatches[2]; | ||
| let millisatoshis; | ||
| if (value) { | ||
| const divisor = prefixMatches[3]; | ||
| millisatoshis = hrpToMillisat(value + divisor, true); | ||
| sections.push({ | ||
| name: 'amount', | ||
| letters: prefixMatches[2] + prefixMatches[3], | ||
| value: millisatoshis | ||
| }); | ||
| } else { | ||
| millisatoshis = null; | ||
| } | ||
| // "1" separator | ||
| sections.push({ | ||
| name: 'separator', | ||
| letters: '1' | ||
| }); | ||
| // timestamp | ||
| const timestamp = wordsToIntBE(words.slice(0, 7)); | ||
| words = words.slice(7); // trim off the left 7 words | ||
| sections.push({ | ||
| name: 'timestamp', | ||
| letters: letters.slice(0, 7), | ||
| value: timestamp | ||
| }); | ||
| letters = letters.slice(7); | ||
| let tagName, parser, tagLength, tagWords; | ||
| // we have no tag count to go on, so just keep hacking off words | ||
| // until we have none. | ||
| while (words.length > 0) { | ||
| const tagCode = words[0].toString(); | ||
| tagName = TAGNAMES[tagCode] || 'unknown_tag'; | ||
| parser = TAGPARSERS[tagCode] || getUnknownParser(tagCode); | ||
| words = words.slice(1); | ||
| tagLength = wordsToIntBE(words.slice(0, 2)); | ||
| words = words.slice(2); | ||
| tagWords = words.slice(0, tagLength); | ||
| words = words.slice(tagLength); | ||
| sections.push({ | ||
| name: tagName, | ||
| tag: letters[0], | ||
| letters: letters.slice(0, 1 + 2 + tagLength), | ||
| value: parser(tagWords) // see: parsers for more comments | ||
| }); | ||
| letters = letters.slice(1 + 2 + tagLength); | ||
| } | ||
| // signature | ||
| sections.push({ | ||
| name: 'signature', | ||
| letters: letters.slice(0, 104), | ||
| value: hex.encode(bech32.fromWordsUnsafe(sigWords)) | ||
| }); | ||
| letters = letters.slice(104); | ||
| // checksum | ||
| sections.push({ | ||
| name: 'checksum', | ||
| letters: letters | ||
| }); | ||
| let result = { | ||
| paymentRequest, | ||
| sections, | ||
| get expiry() { | ||
| let exp = sections.find(s => s.name === 'expiry'); | ||
| if (exp) return getValue('timestamp') + exp.value | ||
| }, | ||
| get route_hints() { | ||
| return sections.filter(s => s.name === 'route_hint').map(s => s.value) | ||
| } | ||
| }; | ||
| for (let name in TAGCODES) { | ||
| if (name === 'route_hint') { | ||
| // route hints can be multiple, so this won't work for them | ||
| continue | ||
| } | ||
| Object.defineProperty(result, name, { | ||
| get() { | ||
| return getValue(name) | ||
| } | ||
| }); | ||
| } | ||
| return result | ||
| function getValue(name) { | ||
| let section = sections.find(s => s.name === name); | ||
| return section ? section.value : undefined | ||
| } | ||
| } | ||
| bolt11 = { | ||
| decode, | ||
| hrpToMillisat | ||
| }; | ||
| return bolt11; | ||
| } | ||
| var bolt11Exports = requireBolt11(); | ||
| // from https://stackoverflow.com/a/50868276 | ||
| const fromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))); | ||
| const decodeInvoice = (paymentRequest) => { | ||
| if (!paymentRequest) | ||
| return null; | ||
| try { | ||
| const decoded = bolt11Exports.decode(paymentRequest); | ||
| if (!decoded || !decoded.sections) | ||
| return null; | ||
| const hashTag = decoded.sections.find((value) => value.name === "payment_hash"); | ||
| if (hashTag?.name !== "payment_hash" || !hashTag.value) | ||
| return null; | ||
| const paymentHash = hashTag.value; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
| } | ||
| const timestampTag = decoded.sections.find((value) => value.name === "timestamp"); | ||
| if (timestampTag?.name !== "timestamp" || !timestampTag.value) | ||
| return null; | ||
| const timestamp = timestampTag.value; | ||
| let expiry; | ||
| const expiryTag = decoded.sections.find((value) => value.name === "expiry"); | ||
| if (expiryTag?.name === "expiry") { | ||
| expiry = expiryTag.value; | ||
| } | ||
| const descriptionTag = decoded.sections.find((value) => value.name === "description"); | ||
| const description = descriptionTag?.name === "description" | ||
| ? descriptionTag?.value | ||
| : undefined; | ||
| return { | ||
| paymentHash, | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
| expiry, | ||
| description, | ||
| }; | ||
| } | ||
| catch { | ||
| return null; | ||
| } | ||
| }; | ||
| function bytes(b, ...lengths) { | ||
| if (!(b instanceof Uint8Array)) | ||
| throw new Error('Expected Uint8Array'); | ||
| if (lengths.length > 0 && !lengths.includes(b.length)) | ||
| throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`); | ||
| } | ||
| function exists(instance, checkFinished = true) { | ||
| if (instance.destroyed) | ||
| throw new Error('Hash instance has been destroyed'); | ||
| if (checkFinished && instance.finished) | ||
| throw new Error('Hash#digest() has already been called'); | ||
| } | ||
| function output(out, instance) { | ||
| bytes(out); | ||
| const min = instance.outputLen; | ||
| if (out.length < min) { | ||
| throw new Error(`digestInto() expects output buffer of length at least ${min}`); | ||
| } | ||
| } | ||
| /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| // We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+. | ||
| // node.js versions earlier than v19 don't declare it in global scope. | ||
| // For node.js, package.json#exports field mapping rewrites import | ||
| // from `crypto` to `cryptoNode`, which imports native module. | ||
| // Makes the utils un-importable in browsers without a bundler. | ||
| // Once node.js 18 is deprecated, we can just drop the import. | ||
| const u8a = (a) => a instanceof Uint8Array; | ||
| // Cast array to view | ||
| const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength); | ||
| // The rotate right (circular right shift) operation for uint32 | ||
| const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift); | ||
| // big-endian hardware is rare. Just in case someone still decides to run hashes: | ||
| // early-throw an error because we don't support BE yet. | ||
| const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44; | ||
| if (!isLE) | ||
| throw new Error('Non little-endian hardware is not supported'); | ||
| const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0')); | ||
| /** | ||
| * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123' | ||
| */ | ||
| function bytesToHex(bytes) { | ||
| if (!u8a(bytes)) | ||
| throw new Error('Uint8Array expected'); | ||
| // pre-caching improves the speed 6x | ||
| let hex = ''; | ||
| for (let i = 0; i < bytes.length; i++) { | ||
| hex += hexes[bytes[i]]; | ||
| } | ||
| return hex; | ||
| } | ||
| /** | ||
| * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99]) | ||
| */ | ||
| function utf8ToBytes(str) { | ||
| if (typeof str !== 'string') | ||
| throw new Error(`utf8ToBytes expected string, got ${typeof str}`); | ||
| return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809 | ||
| } | ||
| /** | ||
| * Normalizes (non-hex) string or Uint8Array to Uint8Array. | ||
| * Warning: when Uint8Array is passed, it would NOT get copied. | ||
| * Keep in mind for future mutable operations. | ||
| */ | ||
| function toBytes(data) { | ||
| if (typeof data === 'string') | ||
| data = utf8ToBytes(data); | ||
| if (!u8a(data)) | ||
| throw new Error(`expected Uint8Array, got ${typeof data}`); | ||
| return data; | ||
| } | ||
| // For runtime check if class implements interface | ||
| class Hash { | ||
| // Safe version that clones internal state | ||
| clone() { | ||
| return this._cloneInto(); | ||
| } | ||
| } | ||
| function wrapConstructor(hashCons) { | ||
| const hashC = (msg) => hashCons().update(toBytes(msg)).digest(); | ||
| const tmp = hashCons(); | ||
| hashC.outputLen = tmp.outputLen; | ||
| hashC.blockLen = tmp.blockLen; | ||
| hashC.create = () => hashCons(); | ||
| return hashC; | ||
| } | ||
| // Polyfill for Safari 14 | ||
| function setBigUint64(view, byteOffset, value, isLE) { | ||
| if (typeof view.setBigUint64 === 'function') | ||
| return view.setBigUint64(byteOffset, value, isLE); | ||
| const _32n = BigInt(32); | ||
| const _u32_max = BigInt(0xffffffff); | ||
| const wh = Number((value >> _32n) & _u32_max); | ||
| const wl = Number(value & _u32_max); | ||
| const h = isLE ? 4 : 0; | ||
| const l = isLE ? 0 : 4; | ||
| view.setUint32(byteOffset + h, wh, isLE); | ||
| view.setUint32(byteOffset + l, wl, isLE); | ||
| } | ||
| // Base SHA2 class (RFC 6234) | ||
| class SHA2 extends Hash { | ||
| constructor(blockLen, outputLen, padOffset, isLE) { | ||
| super(); | ||
| this.blockLen = blockLen; | ||
| this.outputLen = outputLen; | ||
| this.padOffset = padOffset; | ||
| this.isLE = isLE; | ||
| this.finished = false; | ||
| this.length = 0; | ||
| this.pos = 0; | ||
| this.destroyed = false; | ||
| this.buffer = new Uint8Array(blockLen); | ||
| this.view = createView(this.buffer); | ||
| } | ||
| update(data) { | ||
| exists(this); | ||
| const { view, buffer, blockLen } = this; | ||
| data = toBytes(data); | ||
| const len = data.length; | ||
| for (let pos = 0; pos < len;) { | ||
| const take = Math.min(blockLen - this.pos, len - pos); | ||
| // Fast path: we have at least one block in input, cast it to view and process | ||
| if (take === blockLen) { | ||
| const dataView = createView(data); | ||
| for (; blockLen <= len - pos; pos += blockLen) | ||
| this.process(dataView, pos); | ||
| continue; | ||
| } | ||
| buffer.set(data.subarray(pos, pos + take), this.pos); | ||
| this.pos += take; | ||
| pos += take; | ||
| if (this.pos === blockLen) { | ||
| this.process(view, 0); | ||
| this.pos = 0; | ||
| } | ||
| } | ||
| this.length += data.length; | ||
| this.roundClean(); | ||
| return this; | ||
| } | ||
| digestInto(out) { | ||
| exists(this); | ||
| output(out, this); | ||
| this.finished = true; | ||
| // Padding | ||
| // We can avoid allocation of buffer for padding completely if it | ||
| // was previously not allocated here. But it won't change performance. | ||
| const { buffer, view, blockLen, isLE } = this; | ||
| let { pos } = this; | ||
| // append the bit '1' to the message | ||
| buffer[pos++] = 0b10000000; | ||
| this.buffer.subarray(pos).fill(0); | ||
| // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again | ||
| if (this.padOffset > blockLen - pos) { | ||
| this.process(view, 0); | ||
| pos = 0; | ||
| } | ||
| // Pad until full block byte with zeros | ||
| for (let i = pos; i < blockLen; i++) | ||
| buffer[i] = 0; | ||
| // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that | ||
| // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen. | ||
| // So we just write lowest 64 bits of that value. | ||
| setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE); | ||
| this.process(view, 0); | ||
| const oview = createView(out); | ||
| const len = this.outputLen; | ||
| // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT | ||
| if (len % 4) | ||
| throw new Error('_sha2: outputLen should be aligned to 32bit'); | ||
| const outLen = len / 4; | ||
| const state = this.get(); | ||
| if (outLen > state.length) | ||
| throw new Error('_sha2: outputLen bigger than state'); | ||
| for (let i = 0; i < outLen; i++) | ||
| oview.setUint32(4 * i, state[i], isLE); | ||
| } | ||
| digest() { | ||
| const { buffer, outputLen } = this; | ||
| this.digestInto(buffer); | ||
| const res = buffer.slice(0, outputLen); | ||
| this.destroy(); | ||
| return res; | ||
| } | ||
| _cloneInto(to) { | ||
| to || (to = new this.constructor()); | ||
| to.set(...this.get()); | ||
| const { blockLen, buffer, length, finished, destroyed, pos } = this; | ||
| to.length = length; | ||
| to.pos = pos; | ||
| to.finished = finished; | ||
| to.destroyed = destroyed; | ||
| if (length % blockLen) | ||
| to.buffer.set(buffer); | ||
| return to; | ||
| } | ||
| } | ||
| // SHA2-256 need to try 2^128 hashes to execute birthday attack. | ||
| // BTC network is doing 2^67 hashes/sec as per early 2023. | ||
| // Choice: a ? b : c | ||
| const Chi = (a, b, c) => (a & b) ^ (~a & c); | ||
| // Majority function, true if any two inpust is true | ||
| const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c); | ||
| // Round constants: | ||
| // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311) | ||
| // prettier-ignore | ||
| const SHA256_K = /* @__PURE__ */ new Uint32Array([ | ||
| 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | ||
| 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | ||
| 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | ||
| 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | ||
| 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | ||
| 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | ||
| 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | ||
| 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 | ||
| ]); | ||
| // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19): | ||
| // prettier-ignore | ||
| const IV = /* @__PURE__ */ new Uint32Array([ | ||
| 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 | ||
| ]); | ||
| // Temporary buffer, not used to store anything between runs | ||
| // Named this way because it matches specification. | ||
| const SHA256_W = /* @__PURE__ */ new Uint32Array(64); | ||
| class SHA256 extends SHA2 { | ||
| constructor() { | ||
| super(64, 32, 8, false); | ||
| // We cannot use array here since array allows indexing by variable | ||
| // which means optimizer/compiler cannot use registers. | ||
| this.A = IV[0] | 0; | ||
| this.B = IV[1] | 0; | ||
| this.C = IV[2] | 0; | ||
| this.D = IV[3] | 0; | ||
| this.E = IV[4] | 0; | ||
| this.F = IV[5] | 0; | ||
| this.G = IV[6] | 0; | ||
| this.H = IV[7] | 0; | ||
| } | ||
| get() { | ||
| const { A, B, C, D, E, F, G, H } = this; | ||
| return [A, B, C, D, E, F, G, H]; | ||
| } | ||
| // prettier-ignore | ||
| set(A, B, C, D, E, F, G, H) { | ||
| this.A = A | 0; | ||
| this.B = B | 0; | ||
| this.C = C | 0; | ||
| this.D = D | 0; | ||
| this.E = E | 0; | ||
| this.F = F | 0; | ||
| this.G = G | 0; | ||
| this.H = H | 0; | ||
| } | ||
| process(view, offset) { | ||
| // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array | ||
| for (let i = 0; i < 16; i++, offset += 4) | ||
| SHA256_W[i] = view.getUint32(offset, false); | ||
| for (let i = 16; i < 64; i++) { | ||
| const W15 = SHA256_W[i - 15]; | ||
| const W2 = SHA256_W[i - 2]; | ||
| const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3); | ||
| const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10); | ||
| SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0; | ||
| } | ||
| // Compression function main loop, 64 rounds | ||
| let { A, B, C, D, E, F, G, H } = this; | ||
| for (let i = 0; i < 64; i++) { | ||
| const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25); | ||
| const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0; | ||
| const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22); | ||
| const T2 = (sigma0 + Maj(A, B, C)) | 0; | ||
| H = G; | ||
| G = F; | ||
| F = E; | ||
| E = (D + T1) | 0; | ||
| D = C; | ||
| C = B; | ||
| B = A; | ||
| A = (T1 + T2) | 0; | ||
| } | ||
| // Add the compressed chunk to the current hash value | ||
| A = (A + this.A) | 0; | ||
| B = (B + this.B) | 0; | ||
| C = (C + this.C) | 0; | ||
| D = (D + this.D) | 0; | ||
| E = (E + this.E) | 0; | ||
| F = (F + this.F) | 0; | ||
| G = (G + this.G) | 0; | ||
| H = (H + this.H) | 0; | ||
| this.set(A, B, C, D, E, F, G, H); | ||
| } | ||
| roundClean() { | ||
| SHA256_W.fill(0); | ||
| } | ||
| destroy() { | ||
| this.set(0, 0, 0, 0, 0, 0, 0, 0); | ||
| this.buffer.fill(0); | ||
| } | ||
| } | ||
| /** | ||
| * SHA2-256 hash function | ||
| * @param message - data that would be hashed | ||
| */ | ||
| const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256()); | ||
| class Invoice { | ||
| constructor(args) { | ||
| this.paymentRequest = args.pr; | ||
| if (!this.paymentRequest) { | ||
| throw new Error("Invalid payment request"); | ||
| } | ||
| const decodedInvoice = decodeInvoice(this.paymentRequest); | ||
| if (!decodedInvoice) { | ||
| throw new Error("Failed to decode payment request"); | ||
| } | ||
| this.paymentHash = decodedInvoice.paymentHash; | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
| this.expiry = decodedInvoice.expiry; | ||
| this.createdDate = new Date(this.timestamp * 1000); | ||
| this.expiryDate = this.expiry | ||
| ? new Date((this.timestamp + this.expiry) * 1000) | ||
| : undefined; | ||
| this.description = decodedInvoice.description ?? null; | ||
| this.verify = args.verify ?? null; | ||
| this.preimage = args.preimage ?? null; | ||
| this.successAction = args.successAction ?? null; | ||
| } | ||
| async isPaid() { | ||
| if (this.preimage) | ||
| return this.validatePreimage(this.preimage); | ||
| else if (this.verify) { | ||
| return await this.verifyPayment(); | ||
| } | ||
| else { | ||
| throw new Error("Could not verify payment"); | ||
| } | ||
| } | ||
| validatePreimage(preimage) { | ||
| if (!preimage || !this.paymentHash) | ||
| return false; | ||
| try { | ||
| const preimageHash = bytesToHex(sha256(fromHexString(preimage))); | ||
| return this.paymentHash === preimageHash; | ||
| } | ||
| catch { | ||
| return false; | ||
| } | ||
| } | ||
| async verifyPayment() { | ||
| try { | ||
| if (!this.verify) { | ||
| throw new Error("LNURL verify not available"); | ||
| } | ||
| const response = await fetch(this.verify); | ||
| if (!response.ok) { | ||
| throw new Error(`Verification request failed: ${response.status} ${response.statusText}`); | ||
| } | ||
| const json = await response.json(); | ||
| if (json.preimage) { | ||
| this.preimage = json.preimage; | ||
| } | ||
| return json.settled; | ||
| } | ||
| catch (error) { | ||
| console.error("Failed to check LNURL-verify", error); | ||
| return false; | ||
| } | ||
| } | ||
| hasExpired() { | ||
| const { expiryDate } = this; | ||
| if (expiryDate) { | ||
| return expiryDate.getTime() < Date.now(); | ||
| } | ||
| return false; | ||
| } | ||
| } | ||
| const handleX402Payment = async (x402Header, url, fetchArgs, headers, wallet) => { | ||
| let parsed; | ||
| try { | ||
| parsed = JSON.parse(decodeURIComponent(escape(atob(x402Header)))); | ||
| } | ||
| catch (_) { | ||
| throw new Error("x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)"); | ||
| } | ||
| if (!Array.isArray(parsed.accepts) || parsed.accepts.length === 0) { | ||
| throw new Error("x402: PAYMENT-REQUIRED header contains no payment options"); | ||
| } | ||
| const requirements = parsed.accepts.find((e) => { | ||
| return e.extra?.paymentMethod === "lightning"; | ||
| }); | ||
| if (!requirements) { | ||
| throw new Error("x402: unsupported x402 network, only Bitcoin lightning network is supported."); | ||
| } | ||
| if (!requirements.extra?.invoice) { | ||
| throw new Error("x402: payment requirements missing lightning invoice"); | ||
| } | ||
| const invoice = new Invoice({ pr: requirements.extra.invoice }); | ||
| if (invoice.amountRaw != requirements.amount) { | ||
| throw new Error(`Invalid invoice amount: ${invoice.amountRaw}. expected ${requirements.amount}`); | ||
| } | ||
| await wallet.payInvoice({ invoice: invoice.paymentRequest }); | ||
| headers.set("payment-signature", buildX402PaymentSignature(requirements.scheme, requirements.network, invoice.paymentRequest, requirements)); | ||
| return fetch(url, fetchArgs); | ||
| }; | ||
| const fetchWithX402 = async (url, fetchArgs, options) => { | ||
| const wallet = options.wallet; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| const headers = new Headers(fetchArgs.headers ?? undefined); | ||
| fetchArgs.headers = headers; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("PAYMENT-REQUIRED"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| return handleX402Payment(header, url, fetchArgs, headers, wallet); | ||
| }; | ||
| export { fetchWithX402 }; | ||
| //# sourceMappingURL=x402.js.map |
Sorry, the diff of this file is too big to display
| interface Wallet { | ||
| payInvoice(args: { | ||
| invoice: string; | ||
| }): Promise<{ | ||
| preimage: string; | ||
| }>; | ||
| } | ||
| declare function createGuardedWallet(wallet: Wallet, maxAmountSats: number): Wallet; | ||
| declare const fetch402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| maxAmount?: number; | ||
| }) => Promise<Response>; | ||
| declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| export { createGuardedWallet, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402 }; | ||
| export type { Wallet }; |
| interface Wallet { | ||
| payInvoice(args: { | ||
| invoice: string; | ||
| }): Promise<{ | ||
| preimage: string; | ||
| }>; | ||
| } | ||
| declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| export { fetchWithL402 }; |
| interface Wallet { | ||
| payInvoice(args: { | ||
| invoice: string; | ||
| }): Promise<{ | ||
| preimage: string; | ||
| }>; | ||
| } | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| export { fetchWithMpp }; |
| interface Wallet { | ||
| payInvoice(args: { | ||
| invoice: string; | ||
| }): Promise<{ | ||
| preimage: string; | ||
| }>; | ||
| } | ||
| declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| export { fetchWithX402 }; |
@@ -837,4 +837,8 @@ 'use strict'; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
@@ -858,2 +862,4 @@ } | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
@@ -1188,2 +1194,4 @@ expiry, | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
@@ -1190,0 +1198,0 @@ this.expiry = decodedInvoice.expiry; |
@@ -1315,4 +1315,8 @@ 'use strict'; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
@@ -1336,2 +1340,4 @@ } | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
@@ -1359,2 +1365,4 @@ expiry, | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
@@ -1361,0 +1369,0 @@ this.expiry = decodedInvoice.expiry; |
@@ -835,4 +835,8 @@ var lib = {}; | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
@@ -856,2 +860,4 @@ } | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
@@ -1186,2 +1192,4 @@ expiry, | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
@@ -1188,0 +1196,0 @@ this.expiry = decodedInvoice.expiry; |
@@ -1313,4 +1313,8 @@ function bytes(b, ...lengths) { | ||
| let satoshi = 0; | ||
| let millisatoshi = 0; | ||
| let amountRaw = "0"; | ||
| const amountTag = decoded.sections.find((value) => value.name === "amount"); | ||
| if (amountTag?.name === "amount" && amountTag.value) { | ||
| amountRaw = amountTag.value; | ||
| millisatoshi = parseInt(amountTag.value); | ||
| satoshi = parseInt(amountTag.value) / 1000; // millisats | ||
@@ -1334,2 +1338,4 @@ } | ||
| satoshi, | ||
| millisatoshi, | ||
| amountRaw, | ||
| timestamp, | ||
@@ -1357,2 +1363,4 @@ expiry, | ||
| this.satoshi = decodedInvoice.satoshi; | ||
| this.millisatoshi = decodedInvoice.millisatoshi; | ||
| this.amountRaw = decodedInvoice.amountRaw; | ||
| this.timestamp = decodedInvoice.timestamp; | ||
@@ -1359,0 +1367,0 @@ this.expiry = decodedInvoice.expiry; |
| !function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).LightningTools={})}(this,function(e){"use strict";var t,r,n,o={};var s=function(){if(n)return r;n=1;const{bech32:e,hex:s,utf8:i}=(t||(t=1,function(e){function t(e){if(!Number.isSafeInteger(e))throw new Error(`Wrong integer: ${e}`)}function r(...e){const t=(e,t)=>r=>e(t(r));return{encode:Array.from(e).reverse().reduce((e,r)=>e?t(e,r.encode):r.encode,void 0),decode:e.reduce((e,r)=>e?t(e,r.decode):r.decode,void 0)}}function n(e){return{encode:r=>{if(!Array.isArray(r)||r.length&&"number"!=typeof r[0])throw new Error("alphabet.encode input should be an array of numbers");return r.map(r=>{if(t(r),r<0||r>=e.length)throw new Error(`Digit index outside alphabet: ${r} (alphabet: ${e.length})`);return e[r]})},decode:t=>{if(!Array.isArray(t)||t.length&&"string"!=typeof t[0])throw new Error("alphabet.decode input should be array of strings");return t.map(t=>{if("string"!=typeof t)throw new Error(`alphabet.decode: not string element=${t}`);const r=e.indexOf(t);if(-1===r)throw new Error(`Unknown letter: "${t}". Allowed: ${e}`);return r})}}}function o(e=""){if("string"!=typeof e)throw new Error("join separator should be string");return{encode:t=>{if(!Array.isArray(t)||t.length&&"string"!=typeof t[0])throw new Error("join.encode input should be array of strings");for(let e of t)if("string"!=typeof e)throw new Error(`join.encode: non-string input=${e}`);return t.join(e)},decode:t=>{if("string"!=typeof t)throw new Error("join.decode input should be string");return t.split(e)}}}function s(e,r="="){if(t(e),"string"!=typeof r)throw new Error("padding chr should be string");return{encode(t){if(!Array.isArray(t)||t.length&&"string"!=typeof t[0])throw new Error("padding.encode input should be array of strings");for(let e of t)if("string"!=typeof e)throw new Error(`padding.encode: non-string input=${e}`);for(;t.length*e%8;)t.push(r);return t},decode(t){if(!Array.isArray(t)||t.length&&"string"!=typeof t[0])throw new Error("padding.encode input should be array of strings");for(let e of t)if("string"!=typeof e)throw new Error(`padding.decode: non-string input=${e}`);let n=t.length;if(n*e%8)throw new Error("Invalid padding: string should have whole number of bytes");for(;n>0&&t[n-1]===r;n--)if(!((n-1)*e%8))throw new Error("Invalid padding: string has too much padding");return t.slice(0,n)}}}function i(e){if("function"!=typeof e)throw new Error("normalize fn should be function");return{encode:e=>e,decode:t=>e(t)}}function a(e,r,n){if(r<2)throw new Error(`convertRadix: wrong from=${r}, base cannot be less than 2`);if(n<2)throw new Error(`convertRadix: wrong to=${n}, base cannot be less than 2`);if(!Array.isArray(e))throw new Error("convertRadix: data should be array");if(!e.length)return[];let o=0;const s=[],i=Array.from(e);for(i.forEach(e=>{if(t(e),e<0||e>=r)throw new Error(`Wrong integer: ${e}`)});;){let e=0,t=!0;for(let s=o;s<i.length;s++){const a=i[s],c=r*e+a;if(!Number.isSafeInteger(c)||r*e/r!==e||c-a!==r*e)throw new Error("convertRadix: carry overflow");if(e=c%n,i[s]=Math.floor(c/n),!Number.isSafeInteger(i[s])||i[s]*n+e!==c)throw new Error("convertRadix: carry overflow");t&&(i[s]?t=!1:o=s)}if(s.push(e),t)break}for(let t=0;t<e.length-1&&0===e[t];t++)s.push(0);return s.reverse()} | ||
| /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */ | ||
| Object.defineProperty(e,"__esModule",{value:!0}),e.bytes=e.stringToBytes=e.str=e.bytesToString=e.hex=e.utf8=e.bech32m=e.bech32=e.base58check=e.base58xmr=e.base58xrp=e.base58flickr=e.base58=e.base64url=e.base64=e.base32crockford=e.base32hex=e.base32=e.base16=e.utils=e.assertNumber=void 0,e.assertNumber=t;const c=(e,t)=>t?c(t,e%t):e,h=(e,t)=>e+(t-c(e,t));function l(e,r,n,o){if(!Array.isArray(e))throw new Error("convertRadix2: data should be array");if(r<=0||r>32)throw new Error(`convertRadix2: wrong from=${r}`);if(n<=0||n>32)throw new Error(`convertRadix2: wrong to=${n}`);if(h(r,n)>32)throw new Error(`convertRadix2: carry overflow from=${r} to=${n} carryBits=${h(r,n)}`);let s=0,i=0;const a=2**n-1,c=[];for(const o of e){if(t(o),o>=2**r)throw new Error(`convertRadix2: invalid data word=${o} from=${r}`);if(s=s<<r|o,i+r>32)throw new Error(`convertRadix2: carry overflow pos=${i} from=${r}`);for(i+=r;i>=n;i-=n)c.push((s>>i-n&a)>>>0);s&=2**i-1}if(s=s<<n-i&a,!o&&i>=r)throw new Error("Excess padding");if(!o&&s)throw new Error(`Non-zero padding: ${s}`);return o&&i>0&&c.push(s>>>0),c}function u(e){return t(e),{encode:t=>{if(!(t instanceof Uint8Array))throw new Error("radix.encode input should be Uint8Array");return a(Array.from(t),256,e)},decode:t=>{if(!Array.isArray(t)||t.length&&"number"!=typeof t[0])throw new Error("radix.decode input should be array of strings");return Uint8Array.from(a(t,e,256))}}}function f(e,r=!1){if(t(e),e<=0||e>32)throw new Error("radix2: bits should be in (0..32]");if(h(8,e)>32||h(e,8)>32)throw new Error("radix2: carry overflow");return{encode:t=>{if(!(t instanceof Uint8Array))throw new Error("radix2.encode input should be Uint8Array");return l(Array.from(t),8,e,!r)},decode:t=>{if(!Array.isArray(t)||t.length&&"number"!=typeof t[0])throw new Error("radix2.decode input should be array of strings");return Uint8Array.from(l(t,e,8,r))}}}function d(e){if("function"!=typeof e)throw new Error("unsafeWrapper fn should be function");return function(...t){try{return e.apply(null,t)}catch(e){}}}function p(e,r){if(t(e),"function"!=typeof r)throw new Error("checksum fn should be function");return{encode(t){if(!(t instanceof Uint8Array))throw new Error("checksum.encode: input should be Uint8Array");const n=r(t).slice(0,e),o=new Uint8Array(t.length+e);return o.set(t),o.set(n,t.length),o},decode(t){if(!(t instanceof Uint8Array))throw new Error("checksum.decode: input should be Uint8Array");const n=t.slice(0,-e),o=r(n).slice(0,e),s=t.slice(-e);for(let t=0;t<e;t++)if(o[t]!==s[t])throw new Error("Invalid checksum");return n}}}e.utils={alphabet:n,chain:r,checksum:p,radix:u,radix2:f,join:o,padding:s},e.base16=r(f(4),n("0123456789ABCDEF"),o("")),e.base32=r(f(5),n("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"),s(5),o("")),e.base32hex=r(f(5),n("0123456789ABCDEFGHIJKLMNOPQRSTUV"),s(5),o("")),e.base32crockford=r(f(5),n("0123456789ABCDEFGHJKMNPQRSTVWXYZ"),o(""),i(e=>e.toUpperCase().replace(/O/g,"0").replace(/[IL]/g,"1"))),e.base64=r(f(6),n("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),s(6),o("")),e.base64url=r(f(6),n("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"),s(6),o(""));const w=e=>r(u(58),n(e),o(""));e.base58=w("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"),e.base58flickr=w("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"),e.base58xrp=w("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");const y=[0,2,3,5,6,7,9,10,11];e.base58xmr={encode(t){let r="";for(let n=0;n<t.length;n+=8){const o=t.subarray(n,n+8);r+=e.base58.encode(o).padStart(y[o.length],"1")}return r},decode(t){let r=[];for(let n=0;n<t.length;n+=11){const o=t.slice(n,n+11),s=y.indexOf(o.length),i=e.base58.decode(o);for(let e=0;e<i.length-s;e++)if(0!==i[e])throw new Error("base58xmr: wrong padding");r=r.concat(Array.from(i.slice(i.length-s)))}return Uint8Array.from(r)}},e.base58check=t=>r(p(4,e=>t(t(e))),e.base58);const m=r(n("qpzry9x8gf2tvdw0s3jn54khce6mua7l"),o("")),g=[996825010,642813549,513874426,1027748829,705979059];function b(e){const t=e>>25;let r=(33554431&e)<<5;for(let e=0;e<g.length;e++)1==(t>>e&1)&&(r^=g[e]);return r}function E(e,t,r=1){const n=e.length;let o=1;for(let t=0;t<n;t++){const r=e.charCodeAt(t);if(r<33||r>126)throw new Error(`Invalid prefix (${e})`);o=b(o)^r>>5}o=b(o);for(let t=0;t<n;t++)o=b(o)^31&e.charCodeAt(t);for(let e of t)o=b(o)^e;for(let e=0;e<6;e++)o=b(o);return o^=r,m.encode(l([o%2**30],30,5,!1))}function v(e){const t="bech32"===e?1:734539939,r=f(5),n=r.decode,o=r.encode,s=d(n);function i(e,r=90){if("string"!=typeof e)throw new Error("bech32.decode input should be string, not "+typeof e);if(e.length<8||!1!==r&&e.length>r)throw new TypeError(`Wrong string length: ${e.length} (${e}). Expected (8..${r})`);const n=e.toLowerCase();if(e!==n&&e!==e.toUpperCase())throw new Error("String must be lowercase or uppercase");const o=(e=n).lastIndexOf("1");if(0===o||-1===o)throw new Error('Letter "1" must be present between prefix and data only');const s=e.slice(0,o),i=e.slice(o+1);if(i.length<6)throw new Error("Data must be at least 6 characters long");const a=m.decode(i).slice(0,-6),c=E(s,a,t);if(!i.endsWith(c))throw new Error(`Invalid checksum in ${e}: expected "${c}"`);return{prefix:s,words:a}}return{encode:function(e,r,n=90){if("string"!=typeof e)throw new Error("bech32.encode prefix should be string, not "+typeof e);if(!Array.isArray(r)||r.length&&"number"!=typeof r[0])throw new Error("bech32.encode words should be array of numbers, not "+typeof r);const o=e.length+7+r.length;if(!1!==n&&o>n)throw new TypeError(`Length ${o} exceeds limit ${n}`);return`${e=e.toLowerCase()}1${m.encode(r)}${E(e,r,t)}`},decode:i,decodeToBytes:function(e){const{prefix:t,words:r}=i(e,!1);return{prefix:t,words:r,bytes:n(r)}},decodeUnsafe:d(i),fromWords:n,fromWordsUnsafe:s,toWords:o}}e.bech32=v("bech32"),e.bech32m=v("bech32m"),e.utf8={encode:e=>(new TextDecoder).decode(e),decode:e=>(new TextEncoder).encode(e)},e.hex=r(f(4),n("0123456789abcdef"),o(""),i(e=>{if("string"!=typeof e||e.length%2)throw new TypeError(`hex.decode: expected string, got ${typeof e} with length ${e.length}`);return e.toLowerCase()}));const x={utf8:e.utf8,hex:e.hex,base16:e.base16,base32:e.base32,base64:e.base64,base64url:e.base64url,base58:e.base58,base58xmr:e.base58xmr},A=`Invalid encoding type. Available types: ${Object.keys(x).join(", ")}`;e.bytesToString=(e,t)=>{if("string"!=typeof e||!x.hasOwnProperty(e))throw new TypeError(A);if(!(t instanceof Uint8Array))throw new TypeError("bytesToString() expects Uint8Array");return x[e].encode(t)},e.str=e.bytesToString,e.stringToBytes=(e,t)=>{if(!x.hasOwnProperty(e))throw new TypeError(A);if("string"!=typeof t)throw new TypeError("stringToBytes() expects string");return x[e].decode(t)},e.bytes=e.stringToBytes}(o)),o),a={bech32:"bc",pubKeyHash:0,scriptHash:5,validWitnessVersions:[0]},c={bech32:"tb",pubKeyHash:111,scriptHash:196,validWitnessVersions:[0]},h={bech32:"tbs",pubKeyHash:111,scriptHash:196,validWitnessVersions:[0]},l={bech32:"bcrt",pubKeyHash:111,scriptHash:196,validWitnessVersions:[0]},u={bech32:"sb",pubKeyHash:63,scriptHash:123,validWitnessVersions:[0]},f=["option_data_loss_protect","initial_routing_sync","option_upfront_shutdown_script","gossip_queries","var_onion_optin","gossip_queries_ex","option_static_remotekey","payment_secret","basic_mpp","option_support_large_channel"],d={m:BigInt(1e3),u:BigInt(1e6),n:BigInt(1e9),p:BigInt(1e12)},p=BigInt("2100000000000000000"),w=BigInt(1e11),y={payment_hash:1,payment_secret:16,description:13,payee:19,description_hash:23,expiry:6,min_final_cltv_expiry:24,fallback_address:9,route_hint:3,feature_bits:5,metadata:27},m={};for(let e=0,t=Object.keys(y);e<t.length;e++){const r=t[e],n=y[t[e]].toString();m[n]=r}const g={1:t=>s.encode(e.fromWordsUnsafe(t)),16:t=>s.encode(e.fromWordsUnsafe(t)),13:t=>i.encode(e.fromWordsUnsafe(t)),19:t=>s.encode(e.fromWordsUnsafe(t)),23:t=>s.encode(e.fromWordsUnsafe(t)),27:t=>s.encode(e.fromWordsUnsafe(t)),6:E,24:E,3:function(t){const r=[];let n,o,i,a,c,h=e.fromWordsUnsafe(t);for(;h.length>0;)n=s.encode(h.slice(0,33)),o=s.encode(h.slice(33,41)),i=parseInt(s.encode(h.slice(41,45)),16),a=parseInt(s.encode(h.slice(45,49)),16),c=parseInt(s.encode(h.slice(49,51)),16),h=h.slice(51),r.push({pubkey:n,short_channel_id:o,fee_base_msat:i,fee_proportional_millionths:a,cltv_expiry_delta:c});return r},5:function(e){const t=e.slice().reverse().map(e=>[!!(1&e),!!(2&e),!!(4&e),!!(8&e),!!(16&e)]).reduce((e,t)=>e.concat(t),[]);for(;t.length<2*f.length;)t.push(!1);const r={};f.forEach((e,n)=>{let o;o=t[2*n]?"required":t[2*n+1]?"supported":"unsupported",r[e]=o});const n=t.slice(2*f.length);return r.extra_bits={start_bit:2*f.length,bits:n,has_required:n.reduce((e,t,r)=>r%2!=0?e||!1:e||t,!1)},r}};function b(t){return r=>({tagCode:parseInt(t),words:e.encode("unknown",r,Number.MAX_SAFE_INTEGER)})}function E(e){return e.reverse().reduce((e,t,r)=>e+t*Math.pow(32,r),0)}function v(e,t){let r,n;if(e.slice(-1).match(/^[munp]$/))r=e.slice(-1),n=e.slice(0,-1);else{if(e.slice(-1).match(/^[^munp0-9]$/))throw new Error("Not a valid multiplier for the amount");n=e}if(!n.match(/^\d+$/))throw new Error("Not a valid human readable amount");const o=BigInt(n),s=r?o*w/d[r]:o*w;if("p"===r&&o%BigInt(10)!==BigInt(0)||s>p)throw new Error("Amount is outside of valid range");return t?s.toString():s}return r={decode:function(t,r){if("string"!=typeof t)throw new Error("Lightning Payment Request must be string");if("ln"!==t.slice(0,2).toLowerCase())throw new Error("Not a proper lightning payment request");const n=[],o=e.decode(t,Number.MAX_SAFE_INTEGER);t=t.toLowerCase();const i=o.prefix;let f=o.words,d=t.slice(i.length+1),p=f.slice(-104);f=f.slice(0,-104);let w=i.match(/^ln(\S+?)(\d*)([a-zA-Z]?)$/);if(w&&!w[2]&&(w=i.match(/^ln(\S+)$/)),!w)throw new Error("Not a proper lightning payment request");n.push({name:"lightning_network",letters:"ln"});const x=w[1];let A;if(r){if(void 0===r.bech32||void 0===r.pubKeyHash||void 0===r.scriptHash||!Array.isArray(r.validWitnessVersions))throw new Error("Invalid network");A=r}else switch(x){case a.bech32:A=a;break;case c.bech32:A=c;break;case h.bech32:A=h;break;case l.bech32:A=l;break;case u.bech32:A=u}if(!A||A.bech32!==x)throw new Error("Unknown coin bech32 prefix");n.push({name:"coin_network",letters:x,value:A});const k=w[2];let $;if(k){$=v(k+w[3],!0),n.push({name:"amount",letters:w[2]+w[3],value:$})}else $=null;n.push({name:"separator",letters:"1"});const U=E(f.slice(0,7));let _,L,I,N;for(f=f.slice(7),n.push({name:"timestamp",letters:d.slice(0,7),value:U}),d=d.slice(7);f.length>0;){const e=f[0].toString();_=m[e]||"unknown_tag",L=g[e]||b(e),f=f.slice(1),I=E(f.slice(0,2)),f=f.slice(2),N=f.slice(0,I),f=f.slice(I),n.push({name:_,tag:d[0],letters:d.slice(0,3+I),value:L(N)}),d=d.slice(3+I)}n.push({name:"signature",letters:d.slice(0,104),value:s.encode(e.fromWordsUnsafe(p))}),d=d.slice(104),n.push({name:"checksum",letters:d});let D={paymentRequest:t,sections:n,get expiry(){let e=n.find(e=>"expiry"===e.name);if(e)return S("timestamp")+e.value},get route_hints(){return n.filter(e=>"route_hint"===e.name).map(e=>e.value)}};for(let e in y)"route_hint"!==e&&Object.defineProperty(D,e,{get:()=>S(e)});return D;function S(e){let t=n.find(t=>t.name===e);return t?t.value:void 0}},hrpToMillisat:v}}();const i=e=>Uint8Array.from(e.match(/.{1,2}/g).map(e=>parseInt(e,16))),a=e=>{if(!e)return null;try{const t=s.decode(e);if(!t||!t.sections)return null;const r=t.sections.find(e=>"payment_hash"===e.name);if("payment_hash"!==r?.name||!r.value)return null;const n=r.value;let o=0;const i=t.sections.find(e=>"amount"===e.name);"amount"===i?.name&&i.value&&(o=parseInt(i.value)/1e3);const a=t.sections.find(e=>"timestamp"===e.name);if("timestamp"!==a?.name||!a.value)return null;const c=a.value;let h;const l=t.sections.find(e=>"expiry"===e.name);"expiry"===l?.name&&(h=l.value);const u=t.sections.find(e=>"description"===e.name);return{paymentHash:n,satoshi:o,timestamp:c,expiry:h,description:"description"===u?.name?u?.value:void 0}}catch{return null}};function c(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")}function h(e,t){!function(e,...t){if(!(e instanceof Uint8Array))throw new Error("Expected Uint8Array");if(t.length>0&&!t.includes(e.length))throw new Error(`Expected Uint8Array of length ${t}, not of length=${e.length}`)}(e);const r=t.outputLen;if(e.length<r)throw new Error(`digestInto() expects output buffer of length at least ${r}`)} | ||
| /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */const l=e=>e instanceof Uint8Array,u=e=>new DataView(e.buffer,e.byteOffset,e.byteLength),f=(e,t)=>e<<32-t|e>>>t;if(!(68===new Uint8Array(new Uint32Array([287454020]).buffer)[0]))throw new Error("Non little-endian hardware is not supported");const d=Array.from({length:256},(e,t)=>t.toString(16).padStart(2,"0"));function p(e){if(!l(e))throw new Error("Uint8Array expected");let t="";for(let r=0;r<e.length;r++)t+=d[e[r]];return t}function w(e){if("string"==typeof e&&(e=function(e){if("string"!=typeof e)throw new Error("utf8ToBytes expected string, got "+typeof e);return new Uint8Array((new TextEncoder).encode(e))}(e)),!l(e))throw new Error("expected Uint8Array, got "+typeof e);return e}class y{clone(){return this._cloneInto()}}function m(e){const t=t=>e().update(w(t)).digest(),r=e();return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=()=>e(),t}class g extends y{constructor(e,t,r,n){super(),this.blockLen=e,this.outputLen=t,this.padOffset=r,this.isLE=n,this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.buffer=new Uint8Array(e),this.view=u(this.buffer)}update(e){c(this);const{view:t,buffer:r,blockLen:n}=this,o=(e=w(e)).length;for(let s=0;s<o;){const i=Math.min(n-this.pos,o-s);if(i===n){const t=u(e);for(;n<=o-s;s+=n)this.process(t,s);continue}r.set(e.subarray(s,s+i),this.pos),this.pos+=i,s+=i,this.pos===n&&(this.process(t,0),this.pos=0)}return this.length+=e.length,this.roundClean(),this}digestInto(e){c(this),h(e,this),this.finished=!0;const{buffer:t,view:r,blockLen:n,isLE:o}=this;let{pos:s}=this;t[s++]=128,this.buffer.subarray(s).fill(0),this.padOffset>n-s&&(this.process(r,0),s=0);for(let e=s;e<n;e++)t[e]=0;!function(e,t,r,n){if("function"==typeof e.setBigUint64)return e.setBigUint64(t,r,n);const o=BigInt(32),s=BigInt(4294967295),i=Number(r>>o&s),a=Number(r&s),c=n?4:0,h=n?0:4;e.setUint32(t+c,i,n),e.setUint32(t+h,a,n)}(r,n-8,BigInt(8*this.length),o),this.process(r,0);const i=u(e),a=this.outputLen;if(a%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const l=a/4,f=this.get();if(l>f.length)throw new Error("_sha2: outputLen bigger than state");for(let e=0;e<l;e++)i.setUint32(4*e,f[e],o)}digest(){const{buffer:e,outputLen:t}=this;this.digestInto(e);const r=e.slice(0,t);return this.destroy(),r}_cloneInto(e){e||(e=new this.constructor),e.set(...this.get());const{blockLen:t,buffer:r,length:n,finished:o,destroyed:s,pos:i}=this;return e.length=n,e.pos=i,e.finished=o,e.destroyed=s,n%t&&e.buffer.set(r),e}}const b=(e,t,r)=>e&t^~e&r,E=(e,t,r)=>e&t^e&r^t&r,v=new Uint32Array([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),x=new Uint32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),A=new Uint32Array(64);class k extends g{constructor(){super(64,32,8,!1),this.A=0|x[0],this.B=0|x[1],this.C=0|x[2],this.D=0|x[3],this.E=0|x[4],this.F=0|x[5],this.G=0|x[6],this.H=0|x[7]}get(){const{A:e,B:t,C:r,D:n,E:o,F:s,G:i,H:a}=this;return[e,t,r,n,o,s,i,a]}set(e,t,r,n,o,s,i,a){this.A=0|e,this.B=0|t,this.C=0|r,this.D=0|n,this.E=0|o,this.F=0|s,this.G=0|i,this.H=0|a}process(e,t){for(let r=0;r<16;r++,t+=4)A[r]=e.getUint32(t,!1);for(let e=16;e<64;e++){const t=A[e-15],r=A[e-2],n=f(t,7)^f(t,18)^t>>>3,o=f(r,17)^f(r,19)^r>>>10;A[e]=o+A[e-7]+n+A[e-16]|0}let{A:r,B:n,C:o,D:s,E:i,F:a,G:c,H:h}=this;for(let e=0;e<64;e++){const t=h+(f(i,6)^f(i,11)^f(i,25))+b(i,a,c)+v[e]+A[e]|0,l=(f(r,2)^f(r,13)^f(r,22))+E(r,n,o)|0;h=c,c=a,a=i,i=s+t|0,s=o,o=n,n=r,r=t+l|0}r=r+this.A|0,n=n+this.B|0,o=o+this.C|0,s=s+this.D|0,i=i+this.E|0,a=a+this.F|0,c=c+this.G|0,h=h+this.H|0,this.set(r,n,o,s,i,a,c,h)}roundClean(){A.fill(0)}destroy(){this.set(0,0,0,0,0,0,0,0),this.buffer.fill(0)}}const $=m(()=>new k);class U{constructor(e){if(this.paymentRequest=e.pr,!this.paymentRequest)throw new Error("Invalid payment request");const t=a(this.paymentRequest);if(!t)throw new Error("Failed to decode payment request");this.paymentHash=t.paymentHash,this.satoshi=t.satoshi,this.timestamp=t.timestamp,this.expiry=t.expiry,this.createdDate=new Date(1e3*this.timestamp),this.expiryDate=this.expiry?new Date(1e3*(this.timestamp+this.expiry)):void 0,this.description=t.description??null,this.verify=e.verify??null,this.preimage=e.preimage??null,this.successAction=e.successAction??null}async isPaid(){if(this.preimage)return this.validatePreimage(this.preimage);if(this.verify)return await this.verifyPayment();throw new Error("Could not verify payment")}validatePreimage(e){if(!e||!this.paymentHash)return!1;try{const t=p($(i(e)));return this.paymentHash===t}catch{return!1}}async verifyPayment(){try{if(!this.verify)throw new Error("LNURL verify not available");const e=await fetch(this.verify);if(!e.ok)throw new Error(`Verification request failed: ${e.status} ${e.statusText}`);const t=await e.json();return t.preimage&&(this.preimage=t.preimage),t.settled}catch(e){return console.error("Failed to check LNURL-verify",e),!1}}hasExpired(){const{expiryDate:e}=this;return!!e&&e.getTime()<Date.now()}}const _=e=>{if("keysend"!==e.tag)throw new Error("Invalid keysend params");if("OK"!==e.status)throw new Error("Keysend status not OK");if(!e.pubkey)throw new Error("Pubkey does not exist");const t=e.pubkey;let r,n;return e.customData&&e.customData[0]&&(r=e.customData[0].customKey,n=e.customData[0].customValue),{destination:t,customKey:r,customValue:n}};async function L({satoshi:e,comment:t,p:r,e:n,relays:o},s={}){const i=s.nostr||globalThis.nostr;if(!i)throw new Error("nostr option or window.nostr is not available");const a=[["relays",...o],["amount",e.toString()]];r&&a.push(["p",r]),n&&a.push(["e",n]);const c={pubkey:await i.getPublicKey(),created_at:Math.floor(Date.now()/1e3),kind:9734,tags:a,content:t??""};return c.id=D(c),await i.signEvent(c)}function I(e){if("string"!=typeof e.content)return!1;if("number"!=typeof e.created_at)return!1;if(!Array.isArray(e.tags))return!1;for(let t=0;t<e.tags.length;t++){const r=e.tags[t];if(!Array.isArray(r))return!1;for(let e=0;e<r.length;e++)if("object"==typeof r[e])return!1}return!0}function N(e){if(!I(e))throw new Error("can't serialize event with wrong or missing properties");return JSON.stringify([0,e.pubkey,e.created_at,e.kind,e.tags,e.content])}function D(e){return p($(N(e)))}function S(e,t){let r,n;return t&&e&&(r=e.names?.[t],n=r?e.relays?.[r]:void 0),[e,r,n]}const R=/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/,T=e=>!!e&&R.test(e),P=({amount:e,min:t,max:r})=>e>0&&e>=t&&e<=r,W=async e=>{if("payRequest"!==e.tag)throw new Error("Invalid pay service params");const t=(e.callback+"").trim();if(!T(t))throw new Error("Callback must be a valid url");const r=Math.ceil(Number(e.minSendable||0)),n=Math.floor(Number(e.maxSendable));if(!r||!n||r>n)throw new Error("Invalid pay service params");let o,s;try{o=JSON.parse(e.metadata+""),s=p($(e.metadata+""))}catch{o=[],s=p($("[]"))}let i="",a="",c="",h="";for(let e=0;e<o.length;e++){const[t,r]=o[e];switch(t){case"text/plain":c=r;break;case"text/identifier":h=r;break;case"text/email":i=r;break;case"image/png;base64":case"image/jpeg;base64":a="data:"+t+","+r}}const l=e.payerData;let u;try{u=new URL(t).hostname}catch{}return{callback:t,fixed:r===n,min:r,max:n,domain:u,metadata:o,metadataHash:s,identifier:h,email:i,description:c,image:a,payerData:l,commentAllowed:Number(e.commentAllowed)||0,rawData:e,allowsNostr:e.allowsNostr||!1}},B=async(e,t)=>{const{boost:r}=e;t||(t={});const n=t.webln||globalThis.webln;if(!n)throw new Error("WebLN not available");if(!n.keysend)throw new Error("Keysend not available in current WebLN provider");const o=e.amount||Math.floor(r.value_msat/1e3),s={destination:e.destination,amount:o,customRecords:{7629169:JSON.stringify(r)}};e.customKey&&e.customValue&&(s.customRecords[e.customKey]=e.customValue),await n.enable();return await n.keysend(s)},H=/^((?:[^<>()[\]\\.,;:\s@"]+(?:\.[^<>()[\]\\.,;:\s@"]+)*)|(?:".+"))@((?:\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(?:(?:[a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,C="https://api.getalby.com/lnurl";class j{constructor(e){this.storage=e||{}}getItem(e){return this.storage[e]}setItem(e,t){this.storage[e]=t}}const K=e=>{const t=e.replace("L402","").replace("LSAT","").trim(),r={},n=/(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g;let o;for(;null!==(o=n.exec(t));)r[o[1]]=o[3]||o[4]||o[5];return r},F=new j,O=async e=>{const t="https://getalby.com/api/rates/"+e.toLowerCase()+".json",r=await fetch(t);if(!r.ok)throw new Error(`Failed to fetch rate: ${r.status} ${r.statusText}`);return(await r.json()).rate_float/1e8},V=async({satoshi:e,currency:t})=>{const r=await O(t);return Number(e)*r};e.DEFAULT_PROXY=C,e.Invoice=U,e.LN_ADDRESS_REGEX=H,e.LightningAddress=class{constructor(e,t){this.address=e,this.options={proxy:C},this.options=Object.assign(this.options,t),this.parse(),this.webln=this.options.webln}parse(){const e=H.exec(this.address.toLowerCase());e&&(this.username=e[1],this.domain=e[2])}getWebLN(){return this.webln||globalThis.webln}async fetch(){return this.options.proxy?this.fetchWithProxy():this.fetchWithoutProxy()}async fetchWithProxy(){const e=await fetch(`${this.options.proxy}/lightning-address-details?${new URLSearchParams({ln:this.address}).toString()}`);if(!e.ok)throw new Error(`Failed to fetch lnurl info: ${e.status} ${e.statusText}`);const t=await e.json();await this.parseLnUrlPayResponse(t.lnurlp),this.parseKeysendResponse(t.keysend),this.parseNostrResponse(t.nostr)}async fetchWithoutProxy(){this.domain&&this.username&&await Promise.all([this.fetchLnurlData(),this.fetchKeysendData(),this.fetchNostrData()])}async fetchLnurlData(){const e=await fetch(this.lnurlpUrl());if(e.ok){const t=await e.json();await this.parseLnUrlPayResponse(t)}}async fetchKeysendData(){const e=await fetch(this.keysendUrl());if(e.ok){const t=await e.json();this.parseKeysendResponse(t)}}async fetchNostrData(){const e=await fetch(this.nostrUrl());if(e.ok){const t=await e.json();this.parseNostrResponse(t)}}lnurlpUrl(){return`https://${this.domain}/.well-known/lnurlp/${this.username}`}keysendUrl(){return`https://${this.domain}/.well-known/keysend/${this.username}`}nostrUrl(){return`https://${this.domain}/.well-known/nostr.json?name=${this.username}`}async generateInvoice(e){let t;if(this.options.proxy){const r=await fetch(`${this.options.proxy}/generate-invoice?${new URLSearchParams({ln:this.address,...e}).toString()}`);if(!r.ok)throw new Error(`Failed to generate invoice: ${r.status} ${r.statusText}`);t=(await r.json()).invoice}else{if(!this.lnurlpData)throw new Error("No lnurlpData available. Please call fetch() first.");if(!this.lnurlpData.callback||!T(this.lnurlpData.callback))throw new Error("Valid callback does not exist in lnurlpData");const r=new URL(this.lnurlpData.callback);r.search=new URLSearchParams(e).toString();const n=await fetch(r.toString());if(!n.ok)throw new Error(`Failed to generate invoice: ${n.status} ${n.statusText}`);t=await n.json()}const r=t&&t.pr&&t.pr.toString();if(!r)throw new Error("Invalid pay service invoice");const n={pr:r};if(t&&t.verify&&(n.verify=t.verify.toString()),t&&t.successAction&&"object"==typeof t.successAction){const{tag:e,message:r,description:o,url:s}=t.successAction;"message"===e?n.successAction={tag:e,message:r}:"url"===e&&(n.successAction={tag:e,description:o,url:s})}return new U(n)}async requestInvoice(e){if(!this.lnurlpData)throw new Error("No lnurlpData available. Please call fetch() first.");const t=1e3*e.satoshi,{commentAllowed:r,min:n,max:o}=this.lnurlpData;if(!P({amount:t,min:n,max:o}))throw new Error("Invalid amount");if(e.comment&&r&&r>0&&e.comment.length>r)throw new Error(`The comment length must be ${r} characters or fewer`);const s={amount:t.toString()};return e.comment&&(s.comment=e.comment),e.payerdata&&(s.payerdata=JSON.stringify(e.payerdata)),this.generateInvoice(s)}async boost(e,t=0){if(!this.keysendData)throw new Error("No keysendData available. Please call fetch() first.");const{destination:r,customKey:n,customValue:o}=this.keysendData,s=this.getWebLN();if(!s)throw new Error("WebLN not available");return B({destination:r,customKey:n,customValue:o,amount:t,boost:e},{webln:s})}async zapInvoice({satoshi:e,comment:t,relays:r,e:n},o={}){if(!this.lnurlpData)throw new Error("No lnurlpData available. Please call fetch() first.");if(!this.nostrPubkey)throw new Error("Nostr Pubkey is missing");const s=this.nostrPubkey,i=1e3*e,{allowsNostr:a,min:c,max:h}=this.lnurlpData;if(!P({amount:i,min:c,max:h}))throw new Error("Invalid amount");if(!a)throw new Error("Your provider does not support zaps");const l=await L({satoshi:i,comment:t,p:s,e:n,relays:r},o),u={amount:i.toString(),nostr:JSON.stringify(l)};return await this.generateInvoice(u)}async zap(e,t={}){const r=this.zapInvoice(e,t),n=this.getWebLN();if(!n)throw new Error("WebLN not available");await n.enable();return n.sendPayment((await r).paymentRequest)}async parseLnUrlPayResponse(e){e&&(this.lnurlpData=await W(e))}parseKeysendResponse(e){e&&(this.keysendData=_(e))}parseNostrResponse(e){e&&([this.nostrData,this.nostrPubkey,this.nostrRelays]=S(e,this.username))}},e.MemoryStorage=j,e.NoStorage=class{constructor(e){}getItem(e){return null}setItem(e,t){}},e.decodeInvoice=a,e.fetchWithL402=async(e,t,r)=>{r||(r={});const n=r.headerKey||"L402",o=r.wallet;if(!o)throw new Error("wallet is missing");const s=r.store||F;t||(t={}),t.cache="no-store",t.mode="cors",t.headers||(t.headers={});const i=s.getItem(e);if(i){const r=JSON.parse(i);return t.headers.Authorization=`${n} ${r.token}:${r.preimage}`,await fetch(e,t)}t.headers["Accept-Authenticate"]=n;const a=await fetch(e,t),c=a.headers.get("www-authenticate");if(!c)return a;const h=K(c),l=h.token||h.macaroon,u=h.invoice,f=await o.sendPayment(u);return s.setItem(e,JSON.stringify({token:l,preimage:f.preimage})),t.headers.Authorization=`${n} ${l}:${f.preimage}`,await fetch(e,t)},e.fromHexString=i,e.generateZapEvent=L,e.getEventHash=D,e.getFiatBtcRate=O,e.getFiatCurrencies=async()=>{const e=await fetch("https://getalby.com/api/rates");if(!e.ok)throw new Error(`Failed to fetch currencies: ${e.status} ${e.statusText}`);const t=await e.json();return Object.entries(t).filter(([e])=>"BTC"!==e.toUpperCase()).map(([e,t])=>({code:e.toUpperCase(),name:t.name,priority:t.priority,symbol:t.symbol})).sort((e,t)=>e.name.localeCompare(t.name)).sort((e,t)=>e.priority-t.priority)},e.getFiatValue=V,e.getFormattedFiatValue=async({satoshi:e,currency:t,locale:r})=>{r||(r="en");return(await V({satoshi:e,currency:t})).toLocaleString(r,{style:"currency",currency:t})},e.getSatoshiValue=async({amount:e,currency:t})=>{const r=await O(t);return Math.floor(Number(e)/r)},e.isUrl=T,e.isValidAmount=P,e.makeAuthenticateHeader=e=>`${e.key||"L402"} macaroon="${e.macaroon}", invoice="${e.invoice}"`,e.parseKeysendResponse=_,e.parseL402=K,e.parseLnUrlPayResponse=W,e.parseNostrResponse=S,e.sendBoostagram=B,e.serializeEvent=N,e.validateEvent=I}); | ||
| Object.defineProperty(e,"__esModule",{value:!0}),e.bytes=e.stringToBytes=e.str=e.bytesToString=e.hex=e.utf8=e.bech32m=e.bech32=e.base58check=e.base58xmr=e.base58xrp=e.base58flickr=e.base58=e.base64url=e.base64=e.base32crockford=e.base32hex=e.base32=e.base16=e.utils=e.assertNumber=void 0,e.assertNumber=t;const c=(e,t)=>t?c(t,e%t):e,h=(e,t)=>e+(t-c(e,t));function l(e,r,n,o){if(!Array.isArray(e))throw new Error("convertRadix2: data should be array");if(r<=0||r>32)throw new Error(`convertRadix2: wrong from=${r}`);if(n<=0||n>32)throw new Error(`convertRadix2: wrong to=${n}`);if(h(r,n)>32)throw new Error(`convertRadix2: carry overflow from=${r} to=${n} carryBits=${h(r,n)}`);let s=0,i=0;const a=2**n-1,c=[];for(const o of e){if(t(o),o>=2**r)throw new Error(`convertRadix2: invalid data word=${o} from=${r}`);if(s=s<<r|o,i+r>32)throw new Error(`convertRadix2: carry overflow pos=${i} from=${r}`);for(i+=r;i>=n;i-=n)c.push((s>>i-n&a)>>>0);s&=2**i-1}if(s=s<<n-i&a,!o&&i>=r)throw new Error("Excess padding");if(!o&&s)throw new Error(`Non-zero padding: ${s}`);return o&&i>0&&c.push(s>>>0),c}function u(e){return t(e),{encode:t=>{if(!(t instanceof Uint8Array))throw new Error("radix.encode input should be Uint8Array");return a(Array.from(t),256,e)},decode:t=>{if(!Array.isArray(t)||t.length&&"number"!=typeof t[0])throw new Error("radix.decode input should be array of strings");return Uint8Array.from(a(t,e,256))}}}function d(e,r=!1){if(t(e),e<=0||e>32)throw new Error("radix2: bits should be in (0..32]");if(h(8,e)>32||h(e,8)>32)throw new Error("radix2: carry overflow");return{encode:t=>{if(!(t instanceof Uint8Array))throw new Error("radix2.encode input should be Uint8Array");return l(Array.from(t),8,e,!r)},decode:t=>{if(!Array.isArray(t)||t.length&&"number"!=typeof t[0])throw new Error("radix2.decode input should be array of strings");return Uint8Array.from(l(t,e,8,r))}}}function f(e){if("function"!=typeof e)throw new Error("unsafeWrapper fn should be function");return function(...t){try{return e.apply(null,t)}catch(e){}}}function p(e,r){if(t(e),"function"!=typeof r)throw new Error("checksum fn should be function");return{encode(t){if(!(t instanceof Uint8Array))throw new Error("checksum.encode: input should be Uint8Array");const n=r(t).slice(0,e),o=new Uint8Array(t.length+e);return o.set(t),o.set(n,t.length),o},decode(t){if(!(t instanceof Uint8Array))throw new Error("checksum.decode: input should be Uint8Array");const n=t.slice(0,-e),o=r(n).slice(0,e),s=t.slice(-e);for(let t=0;t<e;t++)if(o[t]!==s[t])throw new Error("Invalid checksum");return n}}}e.utils={alphabet:n,chain:r,checksum:p,radix:u,radix2:d,join:o,padding:s},e.base16=r(d(4),n("0123456789ABCDEF"),o("")),e.base32=r(d(5),n("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"),s(5),o("")),e.base32hex=r(d(5),n("0123456789ABCDEFGHIJKLMNOPQRSTUV"),s(5),o("")),e.base32crockford=r(d(5),n("0123456789ABCDEFGHJKMNPQRSTVWXYZ"),o(""),i(e=>e.toUpperCase().replace(/O/g,"0").replace(/[IL]/g,"1"))),e.base64=r(d(6),n("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),s(6),o("")),e.base64url=r(d(6),n("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"),s(6),o(""));const w=e=>r(u(58),n(e),o(""));e.base58=w("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"),e.base58flickr=w("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"),e.base58xrp=w("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");const y=[0,2,3,5,6,7,9,10,11];e.base58xmr={encode(t){let r="";for(let n=0;n<t.length;n+=8){const o=t.subarray(n,n+8);r+=e.base58.encode(o).padStart(y[o.length],"1")}return r},decode(t){let r=[];for(let n=0;n<t.length;n+=11){const o=t.slice(n,n+11),s=y.indexOf(o.length),i=e.base58.decode(o);for(let e=0;e<i.length-s;e++)if(0!==i[e])throw new Error("base58xmr: wrong padding");r=r.concat(Array.from(i.slice(i.length-s)))}return Uint8Array.from(r)}},e.base58check=t=>r(p(4,e=>t(t(e))),e.base58);const m=r(n("qpzry9x8gf2tvdw0s3jn54khce6mua7l"),o("")),g=[996825010,642813549,513874426,1027748829,705979059];function b(e){const t=e>>25;let r=(33554431&e)<<5;for(let e=0;e<g.length;e++)1==(t>>e&1)&&(r^=g[e]);return r}function E(e,t,r=1){const n=e.length;let o=1;for(let t=0;t<n;t++){const r=e.charCodeAt(t);if(r<33||r>126)throw new Error(`Invalid prefix (${e})`);o=b(o)^r>>5}o=b(o);for(let t=0;t<n;t++)o=b(o)^31&e.charCodeAt(t);for(let e of t)o=b(o)^e;for(let e=0;e<6;e++)o=b(o);return o^=r,m.encode(l([o%2**30],30,5,!1))}function v(e){const t="bech32"===e?1:734539939,r=d(5),n=r.decode,o=r.encode,s=f(n);function i(e,r=90){if("string"!=typeof e)throw new Error("bech32.decode input should be string, not "+typeof e);if(e.length<8||!1!==r&&e.length>r)throw new TypeError(`Wrong string length: ${e.length} (${e}). Expected (8..${r})`);const n=e.toLowerCase();if(e!==n&&e!==e.toUpperCase())throw new Error("String must be lowercase or uppercase");const o=(e=n).lastIndexOf("1");if(0===o||-1===o)throw new Error('Letter "1" must be present between prefix and data only');const s=e.slice(0,o),i=e.slice(o+1);if(i.length<6)throw new Error("Data must be at least 6 characters long");const a=m.decode(i).slice(0,-6),c=E(s,a,t);if(!i.endsWith(c))throw new Error(`Invalid checksum in ${e}: expected "${c}"`);return{prefix:s,words:a}}return{encode:function(e,r,n=90){if("string"!=typeof e)throw new Error("bech32.encode prefix should be string, not "+typeof e);if(!Array.isArray(r)||r.length&&"number"!=typeof r[0])throw new Error("bech32.encode words should be array of numbers, not "+typeof r);const o=e.length+7+r.length;if(!1!==n&&o>n)throw new TypeError(`Length ${o} exceeds limit ${n}`);return`${e=e.toLowerCase()}1${m.encode(r)}${E(e,r,t)}`},decode:i,decodeToBytes:function(e){const{prefix:t,words:r}=i(e,!1);return{prefix:t,words:r,bytes:n(r)}},decodeUnsafe:f(i),fromWords:n,fromWordsUnsafe:s,toWords:o}}e.bech32=v("bech32"),e.bech32m=v("bech32m"),e.utf8={encode:e=>(new TextDecoder).decode(e),decode:e=>(new TextEncoder).encode(e)},e.hex=r(d(4),n("0123456789abcdef"),o(""),i(e=>{if("string"!=typeof e||e.length%2)throw new TypeError(`hex.decode: expected string, got ${typeof e} with length ${e.length}`);return e.toLowerCase()}));const x={utf8:e.utf8,hex:e.hex,base16:e.base16,base32:e.base32,base64:e.base64,base64url:e.base64url,base58:e.base58,base58xmr:e.base58xmr},A=`Invalid encoding type. Available types: ${Object.keys(x).join(", ")}`;e.bytesToString=(e,t)=>{if("string"!=typeof e||!x.hasOwnProperty(e))throw new TypeError(A);if(!(t instanceof Uint8Array))throw new TypeError("bytesToString() expects Uint8Array");return x[e].encode(t)},e.str=e.bytesToString,e.stringToBytes=(e,t)=>{if(!x.hasOwnProperty(e))throw new TypeError(A);if("string"!=typeof t)throw new TypeError("stringToBytes() expects string");return x[e].decode(t)},e.bytes=e.stringToBytes}(o)),o),a={bech32:"bc",pubKeyHash:0,scriptHash:5,validWitnessVersions:[0]},c={bech32:"tb",pubKeyHash:111,scriptHash:196,validWitnessVersions:[0]},h={bech32:"tbs",pubKeyHash:111,scriptHash:196,validWitnessVersions:[0]},l={bech32:"bcrt",pubKeyHash:111,scriptHash:196,validWitnessVersions:[0]},u={bech32:"sb",pubKeyHash:63,scriptHash:123,validWitnessVersions:[0]},d=["option_data_loss_protect","initial_routing_sync","option_upfront_shutdown_script","gossip_queries","var_onion_optin","gossip_queries_ex","option_static_remotekey","payment_secret","basic_mpp","option_support_large_channel"],f={m:BigInt(1e3),u:BigInt(1e6),n:BigInt(1e9),p:BigInt(1e12)},p=BigInt("2100000000000000000"),w=BigInt(1e11),y={payment_hash:1,payment_secret:16,description:13,payee:19,description_hash:23,expiry:6,min_final_cltv_expiry:24,fallback_address:9,route_hint:3,feature_bits:5,metadata:27},m={};for(let e=0,t=Object.keys(y);e<t.length;e++){const r=t[e],n=y[t[e]].toString();m[n]=r}const g={1:t=>s.encode(e.fromWordsUnsafe(t)),16:t=>s.encode(e.fromWordsUnsafe(t)),13:t=>i.encode(e.fromWordsUnsafe(t)),19:t=>s.encode(e.fromWordsUnsafe(t)),23:t=>s.encode(e.fromWordsUnsafe(t)),27:t=>s.encode(e.fromWordsUnsafe(t)),6:E,24:E,3:function(t){const r=[];let n,o,i,a,c,h=e.fromWordsUnsafe(t);for(;h.length>0;)n=s.encode(h.slice(0,33)),o=s.encode(h.slice(33,41)),i=parseInt(s.encode(h.slice(41,45)),16),a=parseInt(s.encode(h.slice(45,49)),16),c=parseInt(s.encode(h.slice(49,51)),16),h=h.slice(51),r.push({pubkey:n,short_channel_id:o,fee_base_msat:i,fee_proportional_millionths:a,cltv_expiry_delta:c});return r},5:function(e){const t=e.slice().reverse().map(e=>[!!(1&e),!!(2&e),!!(4&e),!!(8&e),!!(16&e)]).reduce((e,t)=>e.concat(t),[]);for(;t.length<2*d.length;)t.push(!1);const r={};d.forEach((e,n)=>{let o;o=t[2*n]?"required":t[2*n+1]?"supported":"unsupported",r[e]=o});const n=t.slice(2*d.length);return r.extra_bits={start_bit:2*d.length,bits:n,has_required:n.reduce((e,t,r)=>r%2!=0?e||!1:e||t,!1)},r}};function b(t){return r=>({tagCode:parseInt(t),words:e.encode("unknown",r,Number.MAX_SAFE_INTEGER)})}function E(e){return e.reverse().reduce((e,t,r)=>e+t*Math.pow(32,r),0)}function v(e,t){let r,n;if(e.slice(-1).match(/^[munp]$/))r=e.slice(-1),n=e.slice(0,-1);else{if(e.slice(-1).match(/^[^munp0-9]$/))throw new Error("Not a valid multiplier for the amount");n=e}if(!n.match(/^\d+$/))throw new Error("Not a valid human readable amount");const o=BigInt(n),s=r?o*w/f[r]:o*w;if("p"===r&&o%BigInt(10)!==BigInt(0)||s>p)throw new Error("Amount is outside of valid range");return t?s.toString():s}return r={decode:function(t,r){if("string"!=typeof t)throw new Error("Lightning Payment Request must be string");if("ln"!==t.slice(0,2).toLowerCase())throw new Error("Not a proper lightning payment request");const n=[],o=e.decode(t,Number.MAX_SAFE_INTEGER);t=t.toLowerCase();const i=o.prefix;let d=o.words,f=t.slice(i.length+1),p=d.slice(-104);d=d.slice(0,-104);let w=i.match(/^ln(\S+?)(\d*)([a-zA-Z]?)$/);if(w&&!w[2]&&(w=i.match(/^ln(\S+)$/)),!w)throw new Error("Not a proper lightning payment request");n.push({name:"lightning_network",letters:"ln"});const x=w[1];let A;if(r){if(void 0===r.bech32||void 0===r.pubKeyHash||void 0===r.scriptHash||!Array.isArray(r.validWitnessVersions))throw new Error("Invalid network");A=r}else switch(x){case a.bech32:A=a;break;case c.bech32:A=c;break;case h.bech32:A=h;break;case l.bech32:A=l;break;case u.bech32:A=u}if(!A||A.bech32!==x)throw new Error("Unknown coin bech32 prefix");n.push({name:"coin_network",letters:x,value:A});const k=w[2];let U;if(k){U=v(k+w[3],!0),n.push({name:"amount",letters:w[2]+w[3],value:U})}else U=null;n.push({name:"separator",letters:"1"});const $=E(d.slice(0,7));let L,R,_,I;for(d=d.slice(7),n.push({name:"timestamp",letters:f.slice(0,7),value:$}),f=f.slice(7);d.length>0;){const e=d[0].toString();L=m[e]||"unknown_tag",R=g[e]||b(e),d=d.slice(1),_=E(d.slice(0,2)),d=d.slice(2),I=d.slice(0,_),d=d.slice(_),n.push({name:L,tag:f[0],letters:f.slice(0,3+_),value:R(I)}),f=f.slice(3+_)}n.push({name:"signature",letters:f.slice(0,104),value:s.encode(e.fromWordsUnsafe(p))}),f=f.slice(104),n.push({name:"checksum",letters:f});let N={paymentRequest:t,sections:n,get expiry(){let e=n.find(e=>"expiry"===e.name);if(e)return D("timestamp")+e.value},get route_hints(){return n.filter(e=>"route_hint"===e.name).map(e=>e.value)}};for(let e in y)"route_hint"!==e&&Object.defineProperty(N,e,{get:()=>D(e)});return N;function D(e){let t=n.find(t=>t.name===e);return t?t.value:void 0}},hrpToMillisat:v}}();const i=e=>Uint8Array.from(e.match(/.{1,2}/g).map(e=>parseInt(e,16))),a=e=>{if(!e)return null;try{const t=s.decode(e);if(!t||!t.sections)return null;const r=t.sections.find(e=>"payment_hash"===e.name);if("payment_hash"!==r?.name||!r.value)return null;const n=r.value;let o=0,i=0,a="0";const c=t.sections.find(e=>"amount"===e.name);"amount"===c?.name&&c.value&&(a=c.value,i=parseInt(c.value),o=parseInt(c.value)/1e3);const h=t.sections.find(e=>"timestamp"===e.name);if("timestamp"!==h?.name||!h.value)return null;const l=h.value;let u;const d=t.sections.find(e=>"expiry"===e.name);"expiry"===d?.name&&(u=d.value);const f=t.sections.find(e=>"description"===e.name);return{paymentHash:n,satoshi:o,millisatoshi:i,amountRaw:a,timestamp:l,expiry:u,description:"description"===f?.name?f?.value:void 0}}catch{return null}};function c(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")}function h(e,t){!function(e,...t){if(!(e instanceof Uint8Array))throw new Error("Expected Uint8Array");if(t.length>0&&!t.includes(e.length))throw new Error(`Expected Uint8Array of length ${t}, not of length=${e.length}`)}(e);const r=t.outputLen;if(e.length<r)throw new Error(`digestInto() expects output buffer of length at least ${r}`)} | ||
| /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */const l=e=>e instanceof Uint8Array,u=e=>new DataView(e.buffer,e.byteOffset,e.byteLength),d=(e,t)=>e<<32-t|e>>>t;if(!(68===new Uint8Array(new Uint32Array([287454020]).buffer)[0]))throw new Error("Non little-endian hardware is not supported");const f=Array.from({length:256},(e,t)=>t.toString(16).padStart(2,"0"));function p(e){if(!l(e))throw new Error("Uint8Array expected");let t="";for(let r=0;r<e.length;r++)t+=f[e[r]];return t}function w(e){if("string"==typeof e&&(e=function(e){if("string"!=typeof e)throw new Error("utf8ToBytes expected string, got "+typeof e);return new Uint8Array((new TextEncoder).encode(e))}(e)),!l(e))throw new Error("expected Uint8Array, got "+typeof e);return e}class y{clone(){return this._cloneInto()}}function m(e){const t=t=>e().update(w(t)).digest(),r=e();return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=()=>e(),t}class g extends y{constructor(e,t,r,n){super(),this.blockLen=e,this.outputLen=t,this.padOffset=r,this.isLE=n,this.finished=!1,this.length=0,this.pos=0,this.destroyed=!1,this.buffer=new Uint8Array(e),this.view=u(this.buffer)}update(e){c(this);const{view:t,buffer:r,blockLen:n}=this,o=(e=w(e)).length;for(let s=0;s<o;){const i=Math.min(n-this.pos,o-s);if(i===n){const t=u(e);for(;n<=o-s;s+=n)this.process(t,s);continue}r.set(e.subarray(s,s+i),this.pos),this.pos+=i,s+=i,this.pos===n&&(this.process(t,0),this.pos=0)}return this.length+=e.length,this.roundClean(),this}digestInto(e){c(this),h(e,this),this.finished=!0;const{buffer:t,view:r,blockLen:n,isLE:o}=this;let{pos:s}=this;t[s++]=128,this.buffer.subarray(s).fill(0),this.padOffset>n-s&&(this.process(r,0),s=0);for(let e=s;e<n;e++)t[e]=0;!function(e,t,r,n){if("function"==typeof e.setBigUint64)return e.setBigUint64(t,r,n);const o=BigInt(32),s=BigInt(4294967295),i=Number(r>>o&s),a=Number(r&s),c=n?4:0,h=n?0:4;e.setUint32(t+c,i,n),e.setUint32(t+h,a,n)}(r,n-8,BigInt(8*this.length),o),this.process(r,0);const i=u(e),a=this.outputLen;if(a%4)throw new Error("_sha2: outputLen should be aligned to 32bit");const l=a/4,d=this.get();if(l>d.length)throw new Error("_sha2: outputLen bigger than state");for(let e=0;e<l;e++)i.setUint32(4*e,d[e],o)}digest(){const{buffer:e,outputLen:t}=this;this.digestInto(e);const r=e.slice(0,t);return this.destroy(),r}_cloneInto(e){e||(e=new this.constructor),e.set(...this.get());const{blockLen:t,buffer:r,length:n,finished:o,destroyed:s,pos:i}=this;return e.length=n,e.pos=i,e.finished=o,e.destroyed=s,n%t&&e.buffer.set(r),e}}const b=(e,t,r)=>e&t^~e&r,E=(e,t,r)=>e&t^e&r^t&r,v=new Uint32Array([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),x=new Uint32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),A=new Uint32Array(64);class k extends g{constructor(){super(64,32,8,!1),this.A=0|x[0],this.B=0|x[1],this.C=0|x[2],this.D=0|x[3],this.E=0|x[4],this.F=0|x[5],this.G=0|x[6],this.H=0|x[7]}get(){const{A:e,B:t,C:r,D:n,E:o,F:s,G:i,H:a}=this;return[e,t,r,n,o,s,i,a]}set(e,t,r,n,o,s,i,a){this.A=0|e,this.B=0|t,this.C=0|r,this.D=0|n,this.E=0|o,this.F=0|s,this.G=0|i,this.H=0|a}process(e,t){for(let r=0;r<16;r++,t+=4)A[r]=e.getUint32(t,!1);for(let e=16;e<64;e++){const t=A[e-15],r=A[e-2],n=d(t,7)^d(t,18)^t>>>3,o=d(r,17)^d(r,19)^r>>>10;A[e]=o+A[e-7]+n+A[e-16]|0}let{A:r,B:n,C:o,D:s,E:i,F:a,G:c,H:h}=this;for(let e=0;e<64;e++){const t=h+(d(i,6)^d(i,11)^d(i,25))+b(i,a,c)+v[e]+A[e]|0,l=(d(r,2)^d(r,13)^d(r,22))+E(r,n,o)|0;h=c,c=a,a=i,i=s+t|0,s=o,o=n,n=r,r=t+l|0}r=r+this.A|0,n=n+this.B|0,o=o+this.C|0,s=s+this.D|0,i=i+this.E|0,a=a+this.F|0,c=c+this.G|0,h=h+this.H|0,this.set(r,n,o,s,i,a,c,h)}roundClean(){A.fill(0)}destroy(){this.set(0,0,0,0,0,0,0,0),this.buffer.fill(0)}}const U=m(()=>new k);class ${constructor(e){if(this.paymentRequest=e.pr,!this.paymentRequest)throw new Error("Invalid payment request");const t=a(this.paymentRequest);if(!t)throw new Error("Failed to decode payment request");this.paymentHash=t.paymentHash,this.satoshi=t.satoshi,this.millisatoshi=t.millisatoshi,this.amountRaw=t.amountRaw,this.timestamp=t.timestamp,this.expiry=t.expiry,this.createdDate=new Date(1e3*this.timestamp),this.expiryDate=this.expiry?new Date(1e3*(this.timestamp+this.expiry)):void 0,this.description=t.description??null,this.verify=e.verify??null,this.preimage=e.preimage??null,this.successAction=e.successAction??null}async isPaid(){if(this.preimage)return this.validatePreimage(this.preimage);if(this.verify)return await this.verifyPayment();throw new Error("Could not verify payment")}validatePreimage(e){if(!e||!this.paymentHash)return!1;try{const t=p(U(i(e)));return this.paymentHash===t}catch{return!1}}async verifyPayment(){try{if(!this.verify)throw new Error("LNURL verify not available");const e=await fetch(this.verify);if(!e.ok)throw new Error(`Verification request failed: ${e.status} ${e.statusText}`);const t=await e.json();return t.preimage&&(this.preimage=t.preimage),t.settled}catch(e){return console.error("Failed to check LNURL-verify",e),!1}}hasExpired(){const{expiryDate:e}=this;return!!e&&e.getTime()<Date.now()}}const L=e=>{if("keysend"!==e.tag)throw new Error("Invalid keysend params");if("OK"!==e.status)throw new Error("Keysend status not OK");if(!e.pubkey)throw new Error("Pubkey does not exist");const t=e.pubkey;let r,n;return e.customData&&e.customData[0]&&(r=e.customData[0].customKey,n=e.customData[0].customValue),{destination:t,customKey:r,customValue:n}};async function R({satoshi:e,comment:t,p:r,e:n,relays:o},s={}){const i=s.nostr||globalThis.nostr;if(!i)throw new Error("nostr option or window.nostr is not available");const a=[["relays",...o],["amount",e.toString()]];r&&a.push(["p",r]),n&&a.push(["e",n]);const c={pubkey:await i.getPublicKey(),created_at:Math.floor(Date.now()/1e3),kind:9734,tags:a,content:t??""};return c.id=N(c),await i.signEvent(c)}function _(e){if("string"!=typeof e.content)return!1;if("number"!=typeof e.created_at)return!1;if(!Array.isArray(e.tags))return!1;for(let t=0;t<e.tags.length;t++){const r=e.tags[t];if(!Array.isArray(r))return!1;for(let e=0;e<r.length;e++)if("object"==typeof r[e])return!1}return!0}function I(e){if(!_(e))throw new Error("can't serialize event with wrong or missing properties");return JSON.stringify([0,e.pubkey,e.created_at,e.kind,e.tags,e.content])}function N(e){return p(U(I(e)))}function D(e,t){let r,n;return t&&e&&(r=e.names?.[t],n=r?e.relays?.[r]:void 0),[e,r,n]}const S=/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/,W=e=>!!e&&S.test(e),T=({amount:e,min:t,max:r})=>e>0&&e>=t&&e<=r,P=async e=>{if("payRequest"!==e.tag)throw new Error("Invalid pay service params");const t=(e.callback+"").trim();if(!W(t))throw new Error("Callback must be a valid url");const r=Math.ceil(Number(e.minSendable||0)),n=Math.floor(Number(e.maxSendable));if(!r||!n||r>n)throw new Error("Invalid pay service params");let o,s;try{o=JSON.parse(e.metadata+""),s=p(U(e.metadata+""))}catch{o=[],s=p(U("[]"))}let i="",a="",c="",h="";for(let e=0;e<o.length;e++){const[t,r]=o[e];switch(t){case"text/plain":c=r;break;case"text/identifier":h=r;break;case"text/email":i=r;break;case"image/png;base64":case"image/jpeg;base64":a="data:"+t+","+r}}const l=e.payerData;let u;try{u=new URL(t).hostname}catch{}return{callback:t,fixed:r===n,min:r,max:n,domain:u,metadata:o,metadataHash:s,identifier:h,email:i,description:c,image:a,payerData:l,commentAllowed:Number(e.commentAllowed)||0,rawData:e,allowsNostr:e.allowsNostr||!1}},C=async(e,t)=>{const{boost:r}=e;t||(t={});const n=t.webln||globalThis.webln;if(!n)throw new Error("WebLN not available");if(!n.keysend)throw new Error("Keysend not available in current WebLN provider");const o=e.amount||Math.floor(r.value_msat/1e3),s={destination:e.destination,amount:o,customRecords:{7629169:JSON.stringify(r)}};e.customKey&&e.customValue&&(s.customRecords[e.customKey]=e.customValue),await n.enable();return await n.keysend(s)},B=/^((?:[^<>()[\]\\.,;:\s@"]+(?:\.[^<>()[\]\\.,;:\s@"]+)*)|(?:".+"))@((?:\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(?:(?:[a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,H="https://api.getalby.com/lnurl";function j(e,t){return{payInvoice:async r=>{const n=new $({pr:r.invoice});if(n.satoshi>t)throw new Error(`Invoice amount (${n.satoshi} sats) exceeds maxAmount (${t} sats)`);return e.payInvoice(r)}}}const O=async(e,t,r,n,o)=>{const s=(e=>{const t=e.replace("L402","").replace("LSAT","").trim(),r={},n=/(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g;let o;for(;null!==(o=n.exec(t));)r[o[1]]=o[3]||o[4]||o[5];return r})(e),i=s.token||s.macaroon,a=s.invoice;if(!i)throw new Error("L402: missing token/macaroon in WWW-Authenticate header");if(!a)throw new Error("L402: missing invoice in WWW-Authenticate header");const c=await o.payInvoice({invoice:a});return n.set("Authorization",`L402 ${i}:${c.preimage}`),fetch(t,r)},q=async(e,t,r,n,o)=>{let s;try{s=JSON.parse(decodeURIComponent(escape(atob(e))))}catch(e){throw new Error("x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)")}if(!Array.isArray(s.accepts)||0===s.accepts.length)throw new Error("x402: PAYMENT-REQUIRED header contains no payment options");const i=s.accepts.find(e=>"lightning"===e.extra?.paymentMethod);if(!i)throw new Error("x402: unsupported x402 network, only Bitcoin lightning network is supported.");if(!i.extra?.invoice)throw new Error("x402: payment requirements missing lightning invoice");const a=new $({pr:i.extra.invoice});if(a.amountRaw!=i.amount)throw new Error(`Invalid invoice amount: ${a.amountRaw}. expected ${i.amount}`);return await o.payInvoice({invoice:a.paymentRequest}),n.set("payment-signature",((e,t,r,n)=>{const o=JSON.stringify({x402Version:2,scheme:e,network:t,payload:{invoice:r},accepted:n});return btoa(unescape(encodeURIComponent(o)))})(i.scheme,i.network,a.paymentRequest,i)),fetch(t,r)},K=e=>{if(null===e||"object"!=typeof e)return JSON.stringify(e);if(Array.isArray(e))return"["+e.map(K).join(",")+"]";return"{"+Object.keys(e).sort().map(t=>JSON.stringify(t)+":"+K(e[t])).join(",")+"}"},F=(e,t,r)=>{const n={id:e.id,intent:e.intent,method:e.method,realm:e.realm,request:e.request};e.expires&&(n.expires=e.expires);return(e=>{const t=(new TextEncoder).encode(e);let r="";for(let e=0;e<t.length;e++)r+=String.fromCharCode(t[e]);return btoa(r).replace(/\+/g,"-").replace(/\//g,"_").replace(/=/g,"")})(K({challenge:n,payload:{preimage:t}}))},V=async(e,t,r,n,o)=>{const s=(e=>{if(!e.trimStart().toLowerCase().startsWith("payment"))return null;const t=e.slice(e.toLowerCase().indexOf("payment")+7).trim(),r={},n=/(\w+)=("([^"]*)"|'([^']*)'|([^,\s]*))/g;let o;for(;null!==(o=n.exec(t));)r[o[1]]=o[3]??o[4]??o[5]??"";return"lightning"===r.method&&"charge"===r.intent&&r.id&&r.realm&&r.request?{id:r.id,realm:r.realm,method:r.method,intent:r.intent,request:r.request,...r.expires?{expires:r.expires}:{}}:null})(e);if(!s)throw new Error("mpp: invalid or unsupported WWW-Authenticate challenge (expected Payment method=lightning intent=charge)");let i;try{i=JSON.parse((e=>{const t=e.replace(/-/g,"+").replace(/_/g,"/"),r=atob(t),n=new Uint8Array(r.length);for(let e=0;e<r.length;e++)n[e]=r.charCodeAt(e);return new TextDecoder("utf-8").decode(n)})(s.request))}catch(e){throw new Error("mpp: invalid request auth-param (not valid base64url-encoded JSON)")}const a=i.methodDetails?.invoice;if(!a)throw new Error("mpp: missing invoice in charge request");const c=await o.payInvoice({invoice:a}),h=F(s,c.preimage);return n.set("Authorization",`Payment ${h}`),fetch(t,r)},M=async e=>{const t="https://getalby.com/api/rates/"+e.toLowerCase()+".json",r=await fetch(t);if(!r.ok)throw new Error(`Failed to fetch rate: ${r.status} ${r.statusText}`);return(await r.json()).rate_float/1e8},z=async({satoshi:e,currency:t})=>{const r=await M(t);return Number(e)*r};e.DEFAULT_PROXY=H,e.Invoice=$,e.LN_ADDRESS_REGEX=B,e.LightningAddress=class{constructor(e,t){this.address=e,this.options={proxy:H},this.options=Object.assign(this.options,t),this.parse(),this.webln=this.options.webln}parse(){const e=B.exec(this.address.toLowerCase());e&&(this.username=e[1],this.domain=e[2])}getWebLN(){return this.webln||globalThis.webln}async fetch(){return this.options.proxy?this.fetchWithProxy():this.fetchWithoutProxy()}async fetchWithProxy(){const e=await fetch(`${this.options.proxy}/lightning-address-details?${new URLSearchParams({ln:this.address}).toString()}`);if(!e.ok)throw new Error(`Failed to fetch lnurl info: ${e.status} ${e.statusText}`);const t=await e.json();await this.parseLnUrlPayResponse(t.lnurlp),this.parseKeysendResponse(t.keysend),this.parseNostrResponse(t.nostr)}async fetchWithoutProxy(){this.domain&&this.username&&await Promise.all([this.fetchLnurlData(),this.fetchKeysendData(),this.fetchNostrData()])}async fetchLnurlData(){const e=await fetch(this.lnurlpUrl());if(e.ok){const t=await e.json();await this.parseLnUrlPayResponse(t)}}async fetchKeysendData(){const e=await fetch(this.keysendUrl());if(e.ok){const t=await e.json();this.parseKeysendResponse(t)}}async fetchNostrData(){const e=await fetch(this.nostrUrl());if(e.ok){const t=await e.json();this.parseNostrResponse(t)}}lnurlpUrl(){return`https://${this.domain}/.well-known/lnurlp/${this.username}`}keysendUrl(){return`https://${this.domain}/.well-known/keysend/${this.username}`}nostrUrl(){return`https://${this.domain}/.well-known/nostr.json?name=${this.username}`}async generateInvoice(e){let t;if(this.options.proxy){const r=await fetch(`${this.options.proxy}/generate-invoice?${new URLSearchParams({ln:this.address,...e}).toString()}`);if(!r.ok)throw new Error(`Failed to generate invoice: ${r.status} ${r.statusText}`);t=(await r.json()).invoice}else{if(!this.lnurlpData)throw new Error("No lnurlpData available. Please call fetch() first.");if(!this.lnurlpData.callback||!W(this.lnurlpData.callback))throw new Error("Valid callback does not exist in lnurlpData");const r=new URL(this.lnurlpData.callback);r.search=new URLSearchParams(e).toString();const n=await fetch(r.toString());if(!n.ok)throw new Error(`Failed to generate invoice: ${n.status} ${n.statusText}`);t=await n.json()}const r=t&&t.pr&&t.pr.toString();if(!r)throw new Error("Invalid pay service invoice");const n={pr:r};if(t&&t.verify&&(n.verify=t.verify.toString()),t&&t.successAction&&"object"==typeof t.successAction){const{tag:e,message:r,description:o,url:s}=t.successAction;"message"===e?n.successAction={tag:e,message:r}:"url"===e&&(n.successAction={tag:e,description:o,url:s})}return new $(n)}async requestInvoice(e){if(!this.lnurlpData)throw new Error("No lnurlpData available. Please call fetch() first.");const t=1e3*e.satoshi,{commentAllowed:r,min:n,max:o}=this.lnurlpData;if(!T({amount:t,min:n,max:o}))throw new Error("Invalid amount");if(e.comment&&r&&r>0&&e.comment.length>r)throw new Error(`The comment length must be ${r} characters or fewer`);const s={amount:t.toString()};return e.comment&&(s.comment=e.comment),e.payerdata&&(s.payerdata=JSON.stringify(e.payerdata)),this.generateInvoice(s)}async boost(e,t=0){if(!this.keysendData)throw new Error("No keysendData available. Please call fetch() first.");const{destination:r,customKey:n,customValue:o}=this.keysendData,s=this.getWebLN();if(!s)throw new Error("WebLN not available");return C({destination:r,customKey:n,customValue:o,amount:t,boost:e},{webln:s})}async zapInvoice({satoshi:e,comment:t,relays:r,e:n},o={}){if(!this.lnurlpData)throw new Error("No lnurlpData available. Please call fetch() first.");if(!this.nostrPubkey)throw new Error("Nostr Pubkey is missing");const s=this.nostrPubkey,i=1e3*e,{allowsNostr:a,min:c,max:h}=this.lnurlpData;if(!T({amount:i,min:c,max:h}))throw new Error("Invalid amount");if(!a)throw new Error("Your provider does not support zaps");const l=await R({satoshi:i,comment:t,p:s,e:n,relays:r},o),u={amount:i.toString(),nostr:JSON.stringify(l)};return await this.generateInvoice(u)}async zap(e,t={}){const r=this.zapInvoice(e,t),n=this.getWebLN();if(!n)throw new Error("WebLN not available");await n.enable();return n.sendPayment((await r).paymentRequest)}async parseLnUrlPayResponse(e){e&&(this.lnurlpData=await P(e))}parseKeysendResponse(e){e&&(this.keysendData=L(e))}parseNostrResponse(e){e&&([this.nostrData,this.nostrPubkey,this.nostrRelays]=D(e,this.username))}},e.createGuardedWallet=j,e.decodeInvoice=a,e.fetch402=async(e,t,r)=>{const n=r.maxAmount?j(r.wallet,r.maxAmount):r.wallet;t||(t={}),t.cache="no-store",t.mode="cors";const o=new Headers(t.headers??void 0);t.headers=o;const s=await fetch(e,t),i=s.headers.get("www-authenticate");if(i){const r=i.trimStart().toLowerCase();if(r.startsWith("payment"))return V(i,e,t,o,n);if(r.startsWith("l402")||r.startsWith("lsat"))return O(i,e,t,o,n);throw new Error(`fetch402: unsupported WWW-Authenticate scheme: ${i}`)}const a=s.headers.get("PAYMENT-REQUIRED");return a?q(a,e,t,o,n):s},e.fetchWithL402=async(e,t,r)=>{const n=r.wallet;if(!n)throw new Error("wallet is missing");t||(t={}),t.cache="no-store",t.mode="cors";const o=new Headers(t.headers??void 0);t.headers=o;const s=await fetch(e,t),i=s.headers.get("www-authenticate");return i?O(i,e,t,o,n):s},e.fetchWithMpp=async(e,t,r)=>{const n=r.wallet;if(!n)throw new Error("wallet is missing");t||(t={}),t.cache="no-store",t.mode="cors";const o=new Headers(t.headers??void 0);t.headers=o;const s=await fetch(e,t),i=s.headers.get("www-authenticate");return i&&i.trimStart().toLowerCase().startsWith("payment")?V(i,e,t,o,n):s},e.fetchWithX402=async(e,t,r)=>{const n=r.wallet;t||(t={}),t.cache="no-store",t.mode="cors";const o=new Headers(t.headers??void 0);t.headers=o;const s=await fetch(e,t),i=s.headers.get("PAYMENT-REQUIRED");return i?q(i,e,t,o,n):s},e.fromHexString=i,e.generateZapEvent=R,e.getEventHash=N,e.getFiatBtcRate=M,e.getFiatCurrencies=async()=>{const e=await fetch("https://getalby.com/api/rates");if(!e.ok)throw new Error(`Failed to fetch currencies: ${e.status} ${e.statusText}`);const t=await e.json();return Object.entries(t).filter(([e])=>"BTC"!==e.toUpperCase()).map(([e,t])=>({code:e.toUpperCase(),name:t.name,priority:t.priority,symbol:t.symbol})).sort((e,t)=>e.name.localeCompare(t.name)).sort((e,t)=>e.priority-t.priority)},e.getFiatValue=z,e.getFormattedFiatValue=async({satoshi:e,currency:t,locale:r})=>{r||(r="en");return(await z({satoshi:e,currency:t})).toLocaleString(r,{style:"currency",currency:t})},e.getSatoshiValue=async({amount:e,currency:t})=>{const r=await M(t);return Math.floor(Number(e)/r)},e.isUrl=W,e.isValidAmount=T,e.parseKeysendResponse=L,e.parseLnUrlPayResponse=P,e.parseNostrResponse=D,e.sendBoostagram=C,e.serializeEvent=I,e.validateEvent=_}); | ||
| //# sourceMappingURL=lightning-tools.umd.js.map |
@@ -20,2 +20,4 @@ type InvoiceArgs = { | ||
| satoshi: number; | ||
| millisatoshi: number; | ||
| amountRaw: string; | ||
| timestamp: number; | ||
@@ -33,2 +35,4 @@ expiry: number | undefined; | ||
| satoshi: number; | ||
| millisatoshi: number; | ||
| amountRaw: string; | ||
| expiry: number | undefined; | ||
@@ -35,0 +39,0 @@ timestamp: number; |
+38
-28
@@ -23,2 +23,4 @@ import * as _webbtc_webln_types from '@webbtc/webln-types'; | ||
| satoshi: number; | ||
| millisatoshi: number; | ||
| amountRaw: string; | ||
| timestamp: number; | ||
@@ -36,2 +38,4 @@ expiry: number | undefined; | ||
| satoshi: number; | ||
| millisatoshi: number; | ||
| amountRaw: string; | ||
| expiry: number | undefined; | ||
@@ -240,35 +244,41 @@ timestamp: number; | ||
| interface KVStorage { | ||
| getItem(key: string): string | null; | ||
| setItem(key: string, value: string): void; | ||
| } | ||
| declare class MemoryStorage implements KVStorage { | ||
| storage: any; | ||
| constructor(initial?: Record<string, unknown>); | ||
| getItem(key: string): any; | ||
| setItem(key: string, value: unknown): void; | ||
| } | ||
| declare class NoStorage implements KVStorage { | ||
| constructor(initial?: unknown); | ||
| getItem(key: string): null; | ||
| setItem(key: string, value: unknown): void; | ||
| } | ||
| declare const parseL402: (input: string) => Record<string, string>; | ||
| declare const makeAuthenticateHeader: (args: { | ||
| macaroon: string; | ||
| invoice: string; | ||
| key?: string; | ||
| }) => string; | ||
| interface Wallet { | ||
| sendPayment(paymentRequest: string): Promise<{ | ||
| payInvoice(args: { | ||
| invoice: string; | ||
| }): Promise<{ | ||
| preimage: string; | ||
| }>; | ||
| } | ||
| declare function createGuardedWallet(wallet: Wallet, maxAmountSats: number): Wallet; | ||
| declare const fetch402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| maxAmount?: number; | ||
| }) => Promise<Response>; | ||
| declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: { | ||
| headerKey?: string; | ||
| wallet?: Wallet; | ||
| store?: KVStorage; | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| declare const fetchWithX402: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| /** | ||
| * Fetch a resource protected by the draft-lightning-charge-00 payment | ||
| * authentication protocol. | ||
| * | ||
| * On a `402 Payment Required` response that carries a | ||
| * `WWW-Authenticate: Payment method="lightning" intent="charge" …` header | ||
| * the function pays the embedded BOLT11 invoice and retries with the | ||
| * resulting preimage as the credential. | ||
| * | ||
| * Note: lightning-charge uses consume-once challenge semantics – each | ||
| * challenge embeds a fresh invoice, so paid credentials cannot be reused. | ||
| * The `store` option is accepted for API consistency but is not used. | ||
| */ | ||
| declare const fetchWithMpp: (url: string, fetchArgs: RequestInit, options: { | ||
| wallet: Wallet; | ||
| }) => Promise<Response>; | ||
| interface FiatCurrency { | ||
@@ -296,3 +306,3 @@ code: string; | ||
| export { DEFAULT_PROXY, Invoice, LN_ADDRESS_REGEX, LightningAddress, MemoryStorage, NoStorage, decodeInvoice, fetchWithL402, fromHexString, generateZapEvent, getEventHash, getFiatBtcRate, getFiatCurrencies, getFiatValue, getFormattedFiatValue, getSatoshiValue, isUrl, isValidAmount, makeAuthenticateHeader, parseKeysendResponse, parseL402, parseLnUrlPayResponse, parseNostrResponse, sendBoostagram, serializeEvent, validateEvent }; | ||
| export type { Boost, BoostArguments, BoostOptions, Event, FiatCurrency, InvoiceArgs, KVStorage, KeySendRawData, KeysendResponse, LUD18PayerData, LUD18ServicePayerData, LnUrlPayResponse, LnUrlRawData, NostrProvider, NostrResponse, RequestInvoiceArgs, SuccessAction, WeblnBoostParams, ZapArgs, ZapOptions }; | ||
| export { DEFAULT_PROXY, Invoice, LN_ADDRESS_REGEX, LightningAddress, createGuardedWallet, decodeInvoice, fetch402, fetchWithL402, fetchWithMpp, fetchWithX402, fromHexString, generateZapEvent, getEventHash, getFiatBtcRate, getFiatCurrencies, getFiatValue, getFormattedFiatValue, getSatoshiValue, isUrl, isValidAmount, parseKeysendResponse, parseLnUrlPayResponse, parseNostrResponse, sendBoostagram, serializeEvent, validateEvent }; | ||
| export type { Boost, BoostArguments, BoostOptions, Event, FiatCurrency, InvoiceArgs, KeySendRawData, KeysendResponse, LUD18PayerData, LUD18ServicePayerData, LnUrlPayResponse, LnUrlRawData, NostrProvider, NostrResponse, RequestInvoiceArgs, SuccessAction, Wallet, WeblnBoostParams, ZapArgs, ZapOptions }; |
@@ -143,2 +143,4 @@ import { WebLNProvider, SendPaymentResponse } from '@webbtc/webln-types'; | ||
| satoshi: number; | ||
| millisatoshi: number; | ||
| amountRaw: string; | ||
| expiry: number | undefined; | ||
@@ -145,0 +147,0 @@ timestamp: number; |
+20
-5
| { | ||
| "name": "@getalby/lightning-tools", | ||
| "version": "7.0.2", | ||
| "version": "8.0.0", | ||
| "description": "Collection of helpful building blocks and tools to develop Bitcoin Lightning web apps", | ||
@@ -42,7 +42,22 @@ "type": "module", | ||
| }, | ||
| "./l402": { | ||
| "import": "./dist/esm/l402.js", | ||
| "require": "./dist/cjs/l402.cjs", | ||
| "types": "./dist/types/l402.d.ts" | ||
| "./402": { | ||
| "import": "./dist/esm/402.js", | ||
| "require": "./dist/cjs/402.cjs", | ||
| "types": "./dist/types/402.d.ts" | ||
| }, | ||
| "./402/l402": { | ||
| "import": "./dist/esm/402/l402.js", | ||
| "require": "./dist/cjs/402/l402.cjs", | ||
| "types": "./dist/types/402/l402.d.ts" | ||
| }, | ||
| "./402/x402": { | ||
| "import": "./dist/esm/402/x402.js", | ||
| "require": "./dist/cjs/402/x402.cjs", | ||
| "types": "./dist/types/402/x402.d.ts" | ||
| }, | ||
| "./402/mpp": { | ||
| "import": "./dist/esm/402/mpp.js", | ||
| "require": "./dist/cjs/402/mpp.cjs", | ||
| "types": "./dist/types/402/mpp.d.ts" | ||
| }, | ||
| "./lnurl": { | ||
@@ -49,0 +64,0 @@ "import": "./dist/esm/lnurl.js", |
+108
-28
@@ -13,3 +13,3 @@ <p align="center"> | ||
| Skip the rest of this README and use the [Alby Bitcoin Payments Agent Skill](https://github.com/getAlby/alby-agent-skill) instead. It will handle the rest! | ||
| Skip the rest of this README and use the [Alby Bitcoin Builder Skill](https://github.com/getAlby/builder-skill) instead. It will handle the rest! | ||
@@ -32,3 +32,3 @@ ## Manual Installation | ||
| <script type="module"> | ||
| import { LightningAddress } from "https://esm.sh/@getalby/lightning-tools@5.0.0"; // jsdelivr.net, skypack.dev also work | ||
| import { LightningAddress } from "https://esm.sh/@getalby/lightning-tools@7"; // jsdelivr.net, skypack.dev also work | ||
@@ -173,4 +173,42 @@ // use LightningAddress normally... | ||
| ### L402 | ||
| > All examples in the [examples/](examples/) directory are runnable. See [examples/README.md](examples/README.md) for setup instructions. | ||
| ### HTTP 402 - requesting HTTP resources that require a payment | ||
| L402, X402, MPP are protocol standards based on the HTTP 402 `Payment Required` code | ||
| for machine-to-machine payments. It is used to charge for HTTP API requests, tool calls, or agentic payments. | ||
| This library includes functions to consome those resources. | ||
| #### fetch402(url: string, fetchArgs, options) | ||
| `fetch402` is a single function that transparently handles L402 and X402 and MPP protected resources. Use it when you don't know or don't care which protocol the server uses — it will detect the protocol from the response headers and pay accordingly. | ||
| - url: the protected URL | ||
| - fetchArgs: arguments are passed to the underlying `fetch()` function used to do the HTTP request | ||
| - options: | ||
| - wallet: any object that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay L402, X402 and MPP invoices. | ||
| ##### Examples | ||
| ```js | ||
| import { fetch402 } from "@getalby/lightning-tools/402"; | ||
| import { NWCClient } from "@getalby/sdk"; | ||
| const nwc = new NWCClient({ | ||
| nostrWalletConnectUrl: "nostr+walletconnect://...", | ||
| }); | ||
| await fetch402( | ||
| "https://example.com/protected-resource", | ||
| {}, | ||
| { wallet: nwc }, | ||
| ) | ||
| .then((res) => res.json()) | ||
| .then(console.log) | ||
| .finally(() => nwc.close()); | ||
| ``` | ||
| #### L402 | ||
| L402 is a protocol standard based on the HTTP 402 Payment Required error code | ||
@@ -182,3 +220,3 @@ designed to support the use case of charging for services and | ||
| #### fetchWithL402(url: string, fetchArgs, options) | ||
| ##### fetchWithL402(url: string, fetchArgs, options) | ||
@@ -188,5 +226,3 @@ - url: the L402 protected URL | ||
| - options: | ||
| - wallet: any object that implements `sendPayment(paymentRequest)` and returns `{ preimage }`. Used to pay the L402 invoice. | ||
| - store: a key/value store object to persiste the l402 for each URL. The store must implement a `getItem()`/`setItem()` function as the browser's localStorage. By default a memory storage is used. | ||
| - headerKey: defaults to L402 but if you need to consume an old LSAT API set this to LSAT | ||
| - wallet: any object (e.g. a NWC client) that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay the L402 invoice. | ||
@@ -196,27 +232,46 @@ ##### Examples | ||
| ```js | ||
| import { fetchWithL402 } from "@getalby/lightning-tools/l402"; | ||
| import { fetchWithL402 } from "@getalby/lightning-tools/402/l402"; | ||
| import { NWCClient } from "@getalby/sdk"; | ||
| // pass a wallet that implements sendPayment() | ||
| // the tokens/preimage data will be stored in the browser's localStorage and used for any following request | ||
| const nwc = new NWCClient({ | ||
| nostrWalletConnectUrl: "nostr+walletconnect://...", | ||
| }); | ||
| await fetchWithL402( | ||
| "https://lsat-weather-api.getalby.repl.co/kigali", | ||
| "https://l402.example.com/protected-resource", | ||
| {}, | ||
| { wallet: myWallet, store: window.localStorage }, | ||
| { wallet: nwc }, | ||
| ) | ||
| .then((res) => res.json()) | ||
| .then(console.log); | ||
| .then(console.log) | ||
| .finally(() => nwc.close()); | ||
| ``` | ||
| #### X402 | ||
| Similar to L402 X402 is an open protocol for machine-to-machine payments built on the HTTP 402 Payment Required status code. | ||
| It enables APIs and resources to request payments inline, without prior registration or authentication. | ||
| This library includes a `fetchWithX402` function to consume X402-protected resources that support the lightning network. | ||
| (Note: X402 works also with other coins and network. This library supports X402 resources that accept Bitcoin on the lightning network) | ||
| ##### fetchWithX402(url: string, fetchArgs, options) | ||
| - url: the X402 protected URL | ||
| - fetchArgs: arguments are passed to the underlying `fetch()` function used to do the HTTP request | ||
| - options: | ||
| - wallet: any object (e.g. a NWC client) that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay the X402 invoice. | ||
| ##### Examples | ||
| ```js | ||
| import { fetchWithL402 } from "@getalby/lightning-tools/l402"; | ||
| import { NostrWebLNProvider } from "@getalby/sdk"; | ||
| import { fetchWithX402 } from "@getalby/lightning-tools/402/x402"; | ||
| import { NWCClient } from "@getalby/sdk"; | ||
| // use a NWC provider as the wallet to do the payments | ||
| const nwc = new NostrWebLNProvider({ | ||
| nostrWalletConnectUrl: loadNWCUrl(), | ||
| const nwc = new NWCClient({ | ||
| nostrWalletConnectUrl: "nostr+walletconnect://...", | ||
| }); | ||
| // this will fetch the resource and pay the invoice using the NWC wallet | ||
| await fetchWithL402( | ||
| "https://lsat-weather-api.getalby.repl.co/kigali", | ||
| await fetchWithX402( | ||
| "https://x402.example.com/protected-resource", | ||
| {}, | ||
@@ -226,14 +281,39 @@ { wallet: nwc }, | ||
| .then((res) => res.json()) | ||
| .then(console.log); | ||
| .then(console.log) | ||
| .finally(() => nwc.close()); | ||
| ``` | ||
| #### MPP | ||
| MPP is an open protocol for machine-to-machine payments built on the HTTP 402 Payment Required status code. | ||
| Charge for API requests, tool calls, or content—agents and apps pay per request in the same HTTP call. | ||
| This library includes a `fetchWithMpp` function to consume MPP-protected resources that support the lightning network. | ||
| (Note: MPP works also with other payment methods. This library supports resources that accept Bitcoin on the lightning network) | ||
| ##### fetchWithMpp(url: string, fetchArgs, options) | ||
| - url: the MPP protected URL | ||
| - fetchArgs: arguments are passed to the underlying `fetch()` function used to do the HTTP request | ||
| - options: | ||
| - wallet: any object (e.g. a NWC client) that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay the X402 invoice. | ||
| ##### Examples | ||
| ```js | ||
| import { fetchWithL402, NoStorage } from "@getalby/lightning-tools/l402"; | ||
| import { fetchWithMpp } from "@getalby/lightning-tools/402/mpp"; | ||
| import { NWCClient } from "@getalby/sdk"; | ||
| // do not store the tokens | ||
| await fetchWithL402( | ||
| "https://lsat-weather-api.getalby.repl.co/kigali", | ||
| const nwc = new NWCClient({ | ||
| nostrWalletConnectUrl: "nostr+walletconnect://...", | ||
| }); | ||
| await fetchWithMpp( | ||
| "https://mpp.example.com/protected-resource", | ||
| {}, | ||
| { store: new NoStorage() }, | ||
| ); | ||
| { wallet: nwc }, | ||
| ) | ||
| .then((res) => res.json()) | ||
| .then(console.log) | ||
| .finally(() => nwc.close()); | ||
| ``` | ||
@@ -240,0 +320,0 @@ |
| 'use strict'; | ||
| class MemoryStorage { | ||
| constructor(initial) { | ||
| this.storage = initial || {}; | ||
| } | ||
| getItem(key) { | ||
| return this.storage[key]; | ||
| } | ||
| setItem(key, value) { | ||
| this.storage[key] = value; | ||
| } | ||
| } | ||
| class NoStorage { | ||
| constructor(initial) { } | ||
| getItem(key) { | ||
| return null; | ||
| } | ||
| setItem(key, value) { } | ||
| } | ||
| const parseL402 = (input) => { | ||
| // Remove the L402 and LSAT identifiers | ||
| const string = input.replace("L402", "").replace("LSAT", "").trim(); | ||
| // Initialize an object to store the key-value pairs | ||
| const keyValuePairs = {}; | ||
| // Regular expression to match key and (quoted or unquoted) value | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g; | ||
| let match; | ||
| // Use regex to find all key-value pairs | ||
| while ((match = regex.exec(string)) !== null) { | ||
| // Key is always match[1] | ||
| // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted) | ||
| keyValuePairs[match[1]] = match[3] || match[4] || match[5]; | ||
| } | ||
| return keyValuePairs; | ||
| }; | ||
| const makeAuthenticateHeader = (args) => { | ||
| const key = args.key || "L402"; | ||
| return `${key} macaroon="${args.macaroon}", invoice="${args.invoice}"`; | ||
| }; | ||
| const memoryStorage = new MemoryStorage(); | ||
| const HEADER_KEY = "L402"; | ||
| const fetchWithL402 = async (url, fetchArgs, options) => { | ||
| if (!options) { | ||
| options = {}; | ||
| } | ||
| const headerKey = options.headerKey || HEADER_KEY; | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| const store = options.store || memoryStorage; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| if (!fetchArgs.headers) { | ||
| fetchArgs.headers = {}; | ||
| } | ||
| const cachedL402Data = store.getItem(url); | ||
| if (cachedL402Data) { | ||
| const data = JSON.parse(cachedL402Data); | ||
| fetchArgs.headers["Authorization"] = | ||
| `${headerKey} ${data.token}:${data.preimage}`; | ||
| return await fetch(url, fetchArgs); | ||
| } | ||
| fetchArgs.headers["Accept-Authenticate"] = headerKey; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("www-authenticate"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| const details = parseL402(header); | ||
| const token = details.token || details.macaroon; | ||
| const inv = details.invoice; | ||
| const invResp = await wallet.sendPayment(inv); | ||
| store.setItem(url, JSON.stringify({ | ||
| token: token, | ||
| preimage: invResp.preimage, | ||
| })); | ||
| fetchArgs.headers["Authorization"] = | ||
| `${headerKey} ${token}:${invResp.preimage}`; | ||
| return await fetch(url, fetchArgs); | ||
| }; | ||
| exports.MemoryStorage = MemoryStorage; | ||
| exports.NoStorage = NoStorage; | ||
| exports.fetchWithL402 = fetchWithL402; | ||
| exports.makeAuthenticateHeader = makeAuthenticateHeader; | ||
| exports.parseL402 = parseL402; | ||
| //# sourceMappingURL=l402.cjs.map |
| {"version":3,"file":"l402.cjs","sources":["../../src/l402/utils.ts","../../src/l402/l402.ts"],"sourcesContent":["export interface KVStorage {\n getItem(key: string): string | null;\n setItem(key: string, value: string): void;\n}\n\nexport class MemoryStorage implements KVStorage {\n storage;\n\n constructor(initial?: Record<string, unknown>) {\n this.storage = initial || {};\n }\n\n getItem(key: string) {\n return this.storage[key];\n }\n\n setItem(key: string, value: unknown) {\n this.storage[key] = value;\n }\n}\n\nexport class NoStorage implements KVStorage {\n constructor(initial?: unknown) {}\n\n getItem(key: string) {\n return null;\n }\n\n setItem(key: string, value: unknown) {}\n}\n\nexport const parseL402 = (input: string): Record<string, string> => {\n // Remove the L402 and LSAT identifiers\n const string = input.replace(\"L402\", \"\").replace(\"LSAT\", \"\").trim();\n\n // Initialize an object to store the key-value pairs\n const keyValuePairs = {};\n\n // Regular expression to match key and (quoted or unquoted) value\n const regex = /(\\w+)=(\"([^\"]*)\"|'([^']*)'|([^,]*))/g;\n let match;\n\n // Use regex to find all key-value pairs\n while ((match = regex.exec(string)) !== null) {\n // Key is always match[1]\n // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted)\n keyValuePairs[match[1]] = match[3] || match[4] || match[5];\n }\n\n return keyValuePairs;\n};\n\nexport const makeAuthenticateHeader = (args: { macaroon: string, invoice: string, key?: string }) => {\n const key = args.key || \"L402\";\n\n return `${key} macaroon=\"${args.macaroon}\", invoice=\"${args.invoice}\"`;\n}\n","import { KVStorage, MemoryStorage, parseL402 } from \"./utils\";\n\nconst memoryStorage = new MemoryStorage();\n\nconst HEADER_KEY = \"L402\";\n\ninterface Wallet {\n sendPayment(paymentRequest: string): Promise<{ preimage: string }>;\n}\n\nexport const fetchWithL402 = async (\n url: string,\n fetchArgs: RequestInit,\n options: {\n headerKey?: string;\n wallet?: Wallet;\n store?: KVStorage;\n },\n) => {\n if (!options) {\n options = {};\n }\n const headerKey = options.headerKey || HEADER_KEY;\n const wallet: Wallet | undefined = options.wallet;\n if (!wallet) {\n throw new Error(\"wallet is missing\");\n }\n const store = options.store || memoryStorage;\n if (!fetchArgs) {\n fetchArgs = {};\n }\n fetchArgs.cache = \"no-store\";\n fetchArgs.mode = \"cors\";\n if (!fetchArgs.headers) {\n fetchArgs.headers = {};\n }\n const cachedL402Data = store.getItem(url);\n if (cachedL402Data) {\n const data = JSON.parse(cachedL402Data);\n fetchArgs.headers[\"Authorization\"] =\n `${headerKey} ${data.token}:${data.preimage}`;\n return await fetch(url, fetchArgs);\n }\n\n fetchArgs.headers[\"Accept-Authenticate\"] = headerKey;\n const initResp = await fetch(url, fetchArgs);\n const header = initResp.headers.get(\"www-authenticate\");\n if (!header) {\n return initResp;\n }\n\n const details = parseL402(header);\n const token = details.token || details.macaroon;\n const inv = details.invoice;\n\n const invResp = await wallet.sendPayment(inv);\n\n store.setItem(\n url,\n JSON.stringify({\n token: token,\n preimage: invResp.preimage,\n }),\n );\n\n fetchArgs.headers[\"Authorization\"] =\n `${headerKey} ${token}:${invResp.preimage}`;\n return await fetch(url, fetchArgs);\n};\n"],"names":[],"mappings":";;MAKa,aAAa,CAAA;AAGxB,IAAA,WAAA,CAAY,OAAiC,EAAA;AAC3C,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,EAAE;IAC9B;AAEA,IAAA,OAAO,CAAC,GAAW,EAAA;AACjB,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;IAC1B;IAEA,OAAO,CAAC,GAAW,EAAE,KAAc,EAAA;AACjC,QAAA,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK;IAC3B;AACD;MAEY,SAAS,CAAA;IACpB,WAAA,CAAY,OAAiB,IAAG;AAEhC,IAAA,OAAO,CAAC,GAAW,EAAA;AACjB,QAAA,OAAO,IAAI;IACb;AAEA,IAAA,OAAO,CAAC,GAAW,EAAE,KAAc,IAAG;AACvC;AAEM,MAAM,SAAS,GAAG,CAAC,KAAa,KAA4B;;IAEjE,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE;;IAGnE,MAAM,aAAa,GAAG,EAAE;;IAGxB,MAAM,KAAK,GAAG,sCAAsC;AACpD,IAAA,IAAI,KAAK;;AAGT,IAAA,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE;;;QAG5C,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;IAC5D;AAEA,IAAA,OAAO,aAAa;AACtB;AAEO,MAAM,sBAAsB,GAAG,CAAC,IAAyD,KAAI;AAClG,IAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,MAAM;IAE9B,OAAO,CAAA,EAAG,GAAG,CAAA,WAAA,EAAc,IAAI,CAAC,QAAQ,CAAA,YAAA,EAAe,IAAI,CAAC,OAAO,CAAA,CAAA,CAAG;AACxE;;ACtDA,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE;AAEzC,MAAM,UAAU,GAAG,MAAM;AAMlB,MAAM,aAAa,GAAG,OAC3B,GAAW,EACX,SAAsB,EACtB,OAIC,KACC;IACF,IAAI,CAAC,OAAO,EAAE;QACZ,OAAO,GAAG,EAAE;IACd;AACA,IAAA,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,UAAU;AACjD,IAAA,MAAM,MAAM,GAAuB,OAAO,CAAC,MAAM;IACjD,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IACtC;AACA,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa;IAC5C,IAAI,CAAC,SAAS,EAAE;QACd,SAAS,GAAG,EAAE;IAChB;AACA,IAAA,SAAS,CAAC,KAAK,GAAG,UAAU;AAC5B,IAAA,SAAS,CAAC,IAAI,GAAG,MAAM;AACvB,IAAA,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;AACtB,QAAA,SAAS,CAAC,OAAO,GAAG,EAAE;IACxB;IACA,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;IACzC,IAAI,cAAc,EAAE;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;AACvC,QAAA,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC;YAChC,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAA,CAAE;AAC/C,QAAA,OAAO,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IACpC;AAEA,IAAA,SAAS,CAAC,OAAO,CAAC,qBAAqB,CAAC,GAAG,SAAS;IACpD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IACvD,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,OAAO,QAAQ;IACjB;AAEA,IAAA,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC;IACjC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ;AAC/C,IAAA,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO;IAE3B,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC;IAE7C,KAAK,CAAC,OAAO,CACX,GAAG,EACH,IAAI,CAAC,SAAS,CAAC;AACb,QAAA,KAAK,EAAE,KAAK;QACZ,QAAQ,EAAE,OAAO,CAAC,QAAQ;AAC3B,KAAA,CAAC,CACH;AAED,IAAA,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC;QAChC,CAAA,EAAG,SAAS,IAAI,KAAK,CAAA,CAAA,EAAI,OAAO,CAAC,QAAQ,EAAE;AAC7C,IAAA,OAAO,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;AACpC;;;;;;;;"} |
| class MemoryStorage { | ||
| constructor(initial) { | ||
| this.storage = initial || {}; | ||
| } | ||
| getItem(key) { | ||
| return this.storage[key]; | ||
| } | ||
| setItem(key, value) { | ||
| this.storage[key] = value; | ||
| } | ||
| } | ||
| class NoStorage { | ||
| constructor(initial) { } | ||
| getItem(key) { | ||
| return null; | ||
| } | ||
| setItem(key, value) { } | ||
| } | ||
| const parseL402 = (input) => { | ||
| // Remove the L402 and LSAT identifiers | ||
| const string = input.replace("L402", "").replace("LSAT", "").trim(); | ||
| // Initialize an object to store the key-value pairs | ||
| const keyValuePairs = {}; | ||
| // Regular expression to match key and (quoted or unquoted) value | ||
| const regex = /(\w+)=("([^"]*)"|'([^']*)'|([^,]*))/g; | ||
| let match; | ||
| // Use regex to find all key-value pairs | ||
| while ((match = regex.exec(string)) !== null) { | ||
| // Key is always match[1] | ||
| // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted) | ||
| keyValuePairs[match[1]] = match[3] || match[4] || match[5]; | ||
| } | ||
| return keyValuePairs; | ||
| }; | ||
| const makeAuthenticateHeader = (args) => { | ||
| const key = args.key || "L402"; | ||
| return `${key} macaroon="${args.macaroon}", invoice="${args.invoice}"`; | ||
| }; | ||
| const memoryStorage = new MemoryStorage(); | ||
| const HEADER_KEY = "L402"; | ||
| const fetchWithL402 = async (url, fetchArgs, options) => { | ||
| if (!options) { | ||
| options = {}; | ||
| } | ||
| const headerKey = options.headerKey || HEADER_KEY; | ||
| const wallet = options.wallet; | ||
| if (!wallet) { | ||
| throw new Error("wallet is missing"); | ||
| } | ||
| const store = options.store || memoryStorage; | ||
| if (!fetchArgs) { | ||
| fetchArgs = {}; | ||
| } | ||
| fetchArgs.cache = "no-store"; | ||
| fetchArgs.mode = "cors"; | ||
| if (!fetchArgs.headers) { | ||
| fetchArgs.headers = {}; | ||
| } | ||
| const cachedL402Data = store.getItem(url); | ||
| if (cachedL402Data) { | ||
| const data = JSON.parse(cachedL402Data); | ||
| fetchArgs.headers["Authorization"] = | ||
| `${headerKey} ${data.token}:${data.preimage}`; | ||
| return await fetch(url, fetchArgs); | ||
| } | ||
| fetchArgs.headers["Accept-Authenticate"] = headerKey; | ||
| const initResp = await fetch(url, fetchArgs); | ||
| const header = initResp.headers.get("www-authenticate"); | ||
| if (!header) { | ||
| return initResp; | ||
| } | ||
| const details = parseL402(header); | ||
| const token = details.token || details.macaroon; | ||
| const inv = details.invoice; | ||
| const invResp = await wallet.sendPayment(inv); | ||
| store.setItem(url, JSON.stringify({ | ||
| token: token, | ||
| preimage: invResp.preimage, | ||
| })); | ||
| fetchArgs.headers["Authorization"] = | ||
| `${headerKey} ${token}:${invResp.preimage}`; | ||
| return await fetch(url, fetchArgs); | ||
| }; | ||
| export { MemoryStorage, NoStorage, fetchWithL402, makeAuthenticateHeader, parseL402 }; | ||
| //# sourceMappingURL=l402.js.map |
| {"version":3,"file":"l402.js","sources":["../../src/l402/utils.ts","../../src/l402/l402.ts"],"sourcesContent":["export interface KVStorage {\n getItem(key: string): string | null;\n setItem(key: string, value: string): void;\n}\n\nexport class MemoryStorage implements KVStorage {\n storage;\n\n constructor(initial?: Record<string, unknown>) {\n this.storage = initial || {};\n }\n\n getItem(key: string) {\n return this.storage[key];\n }\n\n setItem(key: string, value: unknown) {\n this.storage[key] = value;\n }\n}\n\nexport class NoStorage implements KVStorage {\n constructor(initial?: unknown) {}\n\n getItem(key: string) {\n return null;\n }\n\n setItem(key: string, value: unknown) {}\n}\n\nexport const parseL402 = (input: string): Record<string, string> => {\n // Remove the L402 and LSAT identifiers\n const string = input.replace(\"L402\", \"\").replace(\"LSAT\", \"\").trim();\n\n // Initialize an object to store the key-value pairs\n const keyValuePairs = {};\n\n // Regular expression to match key and (quoted or unquoted) value\n const regex = /(\\w+)=(\"([^\"]*)\"|'([^']*)'|([^,]*))/g;\n let match;\n\n // Use regex to find all key-value pairs\n while ((match = regex.exec(string)) !== null) {\n // Key is always match[1]\n // Value is either match[3] (double-quoted), match[4] (single-quoted), or match[5] (unquoted)\n keyValuePairs[match[1]] = match[3] || match[4] || match[5];\n }\n\n return keyValuePairs;\n};\n\nexport const makeAuthenticateHeader = (args: { macaroon: string, invoice: string, key?: string }) => {\n const key = args.key || \"L402\";\n\n return `${key} macaroon=\"${args.macaroon}\", invoice=\"${args.invoice}\"`;\n}\n","import { KVStorage, MemoryStorage, parseL402 } from \"./utils\";\n\nconst memoryStorage = new MemoryStorage();\n\nconst HEADER_KEY = \"L402\";\n\ninterface Wallet {\n sendPayment(paymentRequest: string): Promise<{ preimage: string }>;\n}\n\nexport const fetchWithL402 = async (\n url: string,\n fetchArgs: RequestInit,\n options: {\n headerKey?: string;\n wallet?: Wallet;\n store?: KVStorage;\n },\n) => {\n if (!options) {\n options = {};\n }\n const headerKey = options.headerKey || HEADER_KEY;\n const wallet: Wallet | undefined = options.wallet;\n if (!wallet) {\n throw new Error(\"wallet is missing\");\n }\n const store = options.store || memoryStorage;\n if (!fetchArgs) {\n fetchArgs = {};\n }\n fetchArgs.cache = \"no-store\";\n fetchArgs.mode = \"cors\";\n if (!fetchArgs.headers) {\n fetchArgs.headers = {};\n }\n const cachedL402Data = store.getItem(url);\n if (cachedL402Data) {\n const data = JSON.parse(cachedL402Data);\n fetchArgs.headers[\"Authorization\"] =\n `${headerKey} ${data.token}:${data.preimage}`;\n return await fetch(url, fetchArgs);\n }\n\n fetchArgs.headers[\"Accept-Authenticate\"] = headerKey;\n const initResp = await fetch(url, fetchArgs);\n const header = initResp.headers.get(\"www-authenticate\");\n if (!header) {\n return initResp;\n }\n\n const details = parseL402(header);\n const token = details.token || details.macaroon;\n const inv = details.invoice;\n\n const invResp = await wallet.sendPayment(inv);\n\n store.setItem(\n url,\n JSON.stringify({\n token: token,\n preimage: invResp.preimage,\n }),\n );\n\n fetchArgs.headers[\"Authorization\"] =\n `${headerKey} ${token}:${invResp.preimage}`;\n return await fetch(url, fetchArgs);\n};\n"],"names":[],"mappings":"MAKa,aAAa,CAAA;AAGxB,IAAA,WAAA,CAAY,OAAiC,EAAA;AAC3C,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,EAAE;IAC9B;AAEA,IAAA,OAAO,CAAC,GAAW,EAAA;AACjB,QAAA,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC;IAC1B;IAEA,OAAO,CAAC,GAAW,EAAE,KAAc,EAAA;AACjC,QAAA,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK;IAC3B;AACD;MAEY,SAAS,CAAA;IACpB,WAAA,CAAY,OAAiB,IAAG;AAEhC,IAAA,OAAO,CAAC,GAAW,EAAA;AACjB,QAAA,OAAO,IAAI;IACb;AAEA,IAAA,OAAO,CAAC,GAAW,EAAE,KAAc,IAAG;AACvC;AAEM,MAAM,SAAS,GAAG,CAAC,KAAa,KAA4B;;IAEjE,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE;;IAGnE,MAAM,aAAa,GAAG,EAAE;;IAGxB,MAAM,KAAK,GAAG,sCAAsC;AACpD,IAAA,IAAI,KAAK;;AAGT,IAAA,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE;;;QAG5C,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;IAC5D;AAEA,IAAA,OAAO,aAAa;AACtB;AAEO,MAAM,sBAAsB,GAAG,CAAC,IAAyD,KAAI;AAClG,IAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,MAAM;IAE9B,OAAO,CAAA,EAAG,GAAG,CAAA,WAAA,EAAc,IAAI,CAAC,QAAQ,CAAA,YAAA,EAAe,IAAI,CAAC,OAAO,CAAA,CAAA,CAAG;AACxE;;ACtDA,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE;AAEzC,MAAM,UAAU,GAAG,MAAM;AAMlB,MAAM,aAAa,GAAG,OAC3B,GAAW,EACX,SAAsB,EACtB,OAIC,KACC;IACF,IAAI,CAAC,OAAO,EAAE;QACZ,OAAO,GAAG,EAAE;IACd;AACA,IAAA,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,UAAU;AACjD,IAAA,MAAM,MAAM,GAAuB,OAAO,CAAC,MAAM;IACjD,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC;IACtC;AACA,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa;IAC5C,IAAI,CAAC,SAAS,EAAE;QACd,SAAS,GAAG,EAAE;IAChB;AACA,IAAA,SAAS,CAAC,KAAK,GAAG,UAAU;AAC5B,IAAA,SAAS,CAAC,IAAI,GAAG,MAAM;AACvB,IAAA,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;AACtB,QAAA,SAAS,CAAC,OAAO,GAAG,EAAE;IACxB;IACA,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;IACzC,IAAI,cAAc,EAAE;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;AACvC,QAAA,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC;YAChC,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAA,CAAE;AAC/C,QAAA,OAAO,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IACpC;AAEA,IAAA,SAAS,CAAC,OAAO,CAAC,qBAAqB,CAAC,GAAG,SAAS;IACpD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;IAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IACvD,IAAI,CAAC,MAAM,EAAE;AACX,QAAA,OAAO,QAAQ;IACjB;AAEA,IAAA,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC;IACjC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,QAAQ;AAC/C,IAAA,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO;IAE3B,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC;IAE7C,KAAK,CAAC,OAAO,CACX,GAAG,EACH,IAAI,CAAC,SAAS,CAAC;AACb,QAAA,KAAK,EAAE,KAAK;QACZ,QAAQ,EAAE,OAAO,CAAC,QAAQ;AAC3B,KAAA,CAAC,CACH;AAED,IAAA,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC;QAChC,CAAA,EAAG,SAAS,IAAI,KAAK,CAAA,CAAA,EAAI,OAAO,CAAC,QAAQ,EAAE;AAC7C,IAAA,OAAO,MAAM,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC;AACpC;;;;"} |
| interface KVStorage { | ||
| getItem(key: string): string | null; | ||
| setItem(key: string, value: string): void; | ||
| } | ||
| declare class MemoryStorage implements KVStorage { | ||
| storage: any; | ||
| constructor(initial?: Record<string, unknown>); | ||
| getItem(key: string): any; | ||
| setItem(key: string, value: unknown): void; | ||
| } | ||
| declare class NoStorage implements KVStorage { | ||
| constructor(initial?: unknown); | ||
| getItem(key: string): null; | ||
| setItem(key: string, value: unknown): void; | ||
| } | ||
| declare const parseL402: (input: string) => Record<string, string>; | ||
| declare const makeAuthenticateHeader: (args: { | ||
| macaroon: string; | ||
| invoice: string; | ||
| key?: string; | ||
| }) => string; | ||
| interface Wallet { | ||
| sendPayment(paymentRequest: string): Promise<{ | ||
| preimage: string; | ||
| }>; | ||
| } | ||
| declare const fetchWithL402: (url: string, fetchArgs: RequestInit, options: { | ||
| headerKey?: string; | ||
| wallet?: Wallet; | ||
| store?: KVStorage; | ||
| }) => Promise<Response>; | ||
| export { MemoryStorage, NoStorage, fetchWithL402, makeAuthenticateHeader, parseL402 }; | ||
| export type { KVStorage }; |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
New alerts
URL strings
Supply chain riskPackage contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.
Fixed alerts
URL strings
Supply chain riskPackage contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.
Improved metrics
- Total package byte prevSize
2076110
61.85%- Number of package files
50
42.86%- Lines of code
16575
63.03%- Number of lines in readme file
419
23.6%Worsened metrics
- Number of medium supply chain risk alerts
105
52.17%No dependency changes