@d9-network/spec 1.1.0 → 1.2.2

package/dist/index.mjs

@@ -2,16 +2,15 @@ import { t as __export } from "./chunk-7P6ASYW6-kh065yQz.mjs";
 import { _Enum } from "polkadot-api";
 import { generateMnemonic as generateMnemonic$1, mnemonicToMiniSecret as mnemonicToMiniSecret$1, ss58Decode, ss58Encode, validateMnemonic as validateMnemonic$1 } from "@polkadot-labs/hdkd-helpers";
 import { sr25519CreateDerive, withNetworkAccount } from "@polkadot-labs/hdkd";
-import { getPolkadotSigner } from "@polkadot-api/signer";
 
 //#region ../../node_modules/.bun/@polkadot-api+descriptors@file+packages+spec+.papi+descriptors+ec2463ed5a666297/node_modules/@polkadot-api/descriptors/dist/index.mjs
 var table = new Uint8Array(128);
 for (let i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;
-var toBinary = (base64) => {
-	const n = base64.length, bytes = new Uint8Array((n - Number(base64[n - 1] === "=") - Number(base64[n - 2] === "=")) * 3 / 4 | 0);
+var toBinary = (base64$1) => {
+	const n = base64$1.length, bytes = new Uint8Array((n - Number(base64$1[n - 1] === "=") - Number(base64$1[n - 2] === "=")) * 3 / 4 | 0);
 	for (let i2 = 0, j = 0; i2 < n;) {
-		const c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)];
-		const c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)];
+		const c0 = table[base64$1.charCodeAt(i2++)], c1 = table[base64$1.charCodeAt(i2++)];
+		const c2 = table[base64$1.charCodeAt(i2++)], c3 = table[base64$1.charCodeAt(i2++)];
 		bytes[j++] = c0 << 2 | c1 >> 4;
 		bytes[j++] = c1 << 4 | c2 >> 2;
 		bytes[j++] = c2 << 6 | c3;
@@ -7645,17 +7644,17 @@ function isHexString(input) {
 	const s = input.slice(2);
 	return s.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(s);
 }
-function hexToBytes(hex) {
-	if (!isHexString(hex)) throw new Error("Invalid hex string");
-	const s = hex.slice(2);
+function hexToBytes(hex$1) {
+	if (!isHexString(hex$1)) throw new Error("Invalid hex string");
+	const s = hex$1.slice(2);
 	const out = new Uint8Array(s.length / 2);
 	for (let i = 0; i < out.length; i++) out[i] = Number.parseInt(s.slice(i * 2, i * 2 + 2), 16);
 	return out;
 }
 function bytesToHex(bytes) {
-	let hex = "";
-	for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
-	return `0x${hex}`;
+	let hex$1 = "";
+	for (let i = 0; i < bytes.length; i++) hex$1 += bytes[i].toString(16).padStart(2, "0");
+	return `0x${hex$1}`;
 }
 
 //#endregion
@@ -7698,6 +7697,2535 @@ function sr25519AddressFromSecretKeyHex(secretKeyHex, ss58Format) {
 	return sr25519AddressFromKeypair(sr25519KeypairFromMiniSecret(secretKey), ss58Format);
 }
 
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+utils@0.2.0/node_modules/@polkadot-api/utils/dist/esm/hex.mjs
+const HEX_STR = "0123456789abcdef";
+function toHex(bytes) {
+	const result = new Array(bytes.length + 1);
+	result[0] = "0x";
+	for (let i = 0; i < bytes.length;) {
+		const b = bytes[i++];
+		result[i] = HEX_STR[b >> 4] + HEX_STR[b & 15];
+	}
+	return result.join("");
+}
+const HEX_MAP$1 = {
+	0: 0,
+	1: 1,
+	2: 2,
+	3: 3,
+	4: 4,
+	5: 5,
+	6: 6,
+	7: 7,
+	8: 8,
+	9: 9,
+	a: 10,
+	b: 11,
+	c: 12,
+	d: 13,
+	e: 14,
+	f: 15,
+	A: 10,
+	B: 11,
+	C: 12,
+	D: 13,
+	E: 14,
+	F: 15
+};
+function fromHex$1(hexString) {
+	const isOdd = hexString.length % 2;
+	const base = (hexString[1] === "x" ? 2 : 0) + isOdd;
+	const nBytes = (hexString.length - base) / 2 + isOdd;
+	const bytes = new Uint8Array(nBytes);
+	if (isOdd) bytes[0] = 0 | HEX_MAP$1[hexString[2]];
+	for (let i = 0; i < nBytes;) {
+		const idx = base + i * 2;
+		const a = HEX_MAP$1[hexString[idx]];
+		const b = HEX_MAP$1[hexString[idx + 1]];
+		bytes[isOdd + i++] = a << 4 | b;
+	}
+	return bytes;
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+utils@0.2.0/node_modules/@polkadot-api/utils/dist/esm/mergeUint8.mjs
+const mergeUint8$1 = (...i) => {
+	const inputs = Array.isArray(i[0]) ? i[0] : i;
+	const totalLen = inputs.reduce((acc, a) => acc + a.byteLength, 0);
+	const result = new Uint8Array(totalLen);
+	for (let idx = 0, at = 0; idx < inputs.length; idx++) {
+		const current = inputs[idx];
+		result.set(current, at);
+		at += current.byteLength;
+	}
+	return result;
+};
+
+//#endregion
+//#region ../../node_modules/.bun/scale-ts@1.6.1/node_modules/scale-ts/dist/scale-ts.js
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+	__defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+	return value;
+};
+var HEX_MAP = {
+	0: 0,
+	1: 1,
+	2: 2,
+	3: 3,
+	4: 4,
+	5: 5,
+	6: 6,
+	7: 7,
+	8: 8,
+	9: 9,
+	a: 10,
+	b: 11,
+	c: 12,
+	d: 13,
+	e: 14,
+	f: 15,
+	A: 10,
+	B: 11,
+	C: 12,
+	D: 13,
+	E: 14,
+	F: 15
+};
+function fromHex(hexString) {
+	const isOdd = hexString.length % 2;
+	const base = (hexString[1] === "x" ? 2 : 0) + isOdd;
+	const nBytes = (hexString.length - base) / 2 + isOdd;
+	const bytes = new Uint8Array(nBytes);
+	if (isOdd) bytes[0] = 0 | HEX_MAP[hexString[2]];
+	for (let i = 0; i < nBytes;) {
+		const idx = base + i * 2;
+		const a = HEX_MAP[hexString[idx]];
+		const b = HEX_MAP[hexString[idx + 1]];
+		bytes[isOdd + i++] = a << 4 | b;
+	}
+	return bytes;
+}
+var InternalUint8Array = class extends Uint8Array {
+	constructor(buffer) {
+		super(buffer);
+		__publicField$1(this, "i", 0);
+		__publicField$1(this, "v");
+		this.v = new DataView(buffer);
+	}
+};
+var toInternalBytes = (fn) => (buffer) => fn(buffer instanceof InternalUint8Array ? buffer : new InternalUint8Array(buffer instanceof Uint8Array ? buffer.buffer : typeof buffer === "string" ? fromHex(buffer).buffer : buffer));
+var mergeUint8 = (inputs) => {
+	const len = inputs.length;
+	let totalLen = 0;
+	for (let i = 0; i < len; i++) totalLen += inputs[i].length;
+	const result = new Uint8Array(totalLen);
+	for (let idx = 0, at = 0; idx < len; idx++) {
+		const current = inputs[idx];
+		result.set(current, at);
+		at += current.byteLength;
+	}
+	return result;
+};
+function mapObject(input, mapper) {
+	const keys = Object.keys(input);
+	const len = keys.length;
+	const result = {};
+	for (let i = 0; i < len; i++) {
+		const key = keys[i];
+		result[key] = mapper(input[key], key);
+	}
+	return result;
+}
+var createCodec = (encoder, decoder) => {
+	const result = [encoder, decoder];
+	result.enc = encoder;
+	result.dec = decoder;
+	return result;
+};
+var enhanceEncoder = (encoder, mapper) => (value) => encoder(mapper(value));
+var enhanceDecoder = (decoder, mapper) => (value) => mapper(decoder(value));
+var enhanceCodec = ([encoder, decoder], toFrom, fromTo) => createCodec(enhanceEncoder(encoder, toFrom), enhanceDecoder(decoder, fromTo));
+function decodeInt(nBytes, getter) {
+	return toInternalBytes((bytes) => {
+		const result = bytes.v[getter](bytes.i, true);
+		bytes.i += nBytes;
+		return result;
+	});
+}
+function encodeInt(nBytes, setter) {
+	return (input) => {
+		const result = new Uint8Array(nBytes);
+		new DataView(result.buffer)[setter](0, input, true);
+		return result;
+	};
+}
+function intCodec(nBytes, getter, setter) {
+	return createCodec(encodeInt(nBytes, setter), decodeInt(nBytes, getter));
+}
+var u8 = intCodec(1, "getUint8", "setUint8");
+var u16 = intCodec(2, "getUint16", "setUint16");
+var u32$1 = intCodec(4, "getUint32", "setUint32");
+var u64 = intCodec(8, "getBigUint64", "setBigUint64");
+var i8 = intCodec(1, "getInt8", "setInt8");
+var i16 = intCodec(2, "getInt16", "setInt16");
+var i32 = intCodec(4, "getInt32", "setInt32");
+var i64 = intCodec(8, "getBigInt64", "setBigInt64");
+var x128Enc = (value) => {
+	const result = new Uint8Array(16);
+	const dv = new DataView(result.buffer);
+	dv.setBigInt64(0, value, true);
+	dv.setBigInt64(8, value >> 64n, true);
+	return result;
+};
+var create128Dec = (method) => toInternalBytes((input) => {
+	const { v, i } = input;
+	const right = v.getBigUint64(i, true);
+	const left = v[method](i + 8, true);
+	input.i += 16;
+	return left << 64n | right;
+});
+var u128 = createCodec(x128Enc, create128Dec("getBigUint64"));
+var i128 = createCodec(x128Enc, create128Dec("getBigInt64"));
+var x256Enc = (value) => {
+	const result = new Uint8Array(32);
+	const dv = new DataView(result.buffer);
+	dv.setBigInt64(0, value, true);
+	dv.setBigInt64(8, value >> 64n, true);
+	dv.setBigInt64(16, value >> 128n, true);
+	dv.setBigInt64(24, value >> 192n, true);
+	return result;
+};
+var create256Dec = (method) => toInternalBytes((input) => {
+	let result = input.v.getBigUint64(input.i, true);
+	input.i += 8;
+	result |= input.v.getBigUint64(input.i, true) << 64n;
+	input.i += 8;
+	result |= input.v.getBigUint64(input.i, true) << 128n;
+	input.i += 8;
+	result |= input.v[method](input.i, true) << 192n;
+	input.i += 8;
+	return result;
+});
+var u256 = createCodec(x256Enc, create256Dec("getBigUint64"));
+var i256 = createCodec(x256Enc, create256Dec("getBigInt64"));
+var bool = enhanceCodec(u8, (value) => value ? 1 : 0, Boolean);
+var decoders = [
+	u8[1],
+	u16[1],
+	u32$1[1]
+];
+var compactDec = toInternalBytes((bytes) => {
+	const init = bytes[bytes.i];
+	const kind = init & 3;
+	if (kind < 3) return decoders[kind](bytes) >>> 2;
+	const nBytes = (init >>> 2) + 4;
+	bytes.i++;
+	let result = 0n;
+	const nU64 = nBytes / 8 | 0;
+	let shift = 0n;
+	for (let i = 0; i < nU64; i++) {
+		result = u64[1](bytes) << shift | result;
+		shift += 64n;
+	}
+	let nReminders = nBytes % 8;
+	if (nReminders > 3) {
+		result = BigInt(u32$1[1](bytes)) << shift | result;
+		shift += 32n;
+		nReminders -= 4;
+	}
+	if (nReminders > 1) {
+		result = BigInt(u16[1](bytes)) << shift | result;
+		shift += 16n;
+		nReminders -= 2;
+	}
+	if (nReminders) result = BigInt(u8[1](bytes)) << shift | result;
+	return result;
+});
+var MIN_U64 = 1n << 56n;
+var MIN_U32 = 1 << 24;
+var MIN_U16 = 256;
+var U32_MASK = 4294967295n;
+var SINGLE_BYTE_MODE_LIMIT = 64;
+var TWO_BYTE_MODE_LIMIT = 16384;
+var FOUR_BYTE_MODE_LIMIT = 1 << 30;
+var compactEnc = (input) => {
+	if (input < 0) throw new Error(`Wrong compact input (${input})`);
+	const nInput = Number(input) << 2;
+	if (input < SINGLE_BYTE_MODE_LIMIT) return u8[0](nInput);
+	if (input < TWO_BYTE_MODE_LIMIT) return u16[0](nInput | 1);
+	if (input < FOUR_BYTE_MODE_LIMIT) return u32$1[0](nInput | 2);
+	let buffers = [new Uint8Array(1)];
+	let bigValue = BigInt(input);
+	while (bigValue >= MIN_U64) {
+		buffers.push(u64[0](bigValue));
+		bigValue >>= 64n;
+	}
+	if (bigValue >= MIN_U32) {
+		buffers.push(u32$1[0](Number(bigValue & U32_MASK)));
+		bigValue >>= 32n;
+	}
+	let smValue = Number(bigValue);
+	if (smValue >= MIN_U16) {
+		buffers.push(u16[0](smValue));
+		smValue >>= 16;
+	}
+	smValue && buffers.push(u8[0](smValue));
+	const result = mergeUint8(buffers);
+	result[0] = result.length - 5 << 2 | 3;
+	return result;
+};
+var compact = createCodec(compactEnc, compactDec);
+var textEncoder = new TextEncoder();
+var strEnc = (str2) => {
+	const val = textEncoder.encode(str2);
+	return mergeUint8([compact.enc(val.length), val]);
+};
+var textDecoder = new TextDecoder();
+var str = createCodec(strEnc, toInternalBytes((bytes) => {
+	let nElements = compact.dec(bytes);
+	const dv = new DataView(bytes.buffer, bytes.i, nElements);
+	bytes.i += nElements;
+	return textDecoder.decode(dv);
+}));
+var noop = () => {};
+var emptyArr = new Uint8Array(0);
+var _void$1 = createCodec(() => emptyArr, noop);
+var BytesEnc = (nBytes) => nBytes === void 0 ? (bytes) => mergeUint8([compact.enc(bytes.length), bytes]) : (bytes) => bytes.length === nBytes ? bytes : bytes.slice(0, nBytes);
+var BytesDec = (nBytes) => toInternalBytes((bytes) => {
+	const len = nBytes === void 0 ? compact.dec(bytes) : nBytes !== Infinity ? nBytes : bytes.byteLength - bytes.i;
+	const result = new Uint8Array(bytes.buffer.slice(bytes.i, bytes.i + len));
+	bytes.i += len;
+	return result;
+});
+var Bytes = (nBytes) => createCodec(BytesEnc(nBytes), BytesDec(nBytes));
+Bytes.enc = BytesEnc;
+Bytes.dec = BytesDec;
+var enumEnc = (inner, x) => {
+	const keys = Object.keys(inner);
+	const mappedKeys = new Map(x?.map((actualIdx, idx) => [keys[idx], actualIdx]) ?? keys.map((key, idx) => [key, idx]));
+	const getKey = (key) => mappedKeys.get(key);
+	return ({ tag, value }) => mergeUint8([u8.enc(getKey(tag)), inner[tag](value)]);
+};
+var enumDec = (inner, x) => {
+	const keys = Object.keys(inner);
+	const mappedKeys = new Map(x?.map((actualIdx, idx) => [actualIdx, keys[idx]]) ?? keys.map((key, idx) => [idx, key]));
+	return toInternalBytes((bytes) => {
+		const idx = u8.dec(bytes);
+		const tag = mappedKeys.get(idx);
+		const innerDecoder = inner[tag];
+		return {
+			tag,
+			value: innerDecoder(bytes)
+		};
+	});
+};
+var Enum$1 = (inner, ...args) => createCodec(enumEnc(mapObject(inner, ([encoder]) => encoder), ...args), enumDec(mapObject(inner, ([, decoder]) => decoder), ...args));
+Enum$1.enc = enumEnc;
+Enum$1.dec = enumDec;
+var OptionDec = (inner) => toInternalBytes((bytes) => u8[1](bytes) > 0 ? inner(bytes) : void 0);
+var OptionEnc = (inner) => (value) => {
+	const result = new Uint8Array(1);
+	if (value === void 0) return result;
+	result[0] = 1;
+	return mergeUint8([result, inner(value)]);
+};
+var Option = (inner) => createCodec(OptionEnc(inner[0]), OptionDec(inner[1]));
+Option.enc = OptionEnc;
+Option.dec = OptionDec;
+var ResultDec = (okDecoder, koDecoder) => toInternalBytes((bytes) => {
+	const success = u8[1](bytes) === 0;
+	return {
+		success,
+		value: (success ? okDecoder : koDecoder)(bytes)
+	};
+});
+var ResultEnc = (okEncoder, koEncoder) => ({ success, value }) => mergeUint8([u8[0](success ? 0 : 1), (success ? okEncoder : koEncoder)(value)]);
+var Result = (okCodec, koCodec) => createCodec(ResultEnc(okCodec[0], koCodec[0]), ResultDec(okCodec[1], koCodec[1]));
+Result.dec = ResultDec;
+Result.enc = ResultEnc;
+var TupleDec = (...decoders2) => toInternalBytes((bytes) => decoders2.map((decoder) => decoder(bytes)));
+var TupleEnc = (...encoders) => (values) => mergeUint8(encoders.map((enc, idx) => enc(values[idx])));
+var Tuple = (...codecs) => createCodec(TupleEnc(...codecs.map(([encoder]) => encoder)), TupleDec(...codecs.map(([, decoder]) => decoder)));
+Tuple.enc = TupleEnc;
+Tuple.dec = TupleDec;
+var StructEnc = (encoders) => {
+	const keys = Object.keys(encoders);
+	return enhanceEncoder(Tuple.enc(...Object.values(encoders)), (input) => keys.map((k) => input[k]));
+};
+var StructDec = (decoders2) => {
+	const keys = Object.keys(decoders2);
+	return enhanceDecoder(Tuple.dec(...Object.values(decoders2)), (tuple) => Object.fromEntries(tuple.map((value, idx) => [keys[idx], value])));
+};
+var Struct = (codecs) => createCodec(StructEnc(mapObject(codecs, (x) => x[0])), StructDec(mapObject(codecs, (x) => x[1])));
+Struct.enc = StructEnc;
+Struct.dec = StructDec;
+var VectorEnc = (inner, size) => size >= 0 ? (value) => mergeUint8(value.map(inner)) : (value) => mergeUint8([compact.enc(value.length), mergeUint8(value.map(inner))]);
+var VectorDec = (getter, size) => toInternalBytes((bytes) => {
+	const nElements = size >= 0 ? size : compact.dec(bytes);
+	const result = new Array(nElements);
+	for (let i = 0; i < nElements; i++) result[i] = getter(bytes);
+	return result;
+});
+var Vector = (inner, size) => createCodec(VectorEnc(inner[0], size), VectorDec(inner[1], size));
+Vector.enc = VectorEnc;
+Vector.dec = VectorDec;
+
+//#endregion
+//#region ../../node_modules/.bun/@scure+base@2.0.0/node_modules/@scure/base/index.js
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes$2(a) {
+	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+/** Asserts something is Uint8Array. */
+function abytes$1(b) {
+	if (!isBytes$2(b)) throw new Error("Uint8Array expected");
+}
+function isArrayOf(isString, arr$1) {
+	if (!Array.isArray(arr$1)) return false;
+	if (arr$1.length === 0) return true;
+	if (isString) return arr$1.every((item) => typeof item === "string");
+	else return arr$1.every((item) => Number.isSafeInteger(item));
+}
+function afn(input) {
+	if (typeof input !== "function") throw new Error("function expected");
+	return true;
+}
+function astr(label, input) {
+	if (typeof input !== "string") throw new Error(`${label}: string expected`);
+	return true;
+}
+function anumber$1(n) {
+	if (!Number.isSafeInteger(n)) throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+	if (!Array.isArray(input)) throw new Error("array expected");
+}
+function astrArr(label, input) {
+	if (!isArrayOf(true, input)) throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+	if (!isArrayOf(false, input)) throw new Error(`${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$1(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)
+	};
+}
+/**
+* Slow: O(n^2) time complexity
+*/
+function convertRadix(data, from, to) {
+	if (from < 2) throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+	if (to < 2) throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+	aArr(data);
+	if (!data.length) return [];
+	let pos = 0;
+	const res = [];
+	const digits = Array.from(data, (d) => {
+		anumber$1(d);
+		if (d < 0 || d >= from) throw new Error(`invalid integer: ${d}`);
+		return d;
+	});
+	const dlen = digits.length;
+	while (true) {
+		let carry = 0;
+		let done = true;
+		for (let i = pos; i < dlen; i++) {
+			const digit = digits[i];
+			const fromCarry = from * carry;
+			const digitBase = fromCarry + digit;
+			if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) throw new Error("convertRadix: carry overflow");
+			const div = digitBase / to;
+			carry = digitBase % to;
+			const rounded = Math.floor(div);
+			digits[i] = rounded;
+			if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase) throw new Error("convertRadix: carry overflow");
+			if (!done) continue;
+			else if (!rounded) 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 === 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$1) {
+	aArr(data);
+	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 (/* @__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$1(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$1 && pos >= from) throw new Error("Excess padding");
+	if (!padding$1 && carry > 0) throw new Error(`Non-zero padding: ${carry}`);
+	if (padding$1 && pos > 0) res.push(carry >>> 0);
+	return res;
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function radix(num) {
+	anumber$1(num);
+	const _256 = 2 ** 8;
+	return {
+		encode: (bytes) => {
+			if (!isBytes$2(bytes)) throw new Error("radix.encode input should be Uint8Array");
+			return convertRadix(Array.from(bytes), _256, num);
+		},
+		decode: (digits) => {
+			anumArr("radix.decode", digits);
+			return Uint8Array.from(convertRadix(digits, num, _256));
+		}
+	};
+}
+/**
+* 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$1(bits);
+	if (bits <= 0 || bits > 32) throw new Error("radix2: bits should be in (0..32]");
+	if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32) throw new Error("radix2: carry overflow");
+	return {
+		encode: (bytes) => {
+			if (!isBytes$2(bytes)) throw new Error("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) {}
+	};
+}
+/**
+* base16 encoding from RFC 4648.
+* @example
+* ```js
+* base16.encode(Uint8Array.from([0x12, 0xab]));
+* // => '12AB'
+* ```
+*/
+const base16 = chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
+/**
+* base32 encoding from RFC 4648. Has padding.
+* Use `base32nopad` for unpadded version.
+* Also check out `base32hex`, `base32hexnopad`, `base32crockford`.
+* @example
+* ```js
+* base32.encode(Uint8Array.from([0x12, 0xab]));
+* // => 'CKVQ===='
+* base32.decode('CKVQ====');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base32 = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
+/**
+* base32 encoding from RFC 4648. No padding.
+* Use `base32` for padded version.
+* Also check out `base32hex`, `base32hexnopad`, `base32crockford`.
+* @example
+* ```js
+* base32nopad.encode(Uint8Array.from([0x12, 0xab]));
+* // => 'CKVQ'
+* base32nopad.decode('CKVQ');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base32nopad = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
+/**
+* base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.
+* Use `base32hexnopad` for unpadded version.
+* @example
+* ```js
+* base32hex.encode(Uint8Array.from([0x12, 0xab]));
+* // => '2ALG===='
+* base32hex.decode('2ALG====');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base32hex = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
+/**
+* base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.
+* Use `base32hex` for padded version.
+* @example
+* ```js
+* base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));
+* // => '2ALG'
+* base32hexnopad.decode('2ALG');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base32hexnopad = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
+/**
+* base32 encoding from RFC 4648. Doug Crockford's version.
+* https://www.crockford.com/base32.html
+* @example
+* ```js
+* base32crockford.encode(Uint8Array.from([0x12, 0xab]));
+* // => '2ANG'
+* base32crockford.decode('2ANG');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base32crockford = chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+const hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+const decodeBase64Builtin = (s, isUrl) => {
+	astr("base64", s);
+	const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+	const alphabet$1 = isUrl ? "base64url" : "base64";
+	if (s.length > 0 && !re.test(s)) throw new Error("invalid base64");
+	return Uint8Array.fromBase64(s, {
+		alphabet: alphabet$1,
+		lastChunkHandling: "strict"
+	});
+};
+/**
+* base64 from RFC 4648. Padded.
+* Use `base64nopad` for unpadded version.
+* Also check out `base64url`, `base64urlnopad`.
+* Falls back to built-in function, when available.
+* @example
+* ```js
+* base64.encode(Uint8Array.from([0x12, 0xab]));
+* // => 'Eqs='
+* base64.decode('Eqs=');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base64 = hasBase64Builtin ? {
+	encode(b) {
+		abytes$1(b);
+		return b.toBase64();
+	},
+	decode(s) {
+		return decodeBase64Builtin(s, false);
+	}
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
+/**
+* base64 from RFC 4648. No padding.
+* Use `base64` for padded version.
+* @example
+* ```js
+* base64nopad.encode(Uint8Array.from([0x12, 0xab]));
+* // => 'Eqs'
+* base64nopad.decode('Eqs');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base64nopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
+/**
+* base64 from RFC 4648, using URL-safe alphabet. Padded.
+* Use `base64urlnopad` for unpadded version.
+* Falls back to built-in function, when available.
+* @example
+* ```js
+* base64url.encode(Uint8Array.from([0x12, 0xab]));
+* // => 'Eqs='
+* base64url.decode('Eqs=');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base64url = hasBase64Builtin ? {
+	encode(b) {
+		abytes$1(b);
+		return b.toBase64({ alphabet: "base64url" });
+	},
+	decode(s) {
+		return decodeBase64Builtin(s, true);
+	}
+} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
+/**
+* base64 from RFC 4648, using URL-safe alphabet. No padding.
+* Use `base64url` for padded version.
+* @example
+* ```js
+* base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));
+* // => 'Eqs'
+* base64urlnopad.decode('Eqs');
+* // => Uint8Array.from([0x12, 0xab])
+* ```
+*/
+const base64urlnopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
+const genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(abc), join(""));
+/**
+* base58: base64 without ambigous characters +, /, 0, O, I, l.
+* Quadratic (O(n^2)) - so, can't be used on large inputs.
+* @example
+* ```js
+* base58.decode('01abcdef');
+* // => '3UhJW'
+* ```
+*/
+const base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+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$2(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$1, limit = 90) {
+		astr("bech32.decode input", str$1);
+		const slen = str$1.length;
+		if (slen < 8 || limit !== false && slen > limit) throw new TypeError(`invalid string length: ${slen} (${str$1}). Expected (8..${limit})`);
+		const lowered = str$1.toLowerCase();
+		if (str$1 !== lowered && str$1 !== str$1.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$1}: expected "${sum}"`);
+		return {
+			prefix,
+			words
+		};
+	}
+	const decodeUnsafe = unsafeWrapper(decode);
+	function decodeToBytes(str$1) {
+		const { prefix, words } = decode(str$1, 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
+	};
+}
+/**
+* bech32 from BIP 173. Operates on words.
+* For high-level, check out scure-btc-signer:
+* https://github.com/paulmillr/scure-btc-signer.
+*/
+const bech32 = genBech32("bech32");
+/**
+* bech32m from BIP 350. Operates on words.
+* It was to mitigate `bech32` weaknesses.
+* For high-level, check out scure-btc-signer:
+* https://github.com/paulmillr/scure-btc-signer.
+*/
+const bech32m = genBech32("bech32m");
+const hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+const hexBuiltin = {
+	encode(data) {
+		abytes$1(data);
+		return data.toHex();
+	},
+	decode(s) {
+		astr("hex", s);
+		return Uint8Array.fromHex(s);
+	}
+};
+/**
+* hex string decoder. Uses built-in function, when available.
+* @example
+* ```js
+* const b = hex.decode("0102ff"); // => new Uint8Array([ 1, 2, 255 ])
+* const str = hex.encode(b); // "0102ff"
+* ```
+*/
+const hex = hasHexBuiltin ? hexBuiltin : 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/.bun/@noble+hashes@2.0.1/node_modules/@noble/hashes/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, title = "") {
+	if (!Number.isSafeInteger(n) || n < 0) {
+		const prefix = title && `"${title}" `;
+		throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+	}
+}
+/** Asserts something is Uint8Array. */
+function abytes(value, length, title = "") {
+	const bytes = isBytes$1(value);
+	const len = value?.length;
+	const needsLen = length !== void 0;
+	if (!bytes || needsLen && len !== length) {
+		const prefix = title && `"${title}" `;
+		const ofLen = needsLen ? ` of length ${length}` : "";
+		const got = bytes ? `length=${len}` : `type=${typeof value}`;
+		throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+	}
+	return value;
+}
+/** 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, void 0, "digestInto() output");
+	const min = instance.outputLen;
+	if (out.length < min) throw new Error("\"digestInto() output\" expected to be of length >=" + min);
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr$1) {
+	return new Uint32Array(arr$1.buffer, arr$1.byteOffset, Math.floor(arr$1.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);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */ (() => 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$1) {
+	for (let i = 0; i < arr$1.length; i++) arr$1[i] = byteSwap(arr$1[i]);
+	return arr$1;
+}
+const swap32IfBE = isLE ? (u) => u : byteSwap32;
+/** Creates function with outputLen, blockLen, create properties from a class constructor. */
+function createHasher(hashCons, info = {}) {
+	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+	const tmp = hashCons(void 0);
+	hashC.outputLen = tmp.outputLen;
+	hashC.blockLen = tmp.blockLen;
+	hashC.create = (opts) => hashCons(opts);
+	Object.assign(hashC, info);
+	return Object.freeze(hashC);
+}
+
+//#endregion
+//#region ../../node_modules/.bun/@noble+hashes@2.0.1/node_modules/@noble/hashes/_blake.js
+/**
+* Internal blake variable.
+* For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+*/
+const BSIGMA = /* @__PURE__ */ Uint8Array.from([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	10,
+	4,
+	8,
+	9,
+	15,
+	13,
+	6,
+	1,
+	12,
+	0,
+	2,
+	11,
+	7,
+	5,
+	3,
+	11,
+	8,
+	12,
+	0,
+	5,
+	2,
+	15,
+	13,
+	10,
+	14,
+	3,
+	6,
+	7,
+	1,
+	9,
+	4,
+	7,
+	9,
+	3,
+	1,
+	13,
+	12,
+	11,
+	14,
+	2,
+	6,
+	5,
+	10,
+	4,
+	0,
+	15,
+	8,
+	9,
+	0,
+	5,
+	7,
+	2,
+	4,
+	10,
+	15,
+	14,
+	1,
+	11,
+	12,
+	6,
+	8,
+	3,
+	13,
+	2,
+	12,
+	6,
+	10,
+	0,
+	11,
+	8,
+	3,
+	4,
+	13,
+	7,
+	5,
+	15,
+	14,
+	1,
+	9,
+	12,
+	5,
+	1,
+	15,
+	14,
+	13,
+	4,
+	10,
+	0,
+	7,
+	6,
+	3,
+	9,
+	2,
+	8,
+	11,
+	13,
+	11,
+	7,
+	14,
+	12,
+	1,
+	3,
+	9,
+	5,
+	0,
+	15,
+	4,
+	8,
+	6,
+	2,
+	10,
+	6,
+	15,
+	14,
+	9,
+	11,
+	3,
+	0,
+	8,
+	12,
+	2,
+	13,
+	7,
+	1,
+	4,
+	10,
+	5,
+	10,
+	2,
+	8,
+	4,
+	7,
+	6,
+	1,
+	5,
+	15,
+	11,
+	9,
+	14,
+	3,
+	12,
+	13,
+	0,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	14,
+	10,
+	4,
+	8,
+	9,
+	15,
+	13,
+	6,
+	1,
+	12,
+	0,
+	2,
+	11,
+	7,
+	5,
+	3,
+	11,
+	8,
+	12,
+	0,
+	5,
+	2,
+	15,
+	13,
+	10,
+	14,
+	3,
+	6,
+	7,
+	1,
+	9,
+	4,
+	7,
+	9,
+	3,
+	1,
+	13,
+	12,
+	11,
+	14,
+	2,
+	6,
+	5,
+	10,
+	4,
+	0,
+	15,
+	8,
+	9,
+	0,
+	5,
+	7,
+	2,
+	4,
+	10,
+	15,
+	14,
+	1,
+	11,
+	12,
+	6,
+	8,
+	3,
+	13,
+	2,
+	12,
+	6,
+	10,
+	0,
+	11,
+	8,
+	3,
+	4,
+	13,
+	7,
+	5,
+	15,
+	14,
+	1,
+	9
+]);
+
+//#endregion
+//#region ../../node_modules/.bun/@noble+hashes@2.0.1/node_modules/@noble/hashes/_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
+	};
+}
+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;
+
+//#endregion
+//#region ../../node_modules/.bun/@noble+hashes@2.0.1/node_modules/@noble/hashes/blake2.js
+/**
+* blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+* b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+* @module
+*/
+const B2B_IV = /* @__PURE__ */ Uint32Array.from([
+	4089235720,
+	1779033703,
+	2227873595,
+	3144134277,
+	4271175723,
+	1013904242,
+	1595750129,
+	2773480762,
+	2917565137,
+	1359893119,
+	725511199,
+	2600822924,
+	4215389547,
+	528734635,
+	327033209,
+	1541459225
+]);
+const BBUF = /* @__PURE__ */ new Uint32Array(32);
+function G1b(a, b, c, d, msg, x) {
+	const Xl = msg[x], Xh = msg[x + 1];
+	let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+	let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+	let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+	let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+	let ll = add3L(Al, Bl, Xl);
+	Ah = add3H(ll, Ah, Bh, Xh);
+	Al = ll | 0;
+	({Dh, Dl} = {
+		Dh: Dh ^ Ah,
+		Dl: Dl ^ Al
+	});
+	({Dh, Dl} = {
+		Dh: rotr32H(Dh, Dl),
+		Dl: rotr32L(Dh, Dl)
+	});
+	({h: Ch, l: Cl} = add(Ch, Cl, Dh, Dl));
+	({Bh, Bl} = {
+		Bh: Bh ^ Ch,
+		Bl: Bl ^ Cl
+	});
+	({Bh, Bl} = {
+		Bh: rotrSH(Bh, Bl, 24),
+		Bl: rotrSL(Bh, Bl, 24)
+	});
+	BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+	BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+	BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+	BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function G2b(a, b, c, d, msg, x) {
+	const Xl = msg[x], Xh = msg[x + 1];
+	let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1];
+	let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1];
+	let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1];
+	let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1];
+	let ll = add3L(Al, Bl, Xl);
+	Ah = add3H(ll, Ah, Bh, Xh);
+	Al = ll | 0;
+	({Dh, Dl} = {
+		Dh: Dh ^ Ah,
+		Dl: Dl ^ Al
+	});
+	({Dh, Dl} = {
+		Dh: rotrSH(Dh, Dl, 16),
+		Dl: rotrSL(Dh, Dl, 16)
+	});
+	({h: Ch, l: Cl} = add(Ch, Cl, Dh, Dl));
+	({Bh, Bl} = {
+		Bh: Bh ^ Ch,
+		Bl: Bl ^ Cl
+	});
+	({Bh, Bl} = {
+		Bh: rotrBH(Bh, Bl, 63),
+		Bl: rotrBL(Bh, Bl, 63)
+	});
+	BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+	BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+	BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+	BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
+	anumber(keyLen);
+	if (outputLen < 0 || outputLen > keyLen) throw new Error("outputLen bigger than keyLen");
+	const { key, salt, personalization } = opts;
+	if (key !== void 0 && (key.length < 1 || key.length > keyLen)) throw new Error("\"key\" expected to be undefined or of length=1.." + keyLen);
+	if (salt !== void 0) abytes(salt, saltLen, "salt");
+	if (personalization !== void 0) abytes(personalization, persLen, "personalization");
+}
+/** Internal base class for BLAKE2. */
+var _BLAKE2 = class {
+	buffer;
+	buffer32;
+	finished = false;
+	destroyed = false;
+	length = 0;
+	pos = 0;
+	blockLen;
+	outputLen;
+	constructor(blockLen, outputLen) {
+		anumber(blockLen);
+		anumber(outputLen);
+		this.blockLen = blockLen;
+		this.outputLen = outputLen;
+		this.buffer = new Uint8Array(blockLen);
+		this.buffer32 = u32(this.buffer);
+	}
+	update(data) {
+		aexists(this);
+		abytes(data);
+		const { blockLen, buffer, buffer32 } = this;
+		const len = data.length;
+		const offset = data.byteOffset;
+		const buf = data.buffer;
+		for (let pos = 0; pos < len;) {
+			if (this.pos === blockLen) {
+				swap32IfBE(buffer32);
+				this.compress(buffer32, 0, false);
+				swap32IfBE(buffer32);
+				this.pos = 0;
+			}
+			const take = Math.min(blockLen - this.pos, len - pos);
+			const dataOffset = offset + pos;
+			if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+				const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+				swap32IfBE(data32);
+				for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+					this.length += blockLen;
+					this.compress(data32, pos32, false);
+				}
+				swap32IfBE(data32);
+				continue;
+			}
+			buffer.set(data.subarray(pos, pos + take), this.pos);
+			this.pos += take;
+			this.length += take;
+			pos += take;
+		}
+		return this;
+	}
+	digestInto(out) {
+		aexists(this);
+		aoutput(out, this);
+		const { pos, buffer32 } = this;
+		this.finished = true;
+		clean(this.buffer.subarray(pos));
+		swap32IfBE(buffer32);
+		this.compress(buffer32, 0, true);
+		swap32IfBE(buffer32);
+		const out32 = u32(out);
+		this.get().forEach((v, i) => out32[i] = swap8IfBE(v));
+	}
+	digest() {
+		const { buffer, outputLen } = this;
+		this.digestInto(buffer);
+		const res = buffer.slice(0, outputLen);
+		this.destroy();
+		return res;
+	}
+	_cloneInto(to) {
+		const { buffer, length, finished, destroyed, outputLen, pos } = this;
+		to ||= new this.constructor({ dkLen: outputLen });
+		to.set(...this.get());
+		to.buffer.set(buffer);
+		to.destroyed = destroyed;
+		to.finished = finished;
+		to.length = length;
+		to.pos = pos;
+		to.outputLen = outputLen;
+		return to;
+	}
+	clone() {
+		return this._cloneInto();
+	}
+};
+/** Internal blake2b hash class. */
+var _BLAKE2b = class extends _BLAKE2 {
+	v0l = B2B_IV[0] | 0;
+	v0h = B2B_IV[1] | 0;
+	v1l = B2B_IV[2] | 0;
+	v1h = B2B_IV[3] | 0;
+	v2l = B2B_IV[4] | 0;
+	v2h = B2B_IV[5] | 0;
+	v3l = B2B_IV[6] | 0;
+	v3h = B2B_IV[7] | 0;
+	v4l = B2B_IV[8] | 0;
+	v4h = B2B_IV[9] | 0;
+	v5l = B2B_IV[10] | 0;
+	v5h = B2B_IV[11] | 0;
+	v6l = B2B_IV[12] | 0;
+	v6h = B2B_IV[13] | 0;
+	v7l = B2B_IV[14] | 0;
+	v7h = B2B_IV[15] | 0;
+	constructor(opts = {}) {
+		const olen = opts.dkLen === void 0 ? 64 : opts.dkLen;
+		super(128, olen);
+		checkBlake2Opts(olen, opts, 64, 16, 16);
+		let { key, personalization, salt } = opts;
+		let keyLength = 0;
+		if (key !== void 0) {
+			abytes(key, void 0, "key");
+			keyLength = key.length;
+		}
+		this.v0l ^= this.outputLen | keyLength << 8 | 16842752;
+		if (salt !== void 0) {
+			abytes(salt, void 0, "salt");
+			const slt = u32(salt);
+			this.v4l ^= swap8IfBE(slt[0]);
+			this.v4h ^= swap8IfBE(slt[1]);
+			this.v5l ^= swap8IfBE(slt[2]);
+			this.v5h ^= swap8IfBE(slt[3]);
+		}
+		if (personalization !== void 0) {
+			abytes(personalization, void 0, "personalization");
+			const pers = u32(personalization);
+			this.v6l ^= swap8IfBE(pers[0]);
+			this.v6h ^= swap8IfBE(pers[1]);
+			this.v7l ^= swap8IfBE(pers[2]);
+			this.v7h ^= swap8IfBE(pers[3]);
+		}
+		if (key !== void 0) {
+			const tmp = new Uint8Array(this.blockLen);
+			tmp.set(key);
+			this.update(tmp);
+		}
+	}
+	get() {
+		let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
+		return [
+			v0l,
+			v0h,
+			v1l,
+			v1h,
+			v2l,
+			v2h,
+			v3l,
+			v3h,
+			v4l,
+			v4h,
+			v5l,
+			v5h,
+			v6l,
+			v6h,
+			v7l,
+			v7h
+		];
+	}
+	set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+		this.v0l = v0l | 0;
+		this.v0h = v0h | 0;
+		this.v1l = v1l | 0;
+		this.v1h = v1h | 0;
+		this.v2l = v2l | 0;
+		this.v2h = v2h | 0;
+		this.v3l = v3l | 0;
+		this.v3h = v3h | 0;
+		this.v4l = v4l | 0;
+		this.v4h = v4h | 0;
+		this.v5l = v5l | 0;
+		this.v5h = v5h | 0;
+		this.v6l = v6l | 0;
+		this.v6h = v6h | 0;
+		this.v7l = v7l | 0;
+		this.v7h = v7h | 0;
+	}
+	compress(msg, offset, isLast) {
+		this.get().forEach((v, i) => BBUF[i] = v);
+		BBUF.set(B2B_IV, 16);
+		let { h, l } = fromBig(BigInt(this.length));
+		BBUF[24] = B2B_IV[8] ^ l;
+		BBUF[25] = B2B_IV[9] ^ h;
+		if (isLast) {
+			BBUF[28] = ~BBUF[28];
+			BBUF[29] = ~BBUF[29];
+		}
+		let j = 0;
+		const s = BSIGMA;
+		for (let i = 0; i < 12; i++) {
+			G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+			G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+			G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+			G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+			G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+			G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+			G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+			G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+			G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+			G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+			G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+			G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+			G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+			G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+			G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+			G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+		}
+		this.v0l ^= BBUF[0] ^ BBUF[16];
+		this.v0h ^= BBUF[1] ^ BBUF[17];
+		this.v1l ^= BBUF[2] ^ BBUF[18];
+		this.v1h ^= BBUF[3] ^ BBUF[19];
+		this.v2l ^= BBUF[4] ^ BBUF[20];
+		this.v2h ^= BBUF[5] ^ BBUF[21];
+		this.v3l ^= BBUF[6] ^ BBUF[22];
+		this.v3h ^= BBUF[7] ^ BBUF[23];
+		this.v4l ^= BBUF[8] ^ BBUF[24];
+		this.v4h ^= BBUF[9] ^ BBUF[25];
+		this.v5l ^= BBUF[10] ^ BBUF[26];
+		this.v5h ^= BBUF[11] ^ BBUF[27];
+		this.v6l ^= BBUF[12] ^ BBUF[28];
+		this.v6h ^= BBUF[13] ^ BBUF[29];
+		this.v7l ^= BBUF[14] ^ BBUF[30];
+		this.v7h ^= BBUF[15] ^ BBUF[31];
+		clean(BBUF);
+	}
+	destroy() {
+		this.destroyed = true;
+		clean(this.buffer32);
+		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	}
+};
+/**
+* Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+* @param msg - message that would be hashed
+* @param opts - dkLen output length, key for MAC mode, salt, personalization
+*/
+const blake2b = /* @__PURE__ */ createHasher((opts) => new _BLAKE2b(opts));
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/utils/ss58-util.mjs
+const SS58_PREFIX = new TextEncoder().encode("SS58PRE");
+const CHECKSUM_LENGTH = 2;
+const getSs58AddressInfo = (address) => {
+	try {
+		const decoded = base58.decode(address);
+		const prefixBytes = decoded.subarray(0, decoded[0] & 64 ? 2 : 1);
+		const publicKey = decoded.subarray(prefixBytes.length, decoded.length - CHECKSUM_LENGTH);
+		const checksum = decoded.subarray(prefixBytes.length + publicKey.length);
+		const expectedChecksum = blake2b(Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey), { dkLen: 64 }).subarray(0, CHECKSUM_LENGTH);
+		if (!(checksum[0] === expectedChecksum[0] && checksum[1] === expectedChecksum[1])) return { isValid: false };
+		return {
+			isValid: true,
+			ss58Format: prefixBytesToNumber(prefixBytes),
+			publicKey: publicKey.slice()
+		};
+	} catch (_) {
+		return { isValid: false };
+	}
+};
+const prefixBytesToNumber = (bytes) => {
+	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	return dv.byteLength === 1 ? dv.getUint8(0) : dv.getUint16(0);
+};
+const withSs58Cache = (fn) => {
+	let cache = {};
+	let activityCount = 0;
+	let latestCount = 0;
+	const checkActivity = () => {
+		if (activityCount === latestCount) {
+			cache = {};
+			activityCount = latestCount = 0;
+		} else {
+			latestCount = activityCount;
+			setTimeout(checkActivity, 0);
+		}
+	};
+	return (publicKey) => {
+		var _a, _b;
+		if (++activityCount === 1) checkActivity();
+		let entry = cache;
+		const lastIdx = publicKey.length - 1;
+		for (let i = 0; i <= lastIdx; i++) entry = entry[_a = publicKey[i]] || (entry[_a] = {});
+		return entry[_b = publicKey[lastIdx]] || (entry[_b] = fn(publicKey));
+	};
+};
+const fromBufferToBase58 = (ss58Format) => {
+	const prefixBytes = ss58Format < 64 ? Uint8Array.of(ss58Format) : Uint8Array.of((ss58Format & 252) >> 2 | 64, ss58Format >> 8 | (ss58Format & 3) << 6);
+	return withSs58Cache((publicKey) => {
+		const checksum = blake2b(Uint8Array.of(...SS58_PREFIX, ...prefixBytes, ...publicKey), { dkLen: 64 }).subarray(0, CHECKSUM_LENGTH);
+		return base58.encode(Uint8Array.of(...prefixBytes, ...publicKey, ...checksum));
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/scale/AccountId.mjs
+function fromBase58ToBuffer(nBytes, _ss58Format) {
+	return (address) => {
+		const info = getSs58AddressInfo(address);
+		if (!info.isValid) throw new Error("Invalid checksum");
+		const { publicKey } = info;
+		if (publicKey.length !== nBytes) throw new Error("Invalid public key length");
+		return publicKey;
+	};
+}
+const AccountId = (ss58Format = 42, nBytes = 32) => enhanceCodec(Bytes(nBytes), fromBase58ToBuffer(nBytes), fromBufferToBase58(ss58Format));
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/scale/Binary.mjs
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+	throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value
+}) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _bytes, _opaqueBytes, _hex, _opaqueHex, _str;
+const textEncoder$3 = new TextEncoder();
+const textDecoder$2 = new TextDecoder();
+const opaqueBytesDec = Tuple(compact, Bytes(Infinity))[1];
+var Binary$1 = class {
+	constructor(data, opaque = false) {
+		__privateAdd(this, _bytes);
+		__privateAdd(this, _opaqueBytes, null);
+		__privateAdd(this, _hex, null);
+		__privateAdd(this, _opaqueHex, null);
+		__privateAdd(this, _str, null);
+		__publicField(this, "asText", () => __privateGet(this, _str) ?? __privateSet(this, _str, textDecoder$2.decode(__privateGet(this, _bytes))));
+		__publicField(this, "asHex", () => __privateGet(this, _hex) ?? __privateSet(this, _hex, toHex(__privateGet(this, _bytes))));
+		__publicField(this, "asOpaqueHex", () => __privateGet(this, _opaqueHex) ?? __privateSet(this, _opaqueHex, toHex(this.asOpaqueBytes())));
+		__publicField(this, "asBytes", () => __privateGet(this, _bytes));
+		__publicField(this, "asOpaqueBytes", () => __privateGet(this, _opaqueBytes) ?? __privateSet(this, _opaqueBytes, mergeUint8$1([compact[0](__privateGet(this, _bytes).length), __privateGet(this, _bytes)])));
+		if (opaque) {
+			try {
+				const [len, bytes] = opaqueBytesDec(data);
+				if (len === bytes.length) {
+					__privateSet(this, _bytes, bytes);
+					__privateSet(this, _opaqueBytes, data);
+					return;
+				}
+			} catch (_) {}
+			throw new Error("Invalid opaque bytes");
+		} else __privateSet(this, _bytes, data);
+	}
+	static fromText(input) {
+		return new this(textEncoder$3.encode(input));
+	}
+	static fromHex(input) {
+		return new this(fromHex$1(input));
+	}
+	static fromOpaqueHex(input) {
+		return new this(fromHex$1(input), true);
+	}
+	static fromBytes(input) {
+		return new this(input);
+	}
+	static fromOpaqueBytes(input) {
+		return new this(input, true);
+	}
+};
+_bytes = /* @__PURE__ */ new WeakMap();
+_opaqueBytes = /* @__PURE__ */ new WeakMap();
+_hex = /* @__PURE__ */ new WeakMap();
+_opaqueHex = /* @__PURE__ */ new WeakMap();
+_str = /* @__PURE__ */ new WeakMap();
+const [accountIdEncoder] = AccountId();
+var FixedSizeBinary$1 = class extends Binary$1 {
+	constructor(data) {
+		super(data);
+	}
+	static fromArray(input) {
+		return new this(new Uint8Array(input));
+	}
+	static fromAccountId32(input) {
+		return new this(accountIdEncoder(input));
+	}
+};
+const enc$2 = (nBytes) => {
+	const _enc = Bytes.enc(nBytes);
+	return (value) => _enc(value.asBytes());
+};
+const dec$2 = (nBytes) => {
+	const _dec = Bytes.dec(nBytes);
+	const Bin2 = nBytes == null ? Binary$1 : FixedSizeBinary$1;
+	return (value) => Bin2.fromBytes(_dec(value));
+};
+const Bin = (nBytes) => createCodec(enc$2(nBytes), dec$2(nBytes));
+Bin.enc = enc$2;
+Bin.dec = dec$2;
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/scale/compact.mjs
+const compactNumber = enhanceCodec(compact, (v) => v, Number);
+const compactBn = enhanceCodec(compact, (v) => v, BigInt);
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/scale/Hex.mjs
+const enc$1 = (nBytes) => {
+	const _enc = Bytes.enc(nBytes);
+	return (value) => _enc(fromHex$1(value));
+};
+const dec$1 = (nBytes) => {
+	const _dec = Bytes.dec(nBytes);
+	return (value) => toHex(_dec(value));
+};
+const Hex = (nBytes) => createCodec(enc$1(nBytes), dec$1(nBytes));
+Hex.enc = enc$1;
+Hex.dec = dec$1;
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/docs.mjs
+const docs = Vector(str);
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/lookup.mjs
+const oStr = Option(str);
+const primitive = Enum$1({
+	bool: _void$1,
+	char: _void$1,
+	str: _void$1,
+	u8: _void$1,
+	u16: _void$1,
+	u32: _void$1,
+	u64: _void$1,
+	u128: _void$1,
+	u256: _void$1,
+	i8: _void$1,
+	i16: _void$1,
+	i32: _void$1,
+	i64: _void$1,
+	i128: _void$1,
+	i256: _void$1
+});
+const fields = Vector(Struct({
+	name: oStr,
+	type: compactNumber,
+	typeName: oStr,
+	docs
+}));
+const arr = Struct({
+	len: u32$1,
+	type: compactNumber
+});
+const bitSequence = Struct({
+	bitStoreType: compactNumber,
+	bitOrderType: compactNumber
+});
+const def = Enum$1({
+	composite: fields,
+	variant: Vector(Struct({
+		name: str,
+		fields,
+		index: u8,
+		docs
+	})),
+	sequence: compactNumber,
+	array: arr,
+	tuple: Vector(compactNumber),
+	primitive,
+	compact: compactNumber,
+	bitSequence
+});
+const lookup = Vector(Struct({
+	id: compactNumber,
+	path: docs,
+	params: Vector(Struct({
+		name: str,
+		type: Option(compactNumber)
+	})),
+	def,
+	docs
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/deprecation.mjs
+const itemDeprecation = Enum$1({
+	NotDeprecated: _void$1,
+	DeprecatedWithoutNote: _void$1,
+	Deprecated: Struct({
+		note: str,
+		since: Option(str)
+	})
+});
+const variantDeprecation = Vector(Struct({
+	index: u8,
+	deprecation: Enum$1({
+		DeprecatedWithoutNote: _void$1,
+		Deprecated: Struct({
+			note: str,
+			since: Option(str)
+		})
+	}, [1, 2])
+}));
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/runtime-api.mjs
+const runtimeApiMethod = {
+	name: str,
+	inputs: Vector(Struct({
+		name: str,
+		type: compactNumber
+	})),
+	output: compactNumber,
+	docs
+};
+const runtimeApiV15 = Struct({
+	name: str,
+	methods: Vector(Struct(runtimeApiMethod)),
+	docs
+});
+const runtimeApi = Struct({
+	name: str,
+	methods: Vector(Struct({
+		...runtimeApiMethod,
+		deprecationInfo: itemDeprecation
+	})),
+	docs,
+	version: compactNumber,
+	deprecationInfo: itemDeprecation
+});
+const viewFunction = Struct({
+	id: Hex(32),
+	...runtimeApiMethod,
+	deprecationInfo: itemDeprecation
+});
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/pallets.mjs
+const storageMap = Struct({
+	hashers: Vector(Enum$1({
+		Blake2128: _void$1,
+		Blake2256: _void$1,
+		Blake2128Concat: _void$1,
+		Twox128: _void$1,
+		Twox256: _void$1,
+		Twox64Concat: _void$1,
+		Identity: _void$1
+	})),
+	key: compactNumber,
+	value: compactNumber
+});
+const storageItem = {
+	name: str,
+	modifier: u8,
+	type: Enum$1({
+		plain: compactNumber,
+		map: storageMap
+	}),
+	fallback: Hex(),
+	docs
+};
+const enumRefV14 = Option(compactNumber);
+const v14Pallet = {
+	name: str,
+	storage: Option(Struct({
+		prefix: str,
+		items: Vector(Struct(storageItem))
+	})),
+	calls: enumRefV14,
+	events: enumRefV14,
+	constants: Vector(Struct({
+		name: str,
+		type: compactNumber,
+		value: Hex(),
+		docs
+	})),
+	errors: enumRefV14,
+	index: u8
+};
+const v15Pallet = {
+	...v14Pallet,
+	docs
+};
+const enumRef = Option(Struct({
+	type: compactNumber,
+	deprecationInfo: variantDeprecation
+}));
+const v16Pallet = {
+	name: str,
+	storage: Option(Struct({
+		prefix: str,
+		items: Vector(Struct({
+			...storageItem,
+			deprecationInfo: itemDeprecation
+		}))
+	})),
+	calls: enumRef,
+	events: enumRef,
+	constants: Vector(Struct({
+		name: str,
+		type: compactNumber,
+		value: Hex(),
+		docs,
+		deprecationInfo: itemDeprecation
+	})),
+	errors: enumRef,
+	associatedTypes: Vector(Struct({
+		name: str,
+		type: compactNumber,
+		docs
+	})),
+	viewFns: Vector(viewFunction),
+	index: u8,
+	docs,
+	deprecationInfo: itemDeprecation
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/v14.mjs
+const empty = new Uint8Array();
+const Always = (value) => createCodec(() => empty, () => value);
+const extrinsic$2 = Struct({
+	type: compactNumber,
+	version: u8,
+	signedExtensions: Vector(Struct({
+		identifier: str,
+		type: compactNumber,
+		additionalSigned: compactNumber
+	}))
+});
+const v14 = Struct({
+	lookup,
+	pallets: Vector(Struct({
+		...v14Pallet,
+		docs: Always([])
+	})),
+	extrinsic: extrinsic$2,
+	type: compactNumber,
+	apis: Always([])
+});
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/v15.mjs
+const extrinsic$1 = Struct({
+	version: u8,
+	address: compactNumber,
+	call: compactNumber,
+	signature: compactNumber,
+	extra: compactNumber,
+	signedExtensions: Vector(Struct({
+		identifier: str,
+		type: compactNumber,
+		additionalSigned: compactNumber
+	}))
+});
+const v15 = Struct({
+	lookup,
+	pallets: Vector(Struct(v15Pallet)),
+	extrinsic: extrinsic$1,
+	type: compactNumber,
+	apis: Vector(runtimeApiV15),
+	outerEnums: Struct({
+		call: compactNumber,
+		event: compactNumber,
+		error: compactNumber
+	}),
+	custom: Vector(Tuple(str, Struct({
+		type: compactNumber,
+		value: Hex()
+	})))
+});
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/v16.mjs
+const extrinsic = Struct({
+	version: Vector(u8),
+	address: compactNumber,
+	call: compactNumber,
+	signature: compactNumber,
+	signedExtensionsByVersion: Vector(Tuple(u8, Vector(compactNumber))),
+	signedExtensions: Vector(Struct({
+		identifier: str,
+		type: compactNumber,
+		additionalSigned: compactNumber
+	}))
+});
+const v16 = Struct({
+	lookup,
+	pallets: Vector(Struct(v16Pallet)),
+	extrinsic,
+	apis: Vector(runtimeApi),
+	outerEnums: Struct({
+		call: compactNumber,
+		event: compactNumber,
+		error: compactNumber
+	}),
+	custom: Vector(Tuple(str, Struct({
+		type: compactNumber,
+		value: Hex()
+	})))
+});
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/metadata.mjs
+const unsupportedFn = () => {
+	throw new Error("Unsupported metadata version!");
+};
+const unsupported = createCodec(unsupportedFn, unsupportedFn);
+const metadata = Struct({
+	magicNumber: u32$1,
+	metadata: Enum$1({
+		v0: unsupported,
+		v1: unsupported,
+		v2: unsupported,
+		v3: unsupported,
+		v4: unsupported,
+		v5: unsupported,
+		v6: unsupported,
+		v7: unsupported,
+		v8: unsupported,
+		v9: unsupported,
+		v10: unsupported,
+		v11: unsupported,
+		v12: unsupported,
+		v13: unsupported,
+		v14,
+		v15,
+		v16
+	})
+});
+const opaqueBytes = Bytes();
+const optionOpaque = Option(opaqueBytes);
+const opaqueOpaqueBytes = Tuple(compact, opaqueBytes);
+const decAnyMetadata = (input) => {
+	try {
+		return metadata.dec(input);
+	} catch (_) {}
+	try {
+		return metadata.dec(optionOpaque.dec(input));
+	} catch (_) {}
+	try {
+		return metadata.dec(opaqueBytes.dec(input));
+	} catch (_) {}
+	try {
+		return metadata.dec(opaqueOpaqueBytes.dec(input)[1]);
+	} catch (_) {}
+	throw null;
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/codecs/metadata/unified.mjs
+const unifyMetadata = (metadata$1) => {
+	if ("magicNumber" in metadata$1) metadata$1 = metadata$1.metadata;
+	if ("tag" in metadata$1) {
+		if (metadata$1.tag !== "v14" && metadata$1.tag !== "v15" && metadata$1.tag !== "v16") throw new Error("Only metadata 14, 15, and 16 are supported");
+		metadata$1 = metadata$1.value;
+	}
+	if ("signedExtensionsByVersion" in metadata$1.extrinsic) {
+		const { extrinsic: { signedExtensions, signedExtensionsByVersion, ...restExtrinsic }, ...rest } = metadata$1;
+		if (!signedExtensionsByVersion.some(([v]) => v === 0)) throw new Error("Extension version 0 not found");
+		return {
+			version: 16,
+			extrinsic: {
+				...restExtrinsic,
+				signedExtensions: Object.fromEntries(signedExtensionsByVersion.map(([v, idxs]) => [v, idxs.map((extIdx) => signedExtensions[extIdx])]))
+			},
+			...rest
+		};
+	}
+	if ("custom" in metadata$1) {
+		const { lookup: lookup2, extrinsic: extrinsic2, custom, apis, pallets: pallets2, outerEnums } = metadata$1;
+		return {
+			version: 15,
+			lookup: lookup2,
+			pallets: pallets2.map((p) => ({
+				...p,
+				calls: p.calls != null ? { type: p.calls } : void 0,
+				events: p.events != null ? { type: p.events } : void 0,
+				errors: p.errors != null ? { type: p.errors } : void 0,
+				viewFns: [],
+				associatedTypes: []
+			})),
+			extrinsic: {
+				...extrinsic2,
+				signedExtensions: { 0: extrinsic2.signedExtensions },
+				version: [extrinsic2.version]
+			},
+			apis,
+			outerEnums,
+			custom
+		};
+	}
+	const { lookup: lookup$1, extrinsic: extrinsic$3, pallets } = metadata$1;
+	return {
+		version: 14,
+		lookup: lookup$1,
+		pallets: pallets.map((p) => ({
+			...p,
+			calls: p.calls != null ? { type: p.calls } : void 0,
+			events: p.events != null ? { type: p.events } : void 0,
+			errors: p.errors != null ? { type: p.errors } : void 0,
+			viewFns: [],
+			associatedTypes: []
+		})),
+		extrinsic: {
+			...extrinsic$3,
+			signedExtensions: { 0: extrinsic$3.signedExtensions },
+			version: [extrinsic$3.version]
+		},
+		apis: []
+	};
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/extrinsics/extrinsic-format.mjs
+const TYPES = {
+	bare: 0,
+	0: "bare",
+	general: 1,
+	1: "general",
+	signed: 2,
+	2: "signed"
+};
+const extrinsicFormat = enhanceCodec(u8, ({ version, type }) => version + (TYPES[type] << 6), (v) => {
+	const version = v & 63;
+	const type = v >> 6;
+	if (version === 4 && (type === TYPES.bare || type === TYPES.signed)) return {
+		version,
+		type: TYPES[type]
+	};
+	if (version === 5 && (type === TYPES.bare || type === TYPES.general)) return {
+		version,
+		type: TYPES[type]
+	};
+	throw new Error(`ExtrinsicFormat ${v} not valid`);
+});
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+substrate-bindings@0.17.0/node_modules/@polkadot-api/substrate-bindings/dist/esm/hashes/blake2.mjs
+const len32$1 = { dkLen: 32 };
+const Blake2256 = (encoded) => blake2b(encoded, len32$1);
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+metadata-builders@0.13.9/node_modules/@polkadot-api/metadata-builders/dist/esm/lookups.mjs
+const isBytes = (value, nBytes) => value.type === "array" && value.len === nBytes && value.value.type === "primitive" && value.value.value === "u8";
+const _void = { type: "void" };
+const _denormalizeLookup = (lookupData, customMap = () => null) => {
+	const lookups = /* @__PURE__ */ new Map();
+	const from = /* @__PURE__ */ new Set();
+	const withCache = (fn) => {
+		return (id) => {
+			let entry = lookups.get(id);
+			if (entry) return entry;
+			if (from.has(id)) {
+				const entry2 = { id };
+				lookups.set(id, entry2);
+				return entry2;
+			}
+			from.add(id);
+			const value = fn(id);
+			entry = lookups.get(id);
+			if (entry) Object.assign(entry, value);
+			else {
+				entry = {
+					id,
+					...value
+				};
+				lookups.set(id, entry);
+			}
+			from.delete(id);
+			return entry;
+		};
+	};
+	let isAccountId32SearchOn = true;
+	let isAccountId20SearchOn = true;
+	const getLookupEntryDef = withCache((id) => {
+		const custom = customMap(lookupData[id]);
+		if (custom) return custom;
+		const { def: def$1, path, params } = lookupData[id];
+		if (def$1.tag === "composite") {
+			if (def$1.value.length === 0) return _void;
+			if (def$1.value.length === 1) {
+				const inner = getLookupEntryDef(def$1.value[0].type);
+				if (isAccountId32SearchOn && path.at(-1) === "AccountId32" && isBytes(inner, 32)) {
+					isAccountId32SearchOn = false;
+					return { type: "AccountId32" };
+				}
+				if (isAccountId20SearchOn && path.at(-1) === "AccountId20" && isBytes(inner, 20)) {
+					isAccountId20SearchOn = false;
+					return { type: "AccountId20" };
+				}
+				return inner;
+			}
+			return getComplexVar(def$1.value);
+		}
+		if (def$1.tag === "variant") {
+			if (path.length === 1 && path[0] === "Option" && params.length === 1 && params[0].name === "T") {
+				const value = getLookupEntryDef(params[0].type);
+				return value.type === "void" ? {
+					type: "primitive",
+					value: "bool"
+				} : {
+					type: "option",
+					value
+				};
+			}
+			if (path.length === 1 && path[0] === "Result" && params.length === 2 && params[0].name === "T" && params[1].name === "E") return {
+				type: "result",
+				value: {
+					ok: getLookupEntryDef(params[0].type),
+					ko: getLookupEntryDef(params[1].type)
+				}
+			};
+			if (def$1.value.length === 0) return _void;
+			const enumValue = {};
+			const enumDocs = {};
+			def$1.value.forEach((x) => {
+				const key = x.name;
+				enumDocs[key] = x.docs;
+				if (x.fields.length === 0) {
+					enumValue[key] = {
+						..._void,
+						idx: x.index
+					};
+					return;
+				}
+				if (x.fields.length === 1 && !x.fields[0].name) {
+					enumValue[key] = {
+						type: "lookupEntry",
+						value: getLookupEntryDef(x.fields[0].type),
+						idx: x.index
+					};
+					return;
+				}
+				enumValue[key] = {
+					...getComplexVar(x.fields),
+					idx: x.index
+				};
+			});
+			return {
+				type: "enum",
+				value: enumValue,
+				innerDocs: enumDocs
+			};
+		}
+		if (def$1.tag === "sequence") return {
+			type: "sequence",
+			value: getLookupEntryDef(def$1.value)
+		};
+		if (def$1.tag === "array") {
+			const { len } = def$1.value;
+			const value = getLookupEntryDef(def$1.value.type);
+			return !len || value.type === "void" ? _void : len > 1 ? {
+				type: "array",
+				value,
+				len: def$1.value.len
+			} : value;
+		}
+		if (def$1.tag === "tuple") {
+			if (def$1.value.length === 0) return _void;
+			return def$1.value.length > 1 ? getArrayOrTuple(def$1.value.map((x) => getLookupEntryDef(x)), def$1.value.map((x) => lookupData[x].docs)) : getLookupEntryDef(def$1.value[0]);
+		}
+		if (def$1.tag === "primitive") return {
+			type: "primitive",
+			value: def$1.value.tag
+		};
+		if (def$1.tag === "compact") {
+			const translated = getLookupEntryDef(def$1.value);
+			if (translated.type === "void") return _void;
+			return {
+				type: "compact",
+				isBig: Number(translated.value.slice(1)) > 32,
+				size: translated.value
+			};
+		}
+		return {
+			type: def$1.tag,
+			isLSB: (lookupData[def$1.value.bitOrderType].path.at(-1) ?? "LSB").toUpperCase().startsWith("LSB")
+		};
+	});
+	const getComplexVar = (input) => {
+		let allKey = true;
+		const values = {};
+		const innerDocs = {};
+		input.forEach((x, idx) => {
+			allKey = allKey && !!x.name;
+			const key = x.name || idx;
+			const value = getLookupEntryDef(x.type);
+			if (value.type !== "void") {
+				values[key] = value;
+				innerDocs[key] = x.docs;
+			}
+		});
+		return allKey ? {
+			type: "struct",
+			value: values,
+			innerDocs
+		} : getArrayOrTuple(Object.values(values), Object.values(innerDocs));
+	};
+	const getArrayOrTuple = (values, innerDocs) => {
+		if (values.every((v) => v.id === values[0].id) && innerDocs.every((doc) => !doc.length)) {
+			const [value] = values;
+			return value.type === "void" ? _void : {
+				type: "array",
+				value: values[0],
+				len: values.length
+			};
+		}
+		return {
+			type: "tuple",
+			value: values,
+			innerDocs
+		};
+	};
+	return getLookupEntryDef;
+};
+const getLookupFn = (metadata$1) => {
+	const getLookupEntryDef = _denormalizeLookup(metadata$1.lookup, ({ def: def$1 }) => {
+		if (def$1.tag === "composite") {
+			const moduleErrorLength = getModuleErrorLength(def$1);
+			if (moduleErrorLength) return {
+				type: "enum",
+				innerDocs: {},
+				value: Object.fromEntries(metadata$1.pallets.map((p) => [p.name, p.errors == null ? {
+					..._void,
+					idx: p.index
+				} : {
+					type: "lookupEntry",
+					value: getLookupEntryDef(p.errors.type),
+					idx: p.index
+				}])),
+				byteLength: moduleErrorLength
+			};
+		}
+		return null;
+	});
+	function getModuleErrorLength(def$1) {
+		if (!(def$1.value.length === 2 && def$1.value[0].name === "index" && def$1.value[1].name === "error")) return null;
+		const index = getLookupEntryDef(def$1.value[0].type);
+		const error = getLookupEntryDef(def$1.value[1].type);
+		return index.type === "primitive" && index.value === "u8" && error.type === "array" && error.value.type === "primitive" && error.value.value === "u8" ? 1 + error.len : null;
+	}
+	const getCall = () => {
+		if ("call" in metadata$1.extrinsic) return metadata$1.extrinsic.call;
+		return (metadata$1.lookup[metadata$1.extrinsic.type]?.params.find((p) => p.name === "Call"))?.type ?? null;
+	};
+	return Object.assign(getLookupEntryDef, {
+		metadata: metadata$1,
+		call: getCall()
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+signers-common@0.1.20/node_modules/@polkadot-api/signers-common/dist/esm/v4.mjs
+const unkownSignerType = () => /* @__PURE__ */ new Error("Unkown signer");
+const getSignerType = (metadata$1) => {
+	const { extrinsic: extrinsic$3 } = metadata$1;
+	const getLookup = getLookupFn(metadata$1);
+	let address;
+	let signature;
+	if ("address" in extrinsic$3) {
+		address = getLookup(extrinsic$3.address);
+		signature = getLookup(extrinsic$3.signature);
+	} else {
+		const extProps = Object.fromEntries(metadata$1.lookup[extrinsic$3.type].params.filter((x) => x.type != null).map((x) => [x.name, getLookup(x.type)]));
+		address = extProps["Address"];
+		signature = extProps["Signature"];
+		if (!address || !signature) throw unkownSignerType();
+	}
+	if (address.type === "AccountId20" && signature.type === "array" && signature.len === 65 && signature.value.type === "primitive" && signature.value.value === "u8") return [1, []];
+	if (signature.type !== "enum" || [
+		"Ecdsa",
+		"Ed25519",
+		"Sr25519"
+	].some((x) => !(x in signature.value))) throw unkownSignerType();
+	if (address.type === "enum") {
+		const id = address.value["Id"];
+		if (id.type === "lookupEntry" && id.value.type === "AccountId32") return [0, [id.idx]];
+	} else if (address.type === "AccountId32") return [0, []];
+	throw unkownSignerType();
+};
+const signingTypeId = {
+	Ed25519: 0,
+	Sr25519: 1,
+	Ecdsa: 2
+};
+const createV4Tx = (metadata$1, publicKey, signed, extra, callData, signingType) => {
+	const [signerType, addressPrefix] = getSignerType(metadata$1);
+	const preResult = mergeUint8$1([
+		extrinsicFormat.enc({
+			version: 4,
+			type: "signed"
+		}),
+		signerType === 1 ? publicKey : new Uint8Array([...addressPrefix, ...publicKey]),
+		signerType === 1 || !signingType ? signed : new Uint8Array([signingTypeId[signingType], ...signed]),
+		...extra,
+		callData
+	]);
+	return mergeUint8$1([compact.enc(preResult.length), preResult]);
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+signers-common@0.1.20/node_modules/@polkadot-api/signers-common/dist/esm/sign-bytes.mjs
+const [preBytes, postBytes] = ["<Bytes>", "</Bytes>"].map((str$1) => Binary$1.fromText(str$1).asBytes());
+const getSignBytes = (sign) => async (data) => {
+	let isPadded = true;
+	let i;
+	for (i = 0; isPadded && i < preBytes.length; i++) isPadded = preBytes[i] === data[i];
+	isPadded = isPadded && i === preBytes.length;
+	const postDataStart = data.length - postBytes.length;
+	for (i = 0; isPadded && i < postBytes.length; i++) isPadded = postBytes[i] === data[postDataStart + i];
+	isPadded = isPadded && i === postBytes.length;
+	return sign(isPadded ? data : mergeUint8$1([
+		preBytes,
+		data,
+		postBytes
+	]));
+};
+
+//#endregion
+//#region ../../node_modules/.bun/@polkadot-api+signer@0.2.13/node_modules/@polkadot-api/signer/dist/esm/from-raw-signer.mjs
+function getPolkadotSigner(publicKey, signingType, sign) {
+	const signTx = async (callData, signedExtensions, metadata$1, _, hasher = Blake2256) => {
+		const decMeta = unifyMetadata(decAnyMetadata(metadata$1));
+		const extra = [];
+		const additionalSigned = [];
+		decMeta.extrinsic.signedExtensions[0].map(({ identifier }) => {
+			const signedExtension = signedExtensions[identifier];
+			if (!signedExtension) throw new Error(`Missing ${identifier} signed extension`);
+			extra.push(signedExtension.value);
+			additionalSigned.push(signedExtension.additionalSigned);
+		});
+		const toSign = mergeUint8$1([
+			callData,
+			...extra,
+			...additionalSigned
+		]);
+		return createV4Tx(decMeta, publicKey, await sign(toSign.length > 256 ? hasher(toSign) : toSign), extra, callData, signingType);
+	};
+	return {
+		publicKey,
+		signTx,
+		signBytes: getSignBytes(sign)
+	};
+}
+const oneU8 = Uint8Array.from([1]);
+
 //#endregion
 //#region src/wallet/signer.ts
 function createSr25519SignerFromKeypair(keypair) {
@@ -8117,12 +10645,12 @@ function formatBlockDuration(blocks, options = {}) {
 * ```
 */
 function concatBytes(...arrays) {
-	const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+	const totalLength = arrays.reduce((sum, arr$1) => sum + arr$1.length, 0);
 	const result = new Uint8Array(totalLength);
 	let offset = 0;
-	for (const arr of arrays) {
-		result.set(arr, offset);
-		offset += arr.length;
+	for (const arr$1 of arrays) {
+		result.set(arr$1, offset);
+		offset += arr$1.length;
 	}
 	return result;
 }
@@ -8194,8 +10722,8 @@ function extractSelectorHex(callData) {
 * @param hex - Hex string with or without 0x prefix
 * @returns Normalized hex string with 0x prefix
 */
-function normalizeHex(hex) {
-	return `0x${(hex.startsWith("0x") ? hex.slice(2) : hex).toLowerCase()}`;
+function normalizeHex(hex$1) {
+	return `0x${(hex$1.startsWith("0x") ? hex$1.slice(2) : hex$1).toLowerCase()}`;
 }
 /**
 * Convert a selector string (with or without 0x) to Uint8Array