x402-proxy 0.10.7 → 0.10.9

package/dist/utils-SeGHMW9O.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+import * as nc from "node:crypto";
+//#region node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
+/**
+* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+* @todo re-check https://issues.chromium.org/issues/42212588
+* @module
+*/
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+	if (le) return {
+		h: Number(n & U32_MASK64),
+		l: Number(n >> _32n & U32_MASK64)
+	};
+	return {
+		h: Number(n >> _32n & U32_MASK64) | 0,
+		l: Number(n & U32_MASK64) | 0
+	};
+}
+function split(lst, le = false) {
+	const len = lst.length;
+	let Ah = new Uint32Array(len);
+	let Al = new Uint32Array(len);
+	for (let i = 0; i < len; i++) {
+		const { h, l } = fromBig(lst[i], le);
+		[Ah[i], Al[i]] = [h, l];
+	}
+	return [Ah, Al];
+}
+const shrSH = (h, _l, s) => h >>> s;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+function add(Ah, Al, Bh, Bl) {
+	const l = (Al >>> 0) + (Bl >>> 0);
+	return {
+		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
+		l: l | 0
+	};
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+//#endregion
+//#region node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
+/**
+* Internal webcrypto alias.
+* We prefer WebCrypto aka globalThis.crypto, which exists in node.js 16+.
+* Falls back to Node.js built-in crypto for Node.js <=v14.
+* See utils.ts for details.
+* @module
+*/
+const crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+//#endregion
+//#region node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+/**
+* Utilities for hex, bytes, CSPRNG.
+* @module
+*/
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes$1(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+	if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes$1(b, ...lengths) {
+	if (!isBytes$1(b)) throw new Error("Uint8Array expected");
+	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+/** Asserts something is hash */
+function ahash(h) {
+	if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash should be wrapped by utils.createHasher");
+	anumber(h.outputLen);
+	anumber(h.blockLen);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(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");
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+	abytes$1(out);
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+	return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+	return word << 32 - shift | word >>> shift;
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+/** The byte swap operation for uint32 */
+function byteSwap(word) {
+	return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+	for (let i = 0; i < arr.length; i++) arr[i] = byteSwap(arr[i]);
+	return arr;
+}
+const swap32IfBE = isLE ? (u) => u : byteSwap32;
+typeof Uint8Array.from([]).toHex === "function" && Uint8Array.fromHex;
+/**
+* Converts string to bytes using UTF8 encoding.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes$1(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+/**
+* 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$1(data);
+	abytes$1(data);
+	return data;
+}
+/** Copies several Uint8Arrays into one. */
+function concatBytes$1(...arrays) {
+	let sum = 0;
+	for (let i = 0; i < arrays.length; i++) {
+		const a = arrays[i];
+		abytes$1(a);
+		sum += a.length;
+	}
+	const res = new Uint8Array(sum);
+	for (let i = 0, pad = 0; i < arrays.length; i++) {
+		const a = arrays[i];
+		res.set(a, pad);
+		pad += a.length;
+	}
+	return res;
+}
+/** For runtime check if class implements interface */
+var Hash = class {};
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(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;
+}
+function createXOFer(hashCons) {
+	const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+	const tmp = hashCons({});
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = (opts) => hashCons(opts);
+	return hashC;
+}
+/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
+function randomBytes(bytesLength = 32) {
+	if (crypto && typeof crypto.getRandomValues === "function") return crypto.getRandomValues(new Uint8Array(bytesLength));
+	if (crypto && typeof crypto.randomBytes === "function") return Uint8Array.from(crypto.randomBytes(bytesLength));
+	throw new Error("crypto.getRandomValues must be defined");
+}
+//#endregion
+//#region node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/utils.js
+/**
+* Hex, bytes and number utilities.
+* @module
+*/
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+function isBytes(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(item) {
+	if (!isBytes(item)) throw new Error("Uint8Array expected");
+}
+function abool(title, value) {
+	if (typeof value !== "boolean") throw new Error(title + " boolean expected, got " + value);
+}
+function numberToHexUnpadded(num) {
+	const hex = num.toString(16);
+	return hex.length & 1 ? "0" + hex : hex;
+}
+function hexToNumber(hex) {
+	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
+	return hex === "" ? _0n : BigInt("0x" + hex);
+}
+const hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+/**
+* Convert byte array to hex string. Uses built-in function, when available.
+* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+*/
+function bytesToHex(bytes) {
+	abytes(bytes);
+	if (hasHexBuiltin) return bytes.toHex();
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
+	return hex;
+}
+const asciis = {
+	_0: 48,
+	_9: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+function asciiToBase16(ch) {
+	if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0;
+	if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10);
+	if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10);
+}
+/**
+* Convert hex string to byte array. Uses built-in function, when available.
+* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+*/
+function hexToBytes(hex) {
+	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
+	if (hasHexBuiltin) return Uint8Array.fromHex(hex);
+	const hl = hex.length;
+	const al = hl / 2;
+	if (hl % 2) throw new Error("hex string expected, got unpadded hex of length " + hl);
+	const array = new Uint8Array(al);
+	for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+		const n1 = asciiToBase16(hex.charCodeAt(hi));
+		const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+		if (n1 === void 0 || n2 === void 0) {
+			const char = hex[hi] + hex[hi + 1];
+			throw new Error("hex string expected, got non-hex character \"" + char + "\" at index " + hi);
+		}
+		array[ai] = n1 * 16 + n2;
+	}
+	return array;
+}
+function bytesToNumberBE(bytes) {
+	return hexToNumber(bytesToHex(bytes));
+}
+function bytesToNumberLE(bytes) {
+	abytes(bytes);
+	return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+}
+function numberToBytesBE(n, len) {
+	return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+}
+function numberToBytesLE(n, len) {
+	return numberToBytesBE(n, len).reverse();
+}
+/**
+* Takes hex string or Uint8Array, converts to Uint8Array.
+* Validates output length.
+* Will throw error for other types.
+* @param title descriptive title for an error e.g. 'private key'
+* @param hex hex string or Uint8Array
+* @param expectedLength optional, will compare to result array's length
+* @returns
+*/
+function ensureBytes(title, hex, expectedLength) {
+	let res;
+	if (typeof hex === "string") try {
+		res = hexToBytes(hex);
+	} catch (e) {
+		throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
+	}
+	else if (isBytes(hex)) res = Uint8Array.from(hex);
+	else throw new Error(title + " must be hex string or Uint8Array");
+	const len = res.length;
+	if (typeof expectedLength === "number" && len !== expectedLength) throw new Error(title + " of length " + expectedLength + " expected, got " + len);
+	return res;
+}
+/**
+* Copies several Uint8Arrays into one.
+*/
+function concatBytes(...arrays) {
+	let sum = 0;
+	for (let i = 0; i < arrays.length; i++) {
+		const a = arrays[i];
+		abytes(a);
+		sum += a.length;
+	}
+	const res = new Uint8Array(sum);
+	for (let i = 0, pad = 0; i < arrays.length; i++) {
+		const a = arrays[i];
+		res.set(a, pad);
+		pad += a.length;
+	}
+	return res;
+}
+function equalBytes(a, b) {
+	if (a.length !== b.length) return false;
+	let diff = 0;
+	for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+	return diff === 0;
+}
+/**
+* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+*/
+function utf8ToBytes(str) {
+	if (typeof str !== "string") throw new Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(str));
+}
+const isPosBig = (n) => typeof n === "bigint" && _0n <= n;
+function inRange(n, min, max) {
+	return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+/**
+* Asserts min <= n < max. NOTE: It's < max and not <= max.
+* @example
+* aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
+*/
+function aInRange(title, n, min, max) {
+	if (!inRange(n, min, max)) throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
+}
+/**
+* Calculates amount of bits in a bigint.
+* Same as `n.toString(2).length`
+* TODO: merge with nLength in modular
+*/
+function bitLen(n) {
+	let len;
+	for (len = 0; n > _0n; n >>= _1n, len += 1);
+	return len;
+}
+/**
+* Calculate mask for N bits. Not using ** operator with bigints because of old engines.
+* Same as BigInt(`0b${Array(i).fill('1').join('')}`)
+*/
+const bitMask = (n) => (_1n << BigInt(n)) - _1n;
+const u8n = (len) => new Uint8Array(len);
+const u8fr = (arr) => Uint8Array.from(arr);
+/**
+* Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
+* @returns function that will call DRBG until 2nd arg returns something meaningful
+* @example
+*   const drbg = createHmacDRBG<Key>(32, 32, hmac);
+*   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
+*/
+function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+	if (typeof hashLen !== "number" || hashLen < 2) throw new Error("hashLen must be a number");
+	if (typeof qByteLen !== "number" || qByteLen < 2) throw new Error("qByteLen must be a number");
+	if (typeof hmacFn !== "function") throw new Error("hmacFn must be a function");
+	let v = u8n(hashLen);
+	let k = u8n(hashLen);
+	let i = 0;
+	const reset = () => {
+		v.fill(1);
+		k.fill(0);
+		i = 0;
+	};
+	const h = (...b) => hmacFn(k, v, ...b);
+	const reseed = (seed = u8n(0)) => {
+		k = h(u8fr([0]), seed);
+		v = h();
+		if (seed.length === 0) return;
+		k = h(u8fr([1]), seed);
+		v = h();
+	};
+	const gen = () => {
+		if (i++ >= 1e3) throw new Error("drbg: tried 1000 values");
+		let len = 0;
+		const out = [];
+		while (len < qByteLen) {
+			v = h();
+			const sl = v.slice();
+			out.push(sl);
+			len += v.length;
+		}
+		return concatBytes(...out);
+	};
+	const genUntil = (seed, pred) => {
+		reset();
+		reseed(seed);
+		let res = void 0;
+		while (!(res = pred(gen()))) reseed();
+		reset();
+		return res;
+	};
+	return genUntil;
+}
+const validatorFns = {
+	bigint: (val) => typeof val === "bigint",
+	function: (val) => typeof val === "function",
+	boolean: (val) => typeof val === "boolean",
+	string: (val) => typeof val === "string",
+	stringOrUint8Array: (val) => typeof val === "string" || isBytes(val),
+	isSafeInteger: (val) => Number.isSafeInteger(val),
+	array: (val) => Array.isArray(val),
+	field: (val, object) => object.Fp.isValid(val),
+	hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
+};
+function validateObject(object, validators, optValidators = {}) {
+	const checkField = (fieldName, type, isOptional) => {
+		const checkVal = validatorFns[type];
+		if (typeof checkVal !== "function") throw new Error("invalid validator function");
+		const val = object[fieldName];
+		if (isOptional && val === void 0) return;
+		if (!checkVal(val, object)) throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
+	};
+	for (const [fieldName, type] of Object.entries(validators)) checkField(fieldName, type, false);
+	for (const [fieldName, type] of Object.entries(optValidators)) checkField(fieldName, type, true);
+	return object;
+}
+/**
+* Memoizes (caches) computation result.
+* Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
+*/
+function memoized(fn) {
+	const map = /* @__PURE__ */ new WeakMap();
+	return (arg, ...args) => {
+		const val = map.get(arg);
+		if (val !== void 0) return val;
+		const computed = fn(arg, ...args);
+		map.set(arg, computed);
+		return computed;
+	};
+}
+//#endregion
+export { shrSH as $, createHasher as A, add3L as B, abytes$1 as C, aoutput as D, anumber as E, swap32IfBE as F, rotlBH as G, add4L as H, toBytes as I, rotlSL as J, rotlBL as K, u32 as L, createXOFer as M, randomBytes as N, clean as O, rotr as P, rotrSL as Q, add as R, Hash as S, ahash as T, add5H as U, add4H as V, add5L as W, rotrBL as X, rotrBH as Y, rotrSH as Z, numberToBytesBE as _, bitMask as a, utf8ToBytes as b, bytesToNumberLE as c, ensureBytes as d, shrSL as et, equalBytes as f, memoized as g, isBytes as h, bitLen as i, createView as j, concatBytes$1 as k, concatBytes as l, inRange as m, abool as n, bytesToHex as o, hexToBytes as p, rotlSH as q, abytes as r, bytesToNumberBE as s, aInRange as t, split as tt, createHmacDrbg as u, numberToBytesLE as v, aexists as w, validateObject as x, numberToHexUnpadded as y, add3H as z };

package/dist/wallet-DKVlrR1S.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { n as fetchAllBalances } from "./wallet-DSyht15_.js";
+export { fetchAllBalances };