@chainflip/processor 2.1.0-alpha.2 → 2.1.0-alpha.4

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/I8.cjs

@@ -0,0 +1,14 @@
+const require_Int = require('../base/Int.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/I8.js
+/**
+* @name i8
+* @description
+* An 8-bit signed integer
+*/
+var i8 = class extends require_Int.Int.with(8) {
+	__IntType = "i8";
+};
+
+//#endregion
+exports.i8 = i8;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/ISize.cjs

@@ -0,0 +1,19 @@
+const require_I32 = require('./I32.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/ISize.js
+/**
+* @name ISize
+* @description
+* A System default signed number, typically used in RPC to report non-consensus
+* data. It is a wrapper for [[I32]] as a WASM default (as generated by Rust bindings).
+* It is not to be used, since it creates consensus mismatches.
+*/
+var isize = class extends require_I32.i32 {
+	constructor(registry, value) {
+		super(registry, value);
+		throw new Error("The `isize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally i64) and WASM (always i32) code. Use one of the `i32` or `i64` types explicitly.");
+	}
+};
+
+//#endregion
+exports.isize = isize;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U128.cjs

@@ -0,0 +1,14 @@
+const require_UInt = require('../base/UInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U128.js
+/**
+* @name u128
+* @description
+* A 128-bit unsigned integer
+*/
+var u128 = class extends require_UInt.UInt.with(128) {
+	__UIntType = "u128";
+};
+
+//#endregion
+exports.u128 = u128;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U16.cjs

@@ -0,0 +1,14 @@
+const require_UInt = require('../base/UInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U16.js
+/**
+* @name u16
+* @description
+* A 16-bit unsigned integer
+*/
+var u16 = class extends require_UInt.UInt.with(16) {
+	__UIntType = "u16";
+};
+
+//#endregion
+exports.u16 = u16;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U256.cjs

@@ -0,0 +1,14 @@
+const require_UInt = require('../base/UInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U256.js
+/**
+* @name u256
+* @description
+* A 256-bit unsigned integer
+*/
+var u256 = class extends require_UInt.UInt.with(256) {
+	__UIntType = "u256";
+};
+
+//#endregion
+exports.u256 = u256;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U32.cjs

@@ -0,0 +1,14 @@
+const require_UInt = require('../base/UInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U32.js
+/**
+* @name u32
+* @description
+* A 32-bit unsigned integer
+*/
+var u32 = class extends require_UInt.UInt.with(32) {
+	__UIntType = "u32";
+};
+
+//#endregion
+exports.u32 = u32;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U64.cjs

@@ -0,0 +1,14 @@
+const require_UInt = require('../base/UInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U64.js
+/**
+* @name u64
+* @description
+* A 64-bit unsigned integer
+*/
+var u64 = class extends require_UInt.UInt.with(64) {
+	__UIntType = "u64";
+};
+
+//#endregion
+exports.u64 = u64;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U8.cjs

@@ -0,0 +1,14 @@
+const require_UInt = require('../base/UInt.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/U8.js
+/**
+* @name u8
+* @description
+* An 8-bit unsigned integer
+*/
+var u8 = class extends require_UInt.UInt.with(8) {
+	__UIntType = "u8";
+};
+
+//#endregion
+exports.u8 = u8;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/USize.cjs

@@ -0,0 +1,19 @@
+const require_U32 = require('./U32.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/primitive/USize.js
+/**
+* @name USize
+* @description
+* A System default unsigned number, typically used in RPC to report non-consensus
+* data. It is a wrapper for [[U32]] as a WASM default (as generated by Rust bindings).
+* It is not to be used, since it created consensus mismatches.
+*/
+var usize = class extends require_U32.u32 {
+	constructor(registry, value) {
+		super(registry, value);
+		throw new Error("The `usize` type should not be used. Since it is platform-specific, it creates incompatibilities between native (generally u64) and WASM (always u32) code. Use one of the `u32` or `u64` types explicitly.");
+	}
+};
+
+//#endregion
+exports.usize = usize;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/compareArray.cjs

@@ -0,0 +1,11 @@
+const require_undefined = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/undefined.cjs');
+const require_util = require('./util.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/compareArray.js
+function compareArray(a, b) {
+	if (Array.isArray(b)) return a.length === b.length && require_undefined.isUndefined(a.find((v, index) => require_util.hasEq(v) ? !v.eq(b[index]) : v !== b[index]));
+	return false;
+}
+
+//#endregion
+exports.compareArray = compareArray;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/compareMap.cjs

@@ -0,0 +1,23 @@
+const require_object = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/object.cjs');
+const require_undefined = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/undefined.cjs');
+const require_util = require('./util.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/compareMap.js
+function hasMismatch(a, b) {
+	return require_undefined.isUndefined(a) || (require_util.hasEq(a) ? !a.eq(b) : a !== b);
+}
+function notEntry(value) {
+	return !Array.isArray(value) || value.length !== 2;
+}
+function compareMapArray(a, b) {
+	return a.size === b.length && !b.some((e) => notEntry(e) || hasMismatch(a.get(e[0]), e[1]));
+}
+function compareMap(a, b) {
+	if (Array.isArray(b)) return compareMapArray(a, b);
+	else if (b instanceof Map) return compareMapArray(a, [...b.entries()]);
+	else if (require_object.isObject(b)) return compareMapArray(a, Object.entries(b));
+	return false;
+}
+
+//#endregion
+exports.compareMap = compareMap;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/compareSet.cjs

@@ -0,0 +1,15 @@
+const require_object = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/object.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/compareSet.js
+function compareSetArray(a, b) {
+	return a.size === b.length && !b.some((e) => !a.has(e));
+}
+function compareSet(a, b) {
+	if (Array.isArray(b)) return compareSetArray(a, b);
+	else if (b instanceof Set) return compareSetArray(a, [...b.values()]);
+	else if (require_object.isObject(b)) return compareSetArray(a, Object.values(b));
+	return false;
+}
+
+//#endregion
+exports.compareSet = compareSet;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/decodeU8a.cjs

@@ -0,0 +1,107 @@
+const require_toHex = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toHex.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/decodeU8a.js
+const MAX_DEPTH = 1024;
+/** @internal */
+function isComplexType(Type) {
+	const typeName = Type.name?.toLowerCase() || "";
+	return [
+		"enum",
+		"hashmap",
+		"linkage",
+		"null",
+		"option",
+		"range",
+		"rangeinclusive",
+		"result",
+		"struct",
+		"tuple",
+		"vec",
+		"vecfixed"
+	].includes(typeName);
+}
+/** @internal */
+function formatFailure(registry, fn, _result, { message }, u8a, i, count, Type, key) {
+	let type = "";
+	try {
+		type = `: ${new Type(registry).toRawType()}`;
+	} catch {}
+	return `${fn}: failed at ${require_toHex.u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ""} (index ${i + 1}/${count})${type}:: ${message}`;
+}
+/**
+* @internal
+*
+* Given an u8a, and an array of Type constructors, decode the u8a against the
+* types, and return an array of decoded values.
+*
+* @param u8a - The u8a to decode.
+* @param result - The result array (will be returned with values pushed)
+* @param types - The array of CodecClass to decode the U8a against.
+*/
+function decodeU8a(registry, result, u8a, [Types, keys]) {
+	const count = result.length;
+	let offset = 0;
+	let i = 0;
+	try {
+		while (i < count) {
+			const value = new Types[i](registry, u8a.subarray(offset));
+			offset += value.initialU8aLength || value.encodedLength;
+			result[i] = value;
+			i++;
+		}
+	} catch (error) {
+		throw new Error(formatFailure(registry, "decodeU8a", result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
+	}
+	return [result, offset];
+}
+/**
+* @internal
+*
+* Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
+* is all on the hot-path, so it is not great, however there is (some) method behind the madness
+*/
+function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
+	const count = result.length;
+	let offset = 0;
+	let i = 0;
+	if (count > MAX_DEPTH && isComplexType(Types[i])) throw new Error(`decodeU8aStruct: Maximum depth exceeded, received ${count} elements, limit ${MAX_DEPTH}`);
+	try {
+		while (i < count) {
+			const value = new Types[i](registry, u8a.subarray(offset));
+			offset += value.initialU8aLength || value.encodedLength;
+			result[i] = [keys[i], value];
+			i++;
+		}
+	} catch (error) {
+		throw new Error(formatFailure(registry, "decodeU8aStruct", result, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
+	}
+	return [result, offset];
+}
+/**
+* @internal
+*
+* Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
+* is all on the hot-path, so it is not great, however there is (some) method behind the madness
+*/
+function decodeU8aVec(registry, result, u8a, startAt, Type) {
+	const count = result.length;
+	if (count > MAX_DEPTH && isComplexType(Type)) throw new Error(`decodeU8aVec: Maximum depth exceeded, received ${count} elements, limit ${MAX_DEPTH}`);
+	let offset = startAt;
+	let i = 0;
+	try {
+		while (i < count) {
+			const value = new Type(registry, u8a.subarray(offset));
+			offset += value.initialU8aLength || value.encodedLength;
+			result[i] = value;
+			i++;
+		}
+	} catch (error) {
+		throw new Error(formatFailure(registry, "decodeU8aVec", result, error, u8a.subarray(offset), i, count, Type));
+	}
+	return [offset, offset - startAt];
+}
+
+//#endregion
+exports.decodeU8a = decodeU8a;
+exports.decodeU8aStruct = decodeU8aStruct;
+exports.decodeU8aVec = decodeU8aVec;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/sanitize.cjs

@@ -0,0 +1,180 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/sanitize.js
+const BOUNDED = [
+	"BTreeMap",
+	"BTreeSet",
+	"HashMap",
+	"Vec"
+];
+const ALLOWED_BOXES = BOUNDED.concat([
+	"Compact",
+	"DoNotConstruct",
+	"Int",
+	"Linkage",
+	"Range",
+	"RangeInclusive",
+	"Result",
+	"Opaque",
+	"Option",
+	"UInt",
+	"WrapperKeepOpaque",
+	"WrapperOpaque"
+]);
+const BOX_PRECEDING = [
+	"<",
+	"(",
+	"[",
+	"\"",
+	",",
+	" "
+];
+const mappings = [
+	alias("<T::InherentOfflineReport as InherentOfflineReport>::Inherent", "InherentOfflineReport", false),
+	alias("VecDeque<", "Vec<", false),
+	cleanupCompact(),
+	removeExtensions("Bounded", true),
+	removeExtensions("Weak", false),
+	removeTraits(),
+	removePairOf(),
+	removeWrap("Box<"),
+	removeGenerics(),
+	alias("String", "Text"),
+	alias("Vec<u8>", "Bytes"),
+	alias("&\\[u8\\]", "Bytes"),
+	alias("&'static\\[u8\\]", "Bytes"),
+	alias("RawAddress", "Address"),
+	alias("Lookup::Source", "LookupSource"),
+	alias("Lookup::Target", "LookupTarget"),
+	alias("exec::StorageKey", "ContractStorageKey"),
+	flattenSingleTuple(),
+	removeColons(),
+	trim()
+];
+function trim() {
+	return (value) => value.trim();
+}
+function findClosing(value, start) {
+	let depth = 0;
+	for (let i = start, count = value.length; i < count; i++) if (value[i] === ">") {
+		if (!depth) return i;
+		depth--;
+	} else if (value[i] === "<") depth++;
+	throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
+}
+function alias(src, dest, withChecks = true) {
+	const from = new RegExp(`(^${src}|${BOX_PRECEDING.map((box) => `\\${box}${src}`).join("|")})`, "g");
+	const to = (src) => {
+		from.lastIndex = 0;
+		return withChecks && BOX_PRECEDING.includes(src[0]) ? `${src[0]}${dest}` : dest;
+	};
+	return (value) => value.replace(from, to);
+}
+function cleanupCompact() {
+	return (value) => {
+		if (value.includes(" as HasCompact")) {
+			for (let i = 0, count = value.length; i < count; i++) if (value[i] === "<") {
+				const end = findClosing(value, i + 1) - 14;
+				if (value.substring(end, end + 14) === " as HasCompact") value = `Compact<${value.substring(i + 1, end)}>`;
+			}
+		}
+		return value;
+	};
+}
+function flattenSingleTuple() {
+	const from1 = /,\)/g;
+	const from2 = /\(([^,]+)\)/;
+	return (value) => {
+		from1.lastIndex = 0;
+		return value.replace(from1, ")").replace(from2, "$1");
+	};
+}
+function replaceTagWith(value, matcher, replacer) {
+	let index = -1;
+	while (true) {
+		index = value.indexOf(matcher, index + 1);
+		if (index === -1) return value;
+		const start = index + matcher.length;
+		const end = findClosing(value, start);
+		value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
+	}
+}
+function removeExtensions(type, isSized) {
+	return (value) => {
+		for (let i = 0, count = BOUNDED.length; i < count; i++) {
+			const tag = BOUNDED[i];
+			value = replaceTagWith(value, `${type}${tag}<`, (v) => {
+				const parts = v.split(",").map((s) => s.trim()).filter((s) => s);
+				if (isSized) parts.pop();
+				return `${tag}<${parts.join(",")}>`;
+			});
+		}
+		return value;
+	};
+}
+function removeColons() {
+	return (value) => {
+		let index = 0;
+		while (index !== -1) {
+			index = value.indexOf("::");
+			if (index === 0) value = value.substring(2);
+			else if (index !== -1) {
+				let start = index;
+				while (start !== -1 && !BOX_PRECEDING.includes(value[start])) start--;
+				value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
+			}
+		}
+		return value;
+	};
+}
+function removeGenerics() {
+	return (value) => {
+		for (let i = 0, count = value.length; i < count; i++) if (value[i] === "<") {
+			if (!ALLOWED_BOXES.find((box) => {
+				const start = i - box.length;
+				return start >= 0 && value.substring(start, i) === box && (start === 0 || BOX_PRECEDING.includes(value[start - 1]));
+			})) {
+				const end = findClosing(value, i + 1);
+				value = `${value.substring(0, i)}${value.substring(end + 1)}`;
+			}
+		}
+		return value;
+	};
+}
+function removePairOf() {
+	const replacer = (v) => `(${v},${v})`;
+	return (value) => replaceTagWith(value, "PairOf<", replacer);
+}
+function removeTraits() {
+	const from1 = /\s/g;
+	const from2 = /(T|Self)::/g;
+	const from3 = /<(T|Self)asTrait>::/g;
+	const from4 = /<Tas[a-z]+::Trait>::/g;
+	const from5 = /<LookupasStaticLookup>/g;
+	const from6 = /::Type/g;
+	return (value) => {
+		from1.lastIndex = 0;
+		from2.lastIndex = 0;
+		from3.lastIndex = 0;
+		from4.lastIndex = 0;
+		from5.lastIndex = 0;
+		from6.lastIndex = 0;
+		return value.replace(from1, "").replace(from2, "").replace(from3, "").replace(from4, "").replace(from5, "Lookup").replace(from6, "");
+	};
+}
+function removeWrap(check) {
+	const replacer = (v) => v;
+	return (value) => replaceTagWith(value, check, replacer);
+}
+const sanitizeMap = /* @__PURE__ */ new Map();
+function sanitize(value) {
+	const startValue = value.toString();
+	const memoized = sanitizeMap.get(startValue);
+	if (memoized) return memoized;
+	let result = startValue;
+	for (let i = 0, count = mappings.length; i < count; i++) result = mappings[i](result);
+	sanitizeMap.set(startValue, result);
+	return result;
+}
+
+//#endregion
+exports.sanitize = sanitize;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/sortValues.cjs

@@ -0,0 +1,70 @@
+const require_bn = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/bn.cjs');
+const require_bigInt = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/bigInt.cjs');
+const require_toBn = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/bn/toBn.cjs');
+const require_boolean = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/boolean.cjs');
+const require_codec = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/codec.cjs');
+const require_stringify = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/stringify.cjs');
+const require_number = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/number.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/sortValues.js
+/** @internal **/
+function isArrayLike(arg) {
+	return arg instanceof Uint8Array || Array.isArray(arg);
+}
+/** @internal **/
+function isEnum(arg) {
+	return require_codec.isCodec(arg) && require_number.isNumber(arg.index) && require_codec.isCodec(arg.value);
+}
+/** @internal **/
+function isOption(arg) {
+	return require_codec.isCodec(arg) && require_boolean.isBoolean(arg.isSome) && require_codec.isCodec(arg.value);
+}
+/** @internal */
+function isNumberLike(arg) {
+	return require_number.isNumber(arg) || require_bn.isBn(arg) || require_bigInt.isBigInt(arg);
+}
+/** @internal */
+function sortArray(a, b) {
+	let sortRes = 0;
+	const minLen = Math.min(a.length, b.length);
+	for (let i = 0; i < minLen; ++i) {
+		sortRes = sortAsc(a[i], b[i]);
+		if (sortRes !== 0) return sortRes;
+	}
+	return a.length - b.length;
+}
+/** @internal */
+function checkForDuplicates(container, seen, arg) {
+	if (require_codec.isCodec(arg)) {
+		const hex = arg.toHex();
+		if (seen.has(hex)) throw new Error(`Duplicate value in ${container}: ${require_stringify.stringify(arg)}`);
+		seen.add(hex);
+	}
+	return true;
+}
+/**
+* Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
+* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
+* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
+*/
+function sortAsc(a, b) {
+	if (isNumberLike(a) && isNumberLike(b)) return require_toBn.bnToBn(a).cmp(require_toBn.bnToBn(b));
+	else if (a instanceof Map && b instanceof Map) return sortAsc(Array.from(a.values()), Array.from(b.values()));
+	else if (isEnum(a) && isEnum(b)) return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
+	else if (isOption(a) && isOption(b)) return sortAsc(a.isNone ? 0 : 1, b.isNone ? 0 : 1) || sortAsc(a.value, b.value);
+	else if (isArrayLike(a) && isArrayLike(b)) return sortArray(a, b);
+	else if (require_codec.isCodec(a) && require_codec.isCodec(b)) return sortAsc(a.toU8a(true), b.toU8a(true));
+	throw new Error(`Attempting to sort unrecognized values: ${require_stringify.stringify(a)} (typeof ${typeof a}) <-> ${require_stringify.stringify(b)} (typeof ${typeof b})`);
+}
+function sortSet(set) {
+	const seen = /* @__PURE__ */ new Set();
+	return new Set(Array.from(set).filter((value) => checkForDuplicates("BTreeSet", seen, value)).sort(sortAsc));
+}
+function sortMap(map) {
+	const seen = /* @__PURE__ */ new Set();
+	return new Map(Array.from(map.entries()).filter(([key]) => checkForDuplicates("BTreeMap", seen, key)).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
+}
+
+//#endregion
+exports.sortMap = sortMap;
+exports.sortSet = sortSet;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/toConstructors.cjs

@@ -0,0 +1,38 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/toConstructors.js
+/**
+* @internal
+* From a type string or class, return the associated type class
+*/
+function typeToConstructor(registry, type) {
+	return typeof type === "function" ? type : registry.createClassUnsafe(type);
+}
+/**
+* @internal
+* Takes an input array of types and returns the associated classes for it
+*/
+function typesToConstructors(registry, types) {
+	const count = types.length;
+	const result = new Array(count);
+	for (let i = 0; i < count; i++) result[i] = typeToConstructor(registry, types[i]);
+	return result;
+}
+/**
+* @internal
+* Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
+*/
+function mapToTypeMap(registry, input) {
+	const entries = Object.entries(input);
+	const count = entries.length;
+	const output = [new Array(count), new Array(count)];
+	for (let i = 0; i < count; i++) {
+		output[1][i] = entries[i][0];
+		output[0][i] = typeToConstructor(registry, entries[i][1]);
+	}
+	return output;
+}
+
+//#endregion
+exports.mapToTypeMap = mapToTypeMap;
+exports.typeToConstructor = typeToConstructor;
+exports.typesToConstructors = typesToConstructors;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/typesToMap.cjs

@@ -0,0 +1,10 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/typesToMap.js
+function typesToMap(registry, [Types, keys]) {
+	const result = {};
+	for (let i = 0, count = keys.length; i < count; i++) result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
+	return result;
+}
+
+//#endregion
+exports.typesToMap = typesToMap;

package/dist/node_modules/.pnpm/@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/util.cjs

@@ -0,0 +1,9 @@
+const require_function = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/function.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/util.js
+function hasEq(o) {
+	return require_function.isFunction(o.eq);
+}
+
+//#endregion
+exports.hasEq = hasEq;