@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/_md-6zV2Cme0.cjs

@@ -0,0 +1,684 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto);
+//#region ../../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 rotr32H = (_h, l) => l;
+const rotr32L = (h, _l) => h;
+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/@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 = node_crypto && typeof node_crypto === "object" && "webcrypto" in node_crypto ? node_crypto.webcrypto : node_crypto && typeof node_crypto === "object" && "randomBytes" in node_crypto ? node_crypto : void 0;
+//#endregion
+//#region ../../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(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(b, ...lengths) {
+	if (!isBytes(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(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 u8. */
+function u8(arr) {
+	return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** 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;
+}
+/** Conditionally byte swap if on a big-endian platform */
+const swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n);
+/** 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;
+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;
+}
+/**
+* There is no setImmediate in browser and setTimeout is slow.
+* Call of async fn will return Promise, which will be fullfiled only on
+* next scheduler queue processing step and this is exactly what we need.
+*/
+const nextTick = async () => {};
+/**
+* Converts string to bytes using UTF8 encoding.
+* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+*/
+function utf8ToBytes(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(data);
+	abytes(data);
+	return data;
+}
+/**
+* Helper for KDFs: consumes uint8array or string.
+* When string is passed, does utf8 decoding, using TextDecoder.
+*/
+function kdfInputToBytes(data) {
+	if (typeof data === "string") data = utf8ToBytes(data);
+	abytes(data);
+	return data;
+}
+/** 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 checkOpts(defaults, opts) {
+	if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new Error("options should be object or undefined");
+	return Object.assign(defaults, opts);
+}
+/** 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 createOptHasher(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/@noble/hashes/esm/_md.js
+/**
+* Internal Merkle-Damgard hash utils.
+* @module
+*/
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+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(4294967295);
+	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);
+}
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+	return a & b ^ ~a & c;
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+	return a & b ^ a & c ^ b & c;
+}
+/**
+* Merkle-Damgard hash construction base class.
+* Could be used to create MD5, RIPEMD, SHA1, SHA2.
+*/
+var HashMD = class extends Hash {
+	constructor(blockLen, outputLen, padOffset, isLE) {
+		super();
+		this.finished = false;
+		this.length = 0;
+		this.pos = 0;
+		this.destroyed = false;
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.padOffset = padOffset;
+		this.isLE = isLE;
+		this.buffer = new Uint8Array(blockLen);
+		this.view = createView(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		data = toBytes(data);
+		abytes(data);
+		const { view, buffer, blockLen } = this;
+		const len = data.length;
+		for (let pos = 0; pos < len;) {
+			const take = Math.min(blockLen - this.pos, len - pos);
+			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) {
+		aexists(this);
+		aoutput(out, this);
+		this.finished = true;
+		const { buffer, view, blockLen, isLE } = this;
+		let { pos } = this;
+		buffer[pos++] = 128;
+		clean(this.buffer.subarray(pos));
+		if (this.padOffset > blockLen - pos) {
+			this.process(view, 0);
+			pos = 0;
+		}
+		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
+		setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+		this.process(view, 0);
+		const oview = createView(out);
+		const len = this.outputLen;
+		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.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		if (length % blockLen) to.buffer.set(buffer);
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/**
+* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+*/
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	3144134277,
+	1013904242,
+	2773480762,
+	1359893119,
+	2600822924,
+	528734635,
+	1541459225
+]);
+/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
+const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+	1779033703,
+	4089235720,
+	3144134277,
+	2227873595,
+	1013904242,
+	4271175723,
+	2773480762,
+	1595750129,
+	1359893119,
+	2917565137,
+	2600822924,
+	725511199,
+	528734635,
+	4215389547,
+	1541459225,
+	327033209
+]);
+//#endregion
+Object.defineProperty(exports, "Chi", {
+	enumerable: true,
+	get: function() {
+		return Chi;
+	}
+});
+Object.defineProperty(exports, "Hash", {
+	enumerable: true,
+	get: function() {
+		return Hash;
+	}
+});
+Object.defineProperty(exports, "HashMD", {
+	enumerable: true,
+	get: function() {
+		return HashMD;
+	}
+});
+Object.defineProperty(exports, "Maj", {
+	enumerable: true,
+	get: function() {
+		return Maj;
+	}
+});
+Object.defineProperty(exports, "SHA256_IV", {
+	enumerable: true,
+	get: function() {
+		return SHA256_IV;
+	}
+});
+Object.defineProperty(exports, "SHA512_IV", {
+	enumerable: true,
+	get: function() {
+		return SHA512_IV;
+	}
+});
+Object.defineProperty(exports, "abytes", {
+	enumerable: true,
+	get: function() {
+		return abytes;
+	}
+});
+Object.defineProperty(exports, "add", {
+	enumerable: true,
+	get: function() {
+		return add;
+	}
+});
+Object.defineProperty(exports, "add3H", {
+	enumerable: true,
+	get: function() {
+		return add3H;
+	}
+});
+Object.defineProperty(exports, "add3L", {
+	enumerable: true,
+	get: function() {
+		return add3L;
+	}
+});
+Object.defineProperty(exports, "add4H", {
+	enumerable: true,
+	get: function() {
+		return add4H;
+	}
+});
+Object.defineProperty(exports, "add4L", {
+	enumerable: true,
+	get: function() {
+		return add4L;
+	}
+});
+Object.defineProperty(exports, "add5H", {
+	enumerable: true,
+	get: function() {
+		return add5H;
+	}
+});
+Object.defineProperty(exports, "add5L", {
+	enumerable: true,
+	get: function() {
+		return add5L;
+	}
+});
+Object.defineProperty(exports, "aexists", {
+	enumerable: true,
+	get: function() {
+		return aexists;
+	}
+});
+Object.defineProperty(exports, "ahash", {
+	enumerable: true,
+	get: function() {
+		return ahash;
+	}
+});
+Object.defineProperty(exports, "anumber", {
+	enumerable: true,
+	get: function() {
+		return anumber;
+	}
+});
+Object.defineProperty(exports, "aoutput", {
+	enumerable: true,
+	get: function() {
+		return aoutput;
+	}
+});
+Object.defineProperty(exports, "bytesToHex", {
+	enumerable: true,
+	get: function() {
+		return bytesToHex;
+	}
+});
+Object.defineProperty(exports, "checkOpts", {
+	enumerable: true,
+	get: function() {
+		return checkOpts;
+	}
+});
+Object.defineProperty(exports, "clean", {
+	enumerable: true,
+	get: function() {
+		return clean;
+	}
+});
+Object.defineProperty(exports, "concatBytes", {
+	enumerable: true,
+	get: function() {
+		return concatBytes;
+	}
+});
+Object.defineProperty(exports, "createHasher", {
+	enumerable: true,
+	get: function() {
+		return createHasher;
+	}
+});
+Object.defineProperty(exports, "createOptHasher", {
+	enumerable: true,
+	get: function() {
+		return createOptHasher;
+	}
+});
+Object.defineProperty(exports, "createView", {
+	enumerable: true,
+	get: function() {
+		return createView;
+	}
+});
+Object.defineProperty(exports, "fromBig", {
+	enumerable: true,
+	get: function() {
+		return fromBig;
+	}
+});
+Object.defineProperty(exports, "hexToBytes", {
+	enumerable: true,
+	get: function() {
+		return hexToBytes;
+	}
+});
+Object.defineProperty(exports, "kdfInputToBytes", {
+	enumerable: true,
+	get: function() {
+		return kdfInputToBytes;
+	}
+});
+Object.defineProperty(exports, "nextTick", {
+	enumerable: true,
+	get: function() {
+		return nextTick;
+	}
+});
+Object.defineProperty(exports, "randomBytes", {
+	enumerable: true,
+	get: function() {
+		return randomBytes;
+	}
+});
+Object.defineProperty(exports, "rotr", {
+	enumerable: true,
+	get: function() {
+		return rotr;
+	}
+});
+Object.defineProperty(exports, "rotr32H", {
+	enumerable: true,
+	get: function() {
+		return rotr32H;
+	}
+});
+Object.defineProperty(exports, "rotr32L", {
+	enumerable: true,
+	get: function() {
+		return rotr32L;
+	}
+});
+Object.defineProperty(exports, "rotrBH", {
+	enumerable: true,
+	get: function() {
+		return rotrBH;
+	}
+});
+Object.defineProperty(exports, "rotrBL", {
+	enumerable: true,
+	get: function() {
+		return rotrBL;
+	}
+});
+Object.defineProperty(exports, "rotrSH", {
+	enumerable: true,
+	get: function() {
+		return rotrSH;
+	}
+});
+Object.defineProperty(exports, "rotrSL", {
+	enumerable: true,
+	get: function() {
+		return rotrSL;
+	}
+});
+Object.defineProperty(exports, "shrSH", {
+	enumerable: true,
+	get: function() {
+		return shrSH;
+	}
+});
+Object.defineProperty(exports, "shrSL", {
+	enumerable: true,
+	get: function() {
+		return shrSL;
+	}
+});
+Object.defineProperty(exports, "split", {
+	enumerable: true,
+	get: function() {
+		return split;
+	}
+});
+Object.defineProperty(exports, "swap32IfBE", {
+	enumerable: true,
+	get: function() {
+		return swap32IfBE;
+	}
+});
+Object.defineProperty(exports, "swap8IfBE", {
+	enumerable: true,
+	get: function() {
+		return swap8IfBE;
+	}
+});
+Object.defineProperty(exports, "toBytes", {
+	enumerable: true,
+	get: function() {
+		return toBytes;
+	}
+});
+Object.defineProperty(exports, "u32", {
+	enumerable: true,
+	get: function() {
+		return u32;
+	}
+});
+Object.defineProperty(exports, "u8", {
+	enumerable: true,
+	get: function() {
+		return u8;
+	}
+});
+Object.defineProperty(exports, "utf8ToBytes", {
+	enumerable: true,
+	get: function() {
+		return utf8ToBytes;
+	}
+});