@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/dist-BtIq4XFn.cjs

@@ -1,535 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-Br2OG8yv.cjs");
-const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
-let _midnight_ntwrk_ledger_v8 = require("@midnight-ntwrk/ledger-v8");
-let _subsquid_scale_codec = require("@subsquid/scale-codec");
-_subsquid_scale_codec = require_rolldown_runtime.__toESM(_subsquid_scale_codec);
-//#region ../../node_modules/@midnightntwrk/wallet-sdk-address-format/node_modules/@scure/base/index.js
-/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-function isArrayOf(isString, arr) {
-	if (!Array.isArray(arr)) return false;
-	if (arr.length === 0) return true;
-	if (isString) return arr.every((item) => typeof item === "string");
-	else return arr.every((item) => Number.isSafeInteger(item));
-}
-function afn(input) {
-	if (typeof input !== "function") throw new TypeError("function expected");
-	return true;
-}
-function astr(label, input) {
-	if (typeof input !== "string") throw new TypeError(`${label}: string expected`);
-	return true;
-}
-function anumber(n) {
-	if (typeof n !== "number") throw new TypeError(`number expected, got ${typeof n}`);
-	if (!Number.isSafeInteger(n)) throw new RangeError(`invalid integer: ${n}`);
-}
-function aArr(input) {
-	if (!Array.isArray(input)) throw new TypeError("array expected");
-}
-function astrArr(label, input) {
-	if (!isArrayOf(true, input)) throw new TypeError(`${label}: array of strings expected`);
-}
-function anumArr(label, input) {
-	if (!isArrayOf(false, input)) throw new TypeError(`${label}: array of numbers expected`);
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function chain(...args) {
-	const id = (a) => a;
-	const wrap = (a, b) => (c) => a(b(c));
-	return {
-		encode: args.map((x) => x.encode).reduceRight(wrap, id),
-		decode: args.map((x) => x.decode).reduce(wrap, id)
-	};
-}
-/**
-* Encodes integer radix representation to array of strings using alphabet and back.
-* Could also be array of strings.
-* @__NO_SIDE_EFFECTS__
-*/
-function alphabet(letters) {
-	const lettersA = typeof letters === "string" ? letters.split("") : letters;
-	const len = lettersA.length;
-	astrArr("alphabet", lettersA);
-	const indexes = new Map(lettersA.map((l, i) => [l, i]));
-	return {
-		encode: (digits) => {
-			aArr(digits);
-			return digits.map((i) => {
-				if (!Number.isSafeInteger(i) || i < 0 || i >= len) throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
-				return lettersA[i];
-			});
-		},
-		decode: (input) => {
-			aArr(input);
-			return input.map((letter) => {
-				astr("alphabet.decode", letter);
-				const i = indexes.get(letter);
-				if (i === void 0) throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
-				return i;
-			});
-		}
-	};
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function join(separator = "") {
-	astr("join", separator);
-	return {
-		encode: (from) => {
-			astrArr("join.decode", from);
-			return from.join(separator);
-		},
-		decode: (to) => {
-			astr("join.decode", to);
-			return to.split(separator);
-		}
-	};
-}
-/**
-* Pad strings array so it has integer number of bits
-* @__NO_SIDE_EFFECTS__
-*/
-function padding(bits, chr = "=") {
-	anumber(bits);
-	astr("padding", chr);
-	return {
-		encode(data) {
-			astrArr("padding.encode", data);
-			while (data.length * bits % 8) data.push(chr);
-			return data;
-		},
-		decode(input) {
-			astrArr("padding.decode", input);
-			let end = input.length;
-			if (end * bits % 8) throw new Error("padding: invalid, string should have whole number of bytes");
-			for (; end > 0 && input[end - 1] === chr; end--) if ((end - 1) * bits % 8 === 0) throw new Error("padding: invalid, string has too much padding");
-			return input.slice(0, end);
-		}
-	};
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function normalize(fn) {
-	afn(fn);
-	return {
-		encode: (from) => from,
-		decode: (to) => fn(to)
-	};
-}
-const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-const radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
-const powers = /* @__PURE__ */ (() => {
-	let res = [];
-	for (let i = 0; i < 40; i++) res.push(2 ** i);
-	return res;
-})();
-/**
-* Implemented with numbers, because BigInt is 5x slower
-*/
-function convertRadix2(data, from, to, padding) {
-	aArr(data);
-	if (from <= 0 || from > 32) throw new RangeError(`convertRadix2: wrong from=${from}`);
-	if (to <= 0 || to > 32) throw new RangeError(`convertRadix2: wrong to=${to}`);
-	if (/* @__PURE__ */ radix2carry(from, to) > 32) throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
-	let carry = 0;
-	let pos = 0;
-	const max = powers[from];
-	const mask = powers[to] - 1;
-	const res = [];
-	for (const n of data) {
-		anumber(n);
-		if (n >= max) 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);
-		const pow = powers[pos];
-		if (pow === void 0) throw new Error("invalid carry");
-		carry &= pow - 1;
-	}
-	carry = carry << to - pos & mask;
-	if (!padding && pos >= from) throw new Error("Excess padding");
-	if (!padding && carry > 0) throw new Error(`Non-zero padding: ${carry}`);
-	if (padding && pos > 0) res.push(carry >>> 0);
-	return res;
-}
-/**
-* If both bases are power of same number (like `2**8 <-> 2**64`),
-* there is a linear algorithm. For now we have implementation for power-of-two bases only.
-* @__NO_SIDE_EFFECTS__
-*/
-function radix2(bits, revPadding = false) {
-	anumber(bits);
-	if (bits <= 0 || bits > 32) throw new RangeError("radix2: bits should be in (0..32]");
-	if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32) throw new RangeError("radix2: carry overflow");
-	return {
-		encode: (bytes) => {
-			if (!isBytes(bytes)) throw new TypeError("radix2.encode input should be Uint8Array");
-			return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
-		},
-		decode: (digits) => {
-			anumArr("radix2.decode", digits);
-			return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
-		}
-	};
-}
-function unsafeWrapper(fn) {
-	afn(fn);
-	return function(...args) {
-		try {
-			return fn.apply(null, args);
-		} catch (e) {}
-	};
-}
-chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
-chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
-chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
-chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
-chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
-chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
-const hasBase64Builtin = typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function";
-hasBase64Builtin || chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
-chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
-hasBase64Builtin || chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
-chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
-const BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
-const POLYMOD_GENERATORS = [
-	996825010,
-	642813549,
-	513874426,
-	1027748829,
-	705979059
-];
-function bech32Polymod(pre) {
-	const b = pre >> 25;
-	let chk = (pre & 33554431) << 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) & 31;
-	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 % powers[30]], 30, 5, false));
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function genBech32(encoding) {
-	const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
-	const _words = radix2(5);
-	const fromWords = _words.decode;
-	const toWords = _words.encode;
-	const fromWordsUnsafe = unsafeWrapper(fromWords);
-	function encode(prefix, words, limit = 90) {
-		astr("bech32.encode prefix", prefix);
-		if (isBytes(words)) words = Array.from(words);
-		anumArr("bech32.encode", words);
-		const plen = prefix.length;
-		if (plen === 0) throw new TypeError(`Invalid prefix length ${plen}`);
-		const actualLength = plen + 7 + words.length;
-		if (limit !== false && actualLength > limit) throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
-		const lowered = prefix.toLowerCase();
-		const sum = bechChecksum(lowered, words, ENCODING_CONST);
-		return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
-	}
-	function decode(str, limit = 90) {
-		astr("bech32.decode input", str);
-		const slen = str.length;
-		if (slen < 8 || limit !== false && slen > limit) throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
-		const lowered = str.toLowerCase();
-		if (str !== lowered && str !== str.toUpperCase()) throw new Error(`String must be lowercase or uppercase`);
-		const sepIndex = lowered.lastIndexOf("1");
-		if (sepIndex === 0 || sepIndex === -1) throw new Error(`Letter "1" must be present between prefix and data only`);
-		const prefix = lowered.slice(0, sepIndex);
-		const data = lowered.slice(sepIndex + 1);
-		if (data.length < 6) throw new Error("Data must be at least 6 characters long");
-		const words = BECH_ALPHABET.decode(data).slice(0, -6);
-		const sum = bechChecksum(prefix, words, ENCODING_CONST);
-		if (!data.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)
-		};
-	}
-	function encodeFromBytes(prefix, bytes) {
-		return encode(prefix, toWords(bytes));
-	}
-	return {
-		encode,
-		decode,
-		encodeFromBytes,
-		decodeToBytes,
-		decodeUnsafe,
-		fromWords,
-		fromWordsUnsafe,
-		toWords
-	};
-}
-genBech32("bech32");
-/**
-* bech32m from BIP 350. Operates on words.
-* It was to mitigate `bech32` weaknesses.
-* For high-level helpers, check out {@link https://github.com/paulmillr/scure-btc-signer | scure-btc-signer}.
-* @example
-* Convert bytes to words, encode them with bech32m, then decode back.
-* ```ts
-* const words = bech32m.toWords(Uint8Array.from([1, 2, 3]));
-* const text = bech32m.encode('bc', words);
-* bech32m.decode(text);
-* ```
-*/
-const bech32m = /* @__PURE__ */ Object.freeze(genBech32("bech32m"));
-"".isWellFormed;
-typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function" || chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s) => {
-	if (typeof s !== "string" || s.length % 2 !== 0) throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
-	return s.toLowerCase();
-}));
-//#endregion
-//#region ../../node_modules/@midnightntwrk/wallet-sdk-address-format/dist/index.js
-require__polyfill_buffer_patch.init__polyfill_buffer_patch();
-const mainnet = Symbol("Mainnet");
-const NetworkId = { toString: (networkId) => {
-	return networkId === mainnet ? "mainnet" : networkId;
-} };
-const BLSScalar = {
-	bytes: 32,
-	modulus: BigInt("0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001")
-};
-const ScaleBigInt = {
-	encode: (data) => {
-		const sink = new _subsquid_scale_codec.ByteSink();
-		sink.compact(data);
-		return require__polyfill_buffer_patch.import_buffer.Buffer.from(sink.toBytes());
-	},
-	decode: (repr) => {
-		const src = new _subsquid_scale_codec.Src(repr);
-		const res = src.compact();
-		src.assertEOF();
-		return BigInt(res);
-	}
-};
-const Bech32mSymbol = Symbol("MidnightBech32m");
-var MidnightBech32m = class MidnightBech32m {
-	static prefix = "mn";
-	static encode(networkId, item) {
-		return item[Bech32mSymbol].encode(networkId, item);
-	}
-	static validateSegment(segmentName, segment) {
-		if (!/^[A-Za-z1-9-]+$/.test(segment)) throw new Error(`Segment ${segmentName}: ${segment} contains disallowed characters. Allowed characters are only numbers, latin letters and a hyphen`);
-	}
-	static parse(bech32string) {
-		const bech32parsed = bech32m.decodeToBytes(bech32string);
-		const [prefix, type, network = mainnet] = bech32parsed.prefix.split("_");
-		if (prefix != MidnightBech32m.prefix) throw new Error(`Expected prefix ${MidnightBech32m.prefix}`);
-		MidnightBech32m.validateSegment("type", type);
-		if (network != mainnet) MidnightBech32m.validateSegment("network", network);
-		return new MidnightBech32m(type, network, require__polyfill_buffer_patch.import_buffer.Buffer.from(bech32parsed.bytes));
-	}
-	type;
-	network;
-	data;
-	constructor(type, network, data) {
-		this.data = data;
-		this.network = network;
-		this.type = type;
-		MidnightBech32m.validateSegment("type", type);
-		if (network != mainnet) MidnightBech32m.validateSegment("network", network);
-	}
-	decode(tclass, networkId) {
-		return tclass[Bech32mSymbol].decode(networkId, this);
-	}
-	asString() {
-		const networkSegment = this.network == mainnet ? "" : `_${this.network}`;
-		return bech32m.encode(`${MidnightBech32m.prefix}_${this.type}${networkSegment}`, bech32m.toWords(this.data), false);
-	}
-	toString() {
-		return this.asString();
-	}
-};
-var Bech32mCodec = class Bech32mCodec {
-	type;
-	dataToBytes;
-	dataFromBytes;
-	constructor(type, dataToBytes, dataFromBytes) {
-		this.dataFromBytes = dataFromBytes;
-		this.dataToBytes = dataToBytes;
-		this.type = type;
-	}
-	encode(networkId, data) {
-		const context = Bech32mCodec.createContext(networkId);
-		return new MidnightBech32m(this.type, context.networkId, this.dataToBytes(data));
-	}
-	decode(networkId, repr) {
-		const context = Bech32mCodec.createContext(networkId);
-		if (repr.type != this.type) throw new Error(`Expected type ${this.type}, got ${repr.type}`);
-		if (context.networkId != repr.network) throw new Error(`Expected ${NetworkId.toString(context.networkId)} address, got ${NetworkId.toString(repr.network)} one`);
-		return this.dataFromBytes(repr.data);
-	}
-	static createContext(networkId) {
-		if (networkId === "mainnet") return { networkId: mainnet };
-		else return { networkId };
-	}
-};
-var ShieldedAddress = class ShieldedAddress {
-	static codec = new Bech32mCodec("shield-addr", (addr) => require__polyfill_buffer_patch.import_buffer.Buffer.concat([addr.coinPublicKey.data, addr.encryptionPublicKey.data]), (bytes) => {
-		return new ShieldedAddress(new ShieldedCoinPublicKey(bytes.subarray(0, ShieldedCoinPublicKey.keyLength)), new ShieldedEncryptionPublicKey(bytes.subarray(ShieldedCoinPublicKey.keyLength)));
-	});
-	static [Bech32mSymbol] = ShieldedAddress.codec;
-	[Bech32mSymbol] = ShieldedAddress.codec;
-	coinPublicKey;
-	encryptionPublicKey;
-	constructor(coinPublicKey, encryptionPublicKey) {
-		this.encryptionPublicKey = encryptionPublicKey;
-		this.coinPublicKey = coinPublicKey;
-	}
-	coinPublicKeyString() {
-		return this.coinPublicKey.data.toString("hex");
-	}
-	encryptionPublicKeyString() {
-		return this.encryptionPublicKey.data.toString("hex");
-	}
-	equals(other) {
-		return this.coinPublicKey.equals(other.coinPublicKey) && this.encryptionPublicKey.equals(other.encryptionPublicKey);
-	}
-};
-(class ShieldedEncryptionSecretKey {
-	static codec = new Bech32mCodec("shield-esk", (esk) => require__polyfill_buffer_patch.import_buffer.Buffer.from(esk.zswap.yesIKnowTheSecurityImplicationsOfThis_serialize()), (repr) => new ShieldedEncryptionSecretKey(_midnight_ntwrk_ledger_v8.EncryptionSecretKey.deserialize(repr)));
-	zswap;
-	constructor(zswap) {
-		this.zswap = zswap;
-	}
-});
-var ShieldedCoinPublicKey = class ShieldedCoinPublicKey {
-	static keyLength = 32;
-	static codec = new Bech32mCodec("shield-cpk", (cpk) => cpk.data, (repr) => new ShieldedCoinPublicKey(repr));
-	static fromHexString(hexString) {
-		return new ShieldedCoinPublicKey(require__polyfill_buffer_patch.import_buffer.Buffer.from(hexString, "hex"));
-	}
-	data;
-	constructor(data) {
-		this.data = data;
-		if (data.length != ShieldedCoinPublicKey.keyLength) throw new Error("Coin public key needs to be 32 bytes long");
-	}
-	toHexString() {
-		return this.data.toString("hex");
-	}
-	equals(other) {
-		return (typeof other === "string" ? ShieldedCoinPublicKey.fromHexString(other) : other).data.equals(this.data);
-	}
-};
-var ShieldedEncryptionPublicKey = class ShieldedEncryptionPublicKey {
-	static keyLength = 32;
-	static codec = new Bech32mCodec("shield-epk", (cpk) => cpk.data, (repr) => new ShieldedEncryptionPublicKey(repr));
-	static fromHexString(hexString) {
-		return new ShieldedEncryptionPublicKey(require__polyfill_buffer_patch.import_buffer.Buffer.from(hexString, "hex"));
-	}
-	data;
-	constructor(data) {
-		this.data = data;
-	}
-	toHexString() {
-		return this.data.toString("hex");
-	}
-	equals(other) {
-		return (typeof other === "string" ? ShieldedEncryptionPublicKey.fromHexString(other) : other).data.equals(this.data);
-	}
-};
-var UnshieldedAddress = class UnshieldedAddress {
-	data;
-	static keyLength = 32;
-	static codec = new Bech32mCodec("addr", (addr) => addr.data, (repr) => new UnshieldedAddress(repr));
-	static [Bech32mSymbol] = UnshieldedAddress.codec;
-	[Bech32mSymbol] = UnshieldedAddress.codec;
-	constructor(data) {
-		if (data.length != UnshieldedAddress.keyLength) throw new Error("Unshielded address needs to be 32 bytes long");
-		this.data = data;
-	}
-	get hexString() {
-		return this.data.toString("hex");
-	}
-	equals(other) {
-		return (typeof other === "string" ? new UnshieldedAddress(require__polyfill_buffer_patch.import_buffer.Buffer.from(other, "hex")) : other).data.equals(this.data);
-	}
-};
-var DustAddress = class DustAddress {
-	data;
-	static codec = new Bech32mCodec("dust", (daddr) => daddr.serialize(), (repr) => new DustAddress(ScaleBigInt.decode(repr)));
-	static [Bech32mSymbol] = DustAddress.codec;
-	[Bech32mSymbol] = DustAddress.codec;
-	static encodePublicKey = (networkId, publicKey) => {
-		return DustAddress.codec.encode(networkId, new DustAddress(publicKey)).asString();
-	};
-	constructor(data) {
-		if (data >= BLSScalar.modulus) throw new Error("Dust address is too large");
-		this.data = data;
-	}
-	serialize() {
-		return ScaleBigInt.encode(this.data);
-	}
-	equals(other) {
-		return (typeof other === "bigint" ? other : other.data) === this.data;
-	}
-};
-//#endregion
-Object.defineProperty(exports, "DustAddress", {
-	enumerable: true,
-	get: function() {
-		return DustAddress;
-	}
-});
-Object.defineProperty(exports, "MidnightBech32m", {
-	enumerable: true,
-	get: function() {
-		return MidnightBech32m;
-	}
-});
-Object.defineProperty(exports, "ShieldedAddress", {
-	enumerable: true,
-	get: function() {
-		return ShieldedAddress;
-	}
-});
-Object.defineProperty(exports, "ShieldedCoinPublicKey", {
-	enumerable: true,
-	get: function() {
-		return ShieldedCoinPublicKey;
-	}
-});
-Object.defineProperty(exports, "ShieldedEncryptionPublicKey", {
-	enumerable: true,
-	get: function() {
-		return ShieldedEncryptionPublicKey;
-	}
-});
-Object.defineProperty(exports, "UnshieldedAddress", {
-	enumerable: true,
-	get: function() {
-		return UnshieldedAddress;
-	}
-});