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

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/create/class.cjs

@@ -0,0 +1,147 @@
+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');
+const require_types = require('../types/types.cjs');
+const require_Compact = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Compact.cjs');
+const require_DoNotConstruct = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/DoNotConstruct.cjs');
+const require_Null = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Null.cjs');
+const require_Enum = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Enum.cjs');
+const require_Int = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Int.cjs');
+const require_Option = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Option.cjs');
+const require_Result = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Result.cjs');
+const require_Tuple = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Tuple.cjs');
+const require_UInt = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/UInt.cjs');
+const require_Vec = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Vec.cjs');
+const require_VecFixed = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/VecFixed.cjs');
+const require_Struct = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/native/Struct.cjs');
+const require_BTreeMap = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/BTreeMap.cjs');
+const require_BTreeSet = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/BTreeSet.cjs');
+const require_Bytes = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/Bytes.cjs');
+const require_HashMap = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/HashMap.cjs');
+const require_Range = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/Range.cjs');
+const require_RangeInclusive = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/RangeInclusive.cjs');
+const require_U8aFixed = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/U8aFixed.cjs');
+const require_WrapperKeepOpaque = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/WrapperKeepOpaque.cjs');
+const require_WrapperOpaque = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/extended/WrapperOpaque.cjs');
+const require_Set = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/native/Set.cjs');
+const require_getTypeDef = require('../util/getTypeDef.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/create/class.js
+function getTypeDefType({ lookupName, type }) {
+	return lookupName || type;
+}
+function getSubDefArray(value) {
+	if (!Array.isArray(value.sub)) throw new Error(`Expected subtype as TypeDef[] in ${require_stringify.stringify(value)}`);
+	return value.sub;
+}
+function getSubDef(value) {
+	if (!value.sub || Array.isArray(value.sub)) throw new Error(`Expected subtype as TypeDef in ${require_stringify.stringify(value)}`);
+	return value.sub;
+}
+function getSubType(value) {
+	return getTypeDefType(getSubDef(value));
+}
+function getTypeClassMap(value) {
+	const subs = getSubDefArray(value);
+	const map = {};
+	for (let i = 0, count = subs.length; i < count; i++) {
+		const sub = subs[i];
+		if (!sub.name) throw new Error(`No name found in definition ${require_stringify.stringify(sub)}`);
+		map[sub.name] = getTypeDefType(sub);
+	}
+	return map;
+}
+function getTypeClassArray(value) {
+	return getSubDefArray(value).map(getTypeDefType);
+}
+function createInt(Clazz, { displayName, length }) {
+	if (!require_number.isNumber(length)) throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+	return Clazz.with(length, displayName);
+}
+function createHashMap(Clazz, value) {
+	const [keyType, valueType] = getTypeClassArray(value);
+	return Clazz.with(keyType, valueType);
+}
+function createWithSub(Clazz, value) {
+	return Clazz.with(getSubType(value));
+}
+const infoMapping = {
+	[require_types.TypeDefInfo.BTreeMap]: (_registry, value) => createHashMap(require_BTreeMap.BTreeMap, value),
+	[require_types.TypeDefInfo.BTreeSet]: (_registry, value) => createWithSub(require_BTreeSet.BTreeSet, value),
+	[require_types.TypeDefInfo.Compact]: (_registry, value) => createWithSub(require_Compact.Compact, value),
+	[require_types.TypeDefInfo.DoNotConstruct]: (_registry, value) => require_DoNotConstruct.DoNotConstruct.with(value.displayName || value.type),
+	[require_types.TypeDefInfo.Enum]: (_registry, value) => {
+		const subs = getSubDefArray(value);
+		return require_Enum.Enum.with(subs.every(({ type }) => type === "Null") ? subs.reduce((out, { index, name }, count) => {
+			if (!name) throw new Error("No name found in sub definition");
+			out[name] = index || count;
+			return out;
+		}, {}) : getTypeClassMap(value));
+	},
+	[require_types.TypeDefInfo.HashMap]: (_registry, value) => createHashMap(require_HashMap.HashMap, value),
+	[require_types.TypeDefInfo.Int]: (_registry, value) => createInt(require_Int.Int, value),
+	[require_types.TypeDefInfo.Linkage]: (_registry, value) => {
+		const type = `Option<${getSubType(value)}>`;
+		const Clazz = require_Struct.Struct.with({
+			previous: type,
+			next: type
+		});
+		Clazz.prototype.toRawType = function() {
+			return `Linkage<${this.next.toRawType(true)}>`;
+		};
+		return Clazz;
+	},
+	[require_types.TypeDefInfo.Null]: (_registry, _value) => require_Null.Null,
+	[require_types.TypeDefInfo.Option]: (_registry, value) => {
+		if (!value.sub || Array.isArray(value.sub)) throw new Error("Expected type information for Option");
+		return createWithSub(require_Option.Option, value);
+	},
+	[require_types.TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
+	[require_types.TypeDefInfo.Range]: (_registry, value) => createWithSub(require_Range.Range, value),
+	[require_types.TypeDefInfo.RangeInclusive]: (_registry, value) => createWithSub(require_RangeInclusive.RangeInclusive, value),
+	[require_types.TypeDefInfo.Result]: (_registry, value) => {
+		const [Ok, Err] = getTypeClassArray(value);
+		return require_Result.Result.with({
+			Err,
+			Ok
+		});
+	},
+	[require_types.TypeDefInfo.Set]: (_registry, value) => require_Set.CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
+		if (!name || !require_number.isNumber(index)) throw new Error("No name found in sub definition");
+		result[name] = index;
+		return result;
+	}, {}), value.length),
+	[require_types.TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
+	[require_types.TypeDefInfo.Struct]: (_registry, value) => require_Struct.Struct.with(getTypeClassMap(value), value.alias),
+	[require_types.TypeDefInfo.Tuple]: (_registry, value) => require_Tuple.Tuple.with(getTypeClassArray(value)),
+	[require_types.TypeDefInfo.UInt]: (_registry, value) => createInt(require_UInt.UInt, value),
+	[require_types.TypeDefInfo.Vec]: (_registry, { sub }) => {
+		if (!sub || Array.isArray(sub)) throw new Error("Expected type information for vector");
+		return sub.type === "u8" ? require_Bytes.Bytes : require_Vec.Vec.with(getTypeDefType(sub));
+	},
+	[require_types.TypeDefInfo.VecFixed]: (_registry, { displayName, length, sub }) => {
+		if (!require_number.isNumber(length) || !sub || Array.isArray(sub)) throw new Error("Expected length & type information for fixed vector");
+		return sub.type === "u8" ? require_U8aFixed.U8aFixed.with(length * 8, displayName) : require_VecFixed.VecFixed.with(getTypeDefType(sub), length);
+	},
+	[require_types.TypeDefInfo.WrapperKeepOpaque]: (_registry, value) => createWithSub(require_WrapperKeepOpaque.WrapperKeepOpaque, value),
+	[require_types.TypeDefInfo.WrapperOpaque]: (_registry, value) => createWithSub(require_WrapperOpaque.WrapperOpaque, value)
+};
+function constructTypeClass(registry, typeDef) {
+	try {
+		const Type = infoMapping[typeDef.info](registry, typeDef);
+		if (!Type) throw new Error("No class created");
+		if (!Type.__fallbackType && typeDef.fallbackType) Type.__fallbackType = typeDef.fallbackType;
+		return Type;
+	} catch (error) {
+		throw new Error(`Unable to construct class from ${require_stringify.stringify(typeDef)}: ${error.message}`);
+	}
+}
+function getTypeClass(registry, typeDef) {
+	return registry.getUnsafe(typeDef.type, false, typeDef);
+}
+function createClassUnsafe(registry, type) {
+	return registry.getUnsafe(type) || getTypeClass(registry, registry.isLookupType(type) ? registry.lookup.getTypeDef(type) : require_getTypeDef.getTypeDef(type));
+}
+
+//#endregion
+exports.constructTypeClass = constructTypeClass;
+exports.createClassUnsafe = createClassUnsafe;

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/create/type.cjs

@@ -0,0 +1,47 @@
+const require_hex = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/hex.cjs');
+const require_u8a = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/u8a.cjs');
+const require_toU8a = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toU8a.cjs');
+const require_eq = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/eq.cjs');
+const require_toHex = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/u8a/toHex.cjs');
+const require_Option = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/base/Option.cjs');
+const require_class = require('./class.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/create/type.js
+function checkInstance(created, matcher) {
+	const u8a = created.toU8a();
+	const rawType = created.toRawType();
+	if (!(require_eq.u8aEq(u8a, matcher) || [
+		"Bytes",
+		"Text",
+		"Type"
+	].includes(rawType) && matcher.length === created.length || created.isEmpty && matcher.every((v) => !v))) throw new Error(`${rawType}:: Decoded input doesn't match input, received ${require_toHex.u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${require_toHex.u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
+}
+function checkPedantic(created, [value]) {
+	if (require_u8a.isU8a(value)) checkInstance(created, value);
+	else if (require_hex.isHex(value)) checkInstance(created, require_toU8a.u8aToU8a(value));
+}
+function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
+	const created = new (isOptional ? require_Option.Option.with(Type) : Type)(registry, ...params);
+	isPedantic && checkPedantic(created, params);
+	if (blockHash) created.createdAtHash = createTypeUnsafe(registry, "BlockHash", [blockHash]);
+	if (isFallback) created.isStorageFallback = true;
+	return created;
+}
+function createTypeUnsafe(registry, type, params = [], options = {}) {
+	let Clazz = null;
+	let firstError = null;
+	try {
+		Clazz = require_class.createClassUnsafe(registry, type);
+		return initType(registry, Clazz, params, options);
+	} catch (error) {
+		firstError = /* @__PURE__ */ new Error(`createType(${type}):: ${error.message}`);
+	}
+	if (Clazz?.__fallbackType) try {
+		Clazz = require_class.createClassUnsafe(registry, Clazz.__fallbackType);
+		return initType(registry, Clazz, params, options);
+	} catch {}
+	throw firstError;
+}
+
+//#endregion
+exports.createTypeUnsafe = createTypeUnsafe;

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/types/types.cjs

@@ -0,0 +1,36 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/types/types.js
+var TypeDefInfo;
+(function(TypeDefInfo) {
+	TypeDefInfo[TypeDefInfo["BTreeMap"] = 0] = "BTreeMap";
+	TypeDefInfo[TypeDefInfo["BTreeSet"] = 1] = "BTreeSet";
+	TypeDefInfo[TypeDefInfo["Compact"] = 2] = "Compact";
+	TypeDefInfo[TypeDefInfo["DoNotConstruct"] = 3] = "DoNotConstruct";
+	TypeDefInfo[TypeDefInfo["Enum"] = 4] = "Enum";
+	TypeDefInfo[TypeDefInfo["HashMap"] = 5] = "HashMap";
+	TypeDefInfo[TypeDefInfo["Int"] = 6] = "Int";
+	TypeDefInfo[TypeDefInfo["Linkage"] = 7] = "Linkage";
+	TypeDefInfo[TypeDefInfo["Null"] = 8] = "Null";
+	TypeDefInfo[TypeDefInfo["Option"] = 9] = "Option";
+	TypeDefInfo[TypeDefInfo["Plain"] = 10] = "Plain";
+	TypeDefInfo[TypeDefInfo["Range"] = 11] = "Range";
+	TypeDefInfo[TypeDefInfo["RangeInclusive"] = 12] = "RangeInclusive";
+	TypeDefInfo[TypeDefInfo["Result"] = 13] = "Result";
+	TypeDefInfo[TypeDefInfo["Set"] = 14] = "Set";
+	TypeDefInfo[TypeDefInfo["Si"] = 15] = "Si";
+	TypeDefInfo[TypeDefInfo["Struct"] = 16] = "Struct";
+	TypeDefInfo[TypeDefInfo["Tuple"] = 17] = "Tuple";
+	TypeDefInfo[TypeDefInfo["UInt"] = 18] = "UInt";
+	TypeDefInfo[TypeDefInfo["Vec"] = 19] = "Vec";
+	TypeDefInfo[TypeDefInfo["VecFixed"] = 20] = "VecFixed";
+	TypeDefInfo[TypeDefInfo["WrapperKeepOpaque"] = 21] = "WrapperKeepOpaque";
+	TypeDefInfo[TypeDefInfo["WrapperOpaque"] = 22] = "WrapperOpaque";
+})(TypeDefInfo || (TypeDefInfo = {}));
+
+//#endregion
+Object.defineProperty(exports, 'TypeDefInfo', {
+  enumerable: true,
+  get: function () {
+    return TypeDefInfo;
+  }
+});

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/util/encodeTypes.cjs

@@ -0,0 +1,101 @@
+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');
+const require_undefined = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/undefined.cjs');
+const require_spread = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/object/spread.cjs');
+const require_types = require('../types/types.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/util/encodeTypes.js
+const stringIdentity = (value) => value.toString();
+const INFO_WRAP = [
+	"BTreeMap",
+	"BTreeSet",
+	"Compact",
+	"HashMap",
+	"Option",
+	"Result",
+	"Vec"
+];
+function paramsNotation(outer, inner, transform = stringIdentity) {
+	return `${outer}${inner ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(", ")}>` : ""}`;
+}
+function encodeWithParams(registry, typeDef, outer) {
+	const { info, sub } = typeDef;
+	switch (info) {
+		case require_types.TypeDefInfo.BTreeMap:
+		case require_types.TypeDefInfo.BTreeSet:
+		case require_types.TypeDefInfo.Compact:
+		case require_types.TypeDefInfo.HashMap:
+		case require_types.TypeDefInfo.Linkage:
+		case require_types.TypeDefInfo.Option:
+		case require_types.TypeDefInfo.Range:
+		case require_types.TypeDefInfo.RangeInclusive:
+		case require_types.TypeDefInfo.Result:
+		case require_types.TypeDefInfo.Vec:
+		case require_types.TypeDefInfo.WrapperKeepOpaque:
+		case require_types.TypeDefInfo.WrapperOpaque: return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
+	}
+	throw new Error(`Unable to encode ${require_stringify.stringify(typeDef)} with params`);
+}
+function encodeSubTypes(registry, sub, asEnum, extra) {
+	const names = sub.map(({ name }) => name);
+	if (!names.every((n) => !!n)) throw new Error(`Subtypes does not have consistent names, ${names.join(", ")}`);
+	const inner = require_spread.objectSpread({}, extra);
+	for (let i = 0, count = sub.length; i < count; i++) {
+		const def = sub[i];
+		if (!def.name) throw new Error(`No name found in ${require_stringify.stringify(def)}`);
+		inner[def.name] = encodeTypeDef(registry, def);
+	}
+	return require_stringify.stringify(asEnum ? { _enum: inner } : inner);
+}
+const encoders = {
+	[require_types.TypeDefInfo.BTreeMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, "BTreeMap"),
+	[require_types.TypeDefInfo.BTreeSet]: (registry, typeDef) => encodeWithParams(registry, typeDef, "BTreeSet"),
+	[require_types.TypeDefInfo.Compact]: (registry, typeDef) => encodeWithParams(registry, typeDef, "Compact"),
+	[require_types.TypeDefInfo.DoNotConstruct]: (registry, { displayName, lookupIndex, lookupName }) => `DoNotConstruct<${lookupName || displayName || (require_undefined.isUndefined(lookupIndex) ? "Unknown" : registry.createLookupType(lookupIndex))}>`,
+	[require_types.TypeDefInfo.Enum]: (registry, { sub }) => {
+		if (!Array.isArray(sub)) throw new Error("Unable to encode Enum type");
+		return sub.every(({ type }) => type === "Null") ? require_stringify.stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) }) : encodeSubTypes(registry, sub, true);
+	},
+	[require_types.TypeDefInfo.HashMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, "HashMap"),
+	[require_types.TypeDefInfo.Int]: (_registry, { length = 32 }) => `Int<${length}>`,
+	[require_types.TypeDefInfo.Linkage]: (registry, typeDef) => encodeWithParams(registry, typeDef, "Linkage"),
+	[require_types.TypeDefInfo.Null]: (_registry, _typeDef) => "Null",
+	[require_types.TypeDefInfo.Option]: (registry, typeDef) => encodeWithParams(registry, typeDef, "Option"),
+	[require_types.TypeDefInfo.Plain]: (_registry, { displayName, type }) => displayName || type,
+	[require_types.TypeDefInfo.Range]: (registry, typeDef) => encodeWithParams(registry, typeDef, "Range"),
+	[require_types.TypeDefInfo.RangeInclusive]: (registry, typeDef) => encodeWithParams(registry, typeDef, "RangeInclusive"),
+	[require_types.TypeDefInfo.Result]: (registry, typeDef) => encodeWithParams(registry, typeDef, "Result"),
+	[require_types.TypeDefInfo.Set]: (_registry, { length = 8, sub }) => {
+		if (!Array.isArray(sub)) throw new Error("Unable to encode Set type");
+		return require_stringify.stringify({ _set: sub.reduce((all, { index, name }, count) => require_spread.objectSpread(all, { [`${name || `Unknown${index || count}`}`]: index || count }), { _bitLength: length || 8 }) });
+	},
+	[require_types.TypeDefInfo.Si]: (_registry, { lookupName, type }) => lookupName || type,
+	[require_types.TypeDefInfo.Struct]: (registry, { alias, sub }) => {
+		if (!Array.isArray(sub)) throw new Error("Unable to encode Struct type");
+		return encodeSubTypes(registry, sub, false, alias ? { _alias: [...alias.entries()].reduce((all, [k, v]) => require_spread.objectSpread(all, { [k]: v }), {}) } : {});
+	},
+	[require_types.TypeDefInfo.Tuple]: (registry, { sub }) => {
+		if (!Array.isArray(sub)) throw new Error("Unable to encode Tuple type");
+		return `(${sub.map((type) => encodeTypeDef(registry, type)).join(",")})`;
+	},
+	[require_types.TypeDefInfo.UInt]: (_registry, { length = 32 }) => `UInt<${length}>`,
+	[require_types.TypeDefInfo.Vec]: (registry, typeDef) => encodeWithParams(registry, typeDef, "Vec"),
+	[require_types.TypeDefInfo.VecFixed]: (_registry, { length, sub }) => {
+		if (!require_number.isNumber(length) || !sub || Array.isArray(sub)) throw new Error("Unable to encode VecFixed type");
+		return `[${sub.type};${length}]`;
+	},
+	[require_types.TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, "WrapperKeepOpaque"),
+	[require_types.TypeDefInfo.WrapperOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, "WrapperOpaque")
+};
+function encodeType(registry, typeDef, withLookup = true) {
+	return withLookup && typeDef.lookupName ? typeDef.lookupName : encoders[typeDef.info](registry, typeDef);
+}
+function encodeTypeDef(registry, typeDef) {
+	return typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i) ? typeDef.displayName : encodeType(registry, typeDef);
+}
+function withTypeString(registry, typeDef) {
+	return require_spread.objectSpread({}, typeDef, { type: encodeType(registry, typeDef, false) });
+}
+
+//#endregion
+exports.withTypeString = withTypeString;

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/util/getTypeDef.cjs

@@ -0,0 +1,250 @@
+const require_string = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/is/string.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');
+const require_spread = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/object/spread.cjs');
+const require_types = require('../types/types.cjs');
+const require_sanitize = require('../../../../../@polkadot_types-codec@16.5.4/node_modules/@polkadot/types-codec/utils/sanitize.cjs');
+const require_typeSplit = require('./typeSplit.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/util/getTypeDef.js
+const KNOWN_INTERNALS = ["_alias", "_fallback"];
+function getTypeString(typeOrObj) {
+	return require_string.isString(typeOrObj) ? typeOrObj.toString() : require_stringify.stringify(typeOrObj);
+}
+function isRustEnum(details) {
+	const values = Object.values(details);
+	if (values.some((v) => require_number.isNumber(v))) {
+		if (!values.every((v) => require_number.isNumber(v) && v >= 0 && v <= 255)) throw new Error("Invalid number-indexed enum definition");
+		return false;
+	}
+	return true;
+}
+function _decodeEnum(value, details, count, fallbackType) {
+	value.info = require_types.TypeDefInfo.Enum;
+	value.fallbackType = fallbackType;
+	if (Array.isArray(details)) value.sub = details.map((name, index) => ({
+		index,
+		info: require_types.TypeDefInfo.Plain,
+		name,
+		type: "Null"
+	}));
+	else if (isRustEnum(details)) value.sub = Object.entries(details).map(([name, typeOrObj], index) => require_spread.objectSpread({}, getTypeDef(getTypeString(typeOrObj || "Null"), { name }, count), { index }));
+	else value.sub = Object.entries(details).map(([name, index]) => ({
+		index,
+		info: require_types.TypeDefInfo.Plain,
+		name,
+		type: "Null"
+	}));
+	return value;
+}
+function _decodeSet(value, details, fallbackType) {
+	value.info = require_types.TypeDefInfo.Set;
+	value.fallbackType = fallbackType;
+	value.length = details._bitLength;
+	value.sub = Object.entries(details).filter(([name]) => !name.startsWith("_")).map(([name, index]) => ({
+		index,
+		info: require_types.TypeDefInfo.Plain,
+		name,
+		type: "Null"
+	}));
+	return value;
+}
+function _decodeStruct(value, type, _, count) {
+	const parsed = JSON.parse(type);
+	const keys = Object.keys(parsed);
+	if (parsed._enum) return _decodeEnum(value, parsed._enum, count, parsed._fallback);
+	else if (parsed._set) return _decodeSet(value, parsed._set, parsed._fallback);
+	value.alias = parsed._alias ? new Map(Object.entries(parsed._alias)) : void 0;
+	value.fallbackType = parsed._fallback;
+	value.sub = keys.filter((name) => !KNOWN_INTERNALS.includes(name)).map((name) => getTypeDef(getTypeString(parsed[name]), { name }, count));
+	return value;
+}
+function _decodeFixedVec(value, type, _, count) {
+	const max = type.length - 1;
+	let index = -1;
+	let inner = 0;
+	for (let i = 1; i < max && index === -1; i++) switch (type[i]) {
+		case ";":
+			if (inner === 0) index = i;
+			break;
+		case "[":
+		case "(":
+		case "<":
+			inner++;
+			break;
+		case "]":
+		case ")":
+		case ">":
+			inner--;
+			break;
+	}
+	if (index === -1) throw new Error(`${type}: Unable to extract location of ';'`);
+	const vecType = type.substring(1, index);
+	const [strLength, displayName] = type.substring(index + 1, max).split(";");
+	const length = parseInt(strLength.trim(), 10);
+	if (length > 2048) throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
+	value.displayName = displayName;
+	value.length = length;
+	value.sub = getTypeDef(vecType, {}, count);
+	return value;
+}
+function _decodeTuple(value, _, subType, count) {
+	value.sub = subType.length === 0 ? [] : require_typeSplit.typeSplit(subType).map((inner) => getTypeDef(inner, {}, count));
+	return value;
+}
+function _decodeAnyInt(value, type, _, clazz) {
+	const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(",");
+	const length = parseInt(strLength.trim(), 10);
+	if (length > 8192 || length % 8) throw new Error(`${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
+	value.displayName = displayName;
+	value.length = length;
+	return value;
+}
+function _decodeInt(value, type, subType) {
+	return _decodeAnyInt(value, type, subType, "Int");
+}
+function _decodeUInt(value, type, subType) {
+	return _decodeAnyInt(value, type, subType, "UInt");
+}
+function _decodeDoNotConstruct(value, type, _) {
+	value.displayName = type.substring(15, type.length - 1);
+	return value;
+}
+function hasWrapper(type, [start, end]) {
+	return type.startsWith(start) && type.slice(-1 * end.length) === end;
+}
+const nestedExtraction = [
+	[
+		"[",
+		"]",
+		require_types.TypeDefInfo.VecFixed,
+		_decodeFixedVec
+	],
+	[
+		"{",
+		"}",
+		require_types.TypeDefInfo.Struct,
+		_decodeStruct
+	],
+	[
+		"(",
+		")",
+		require_types.TypeDefInfo.Tuple,
+		_decodeTuple
+	],
+	[
+		"BTreeMap<",
+		">",
+		require_types.TypeDefInfo.BTreeMap,
+		_decodeTuple
+	],
+	[
+		"HashMap<",
+		">",
+		require_types.TypeDefInfo.HashMap,
+		_decodeTuple
+	],
+	[
+		"Int<",
+		">",
+		require_types.TypeDefInfo.Int,
+		_decodeInt
+	],
+	[
+		"Result<",
+		">",
+		require_types.TypeDefInfo.Result,
+		_decodeTuple
+	],
+	[
+		"UInt<",
+		">",
+		require_types.TypeDefInfo.UInt,
+		_decodeUInt
+	],
+	[
+		"DoNotConstruct<",
+		">",
+		require_types.TypeDefInfo.DoNotConstruct,
+		_decodeDoNotConstruct
+	]
+];
+const wrappedExtraction = [
+	[
+		"BTreeSet<",
+		">",
+		require_types.TypeDefInfo.BTreeSet
+	],
+	[
+		"Compact<",
+		">",
+		require_types.TypeDefInfo.Compact
+	],
+	[
+		"Linkage<",
+		">",
+		require_types.TypeDefInfo.Linkage
+	],
+	[
+		"Opaque<",
+		">",
+		require_types.TypeDefInfo.WrapperOpaque
+	],
+	[
+		"Option<",
+		">",
+		require_types.TypeDefInfo.Option
+	],
+	[
+		"Range<",
+		">",
+		require_types.TypeDefInfo.Range
+	],
+	[
+		"RangeInclusive<",
+		">",
+		require_types.TypeDefInfo.RangeInclusive
+	],
+	[
+		"Vec<",
+		">",
+		require_types.TypeDefInfo.Vec
+	],
+	[
+		"WrapperKeepOpaque<",
+		">",
+		require_types.TypeDefInfo.WrapperKeepOpaque
+	],
+	[
+		"WrapperOpaque<",
+		">",
+		require_types.TypeDefInfo.WrapperOpaque
+	]
+];
+function extractSubType(type, [start, end]) {
+	return type.substring(start.length, type.length - end.length);
+}
+function getTypeDef(_type, { displayName, name } = {}, count = 0) {
+	const type = require_sanitize.sanitize(_type);
+	const value = {
+		displayName,
+		info: require_types.TypeDefInfo.Plain,
+		name,
+		type
+	};
+	if (++count > 64) throw new Error("getTypeDef: Maximum nested limit reached");
+	const nested = nestedExtraction.find((nested) => hasWrapper(type, nested));
+	if (nested) {
+		value.info = nested[2];
+		return nested[3](value, type, extractSubType(type, nested), count);
+	}
+	const wrapped = wrappedExtraction.find((wrapped) => hasWrapper(type, wrapped));
+	if (wrapped) {
+		value.info = wrapped[2];
+		value.sub = getTypeDef(extractSubType(type, wrapped), {}, count);
+	}
+	return value;
+}
+
+//#endregion
+exports.getTypeDef = getTypeDef;

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/util/typeSplit.cjs

@@ -0,0 +1,48 @@
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/util/typeSplit.js
+function typeSplit(type) {
+	const result = [];
+	let c = 0;
+	let f = 0;
+	let s = 0;
+	let t = 0;
+	let start = 0;
+	for (let i = 0, count = type.length; i < count; i++) switch (type[i]) {
+		case ",":
+			if (!(c || f || s || t)) {
+				result.push(type.substring(start, i).trim());
+				start = i + 1;
+			}
+			break;
+		case "<":
+			c++;
+			break;
+		case ">":
+			c--;
+			break;
+		case "[":
+			f++;
+			break;
+		case "]":
+			f--;
+			break;
+		case "{":
+			s++;
+			break;
+		case "}":
+			s--;
+			break;
+		case "(":
+			t++;
+			break;
+		case ")":
+			t--;
+			break;
+	}
+	if (c || f || s || t) throw new Error(`Invalid definition (missing terminators) found in ${type}`);
+	result.push(type.substring(start, type.length).trim());
+	return result;
+}
+
+//#endregion
+exports.typeSplit = typeSplit;

package/dist/node_modules/.pnpm/@polkadot_types-create@16.5.4/node_modules/@polkadot/types-create/util/xcm.cjs

@@ -0,0 +1,23 @@
+const require_spread = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/object/spread.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types-create@16.5.4/node_modules/@polkadot/types-create/util/xcm.js
+const XCM_MAPPINGS = [
+	"AssetInstance",
+	"Fungibility",
+	"Junction",
+	"Junctions",
+	"MultiAsset",
+	"MultiAssetFilter",
+	"MultiLocation",
+	"Response",
+	"WildFungibility",
+	"WildMultiAsset",
+	"Xcm",
+	"XcmError"
+];
+function mapXcmTypes(version) {
+	return XCM_MAPPINGS.reduce((all, key) => require_spread.objectSpread(all, { [key]: `${key}${version}` }), {});
+}
+
+//#endregion
+exports.mapXcmTypes = mapXcmTypes;

package/dist/node_modules/.pnpm/@polkadot_types@16.5.4/node_modules/@polkadot/types/create/lazy.cjs

@@ -0,0 +1,12 @@
+const require_lazy = require('../../../../../@polkadot_util@14.0.1/node_modules/@polkadot/util/lazy.cjs');
+
+//#region ../../node_modules/.pnpm/@polkadot+types@16.5.4/node_modules/@polkadot/types/create/lazy.js
+function lazyVariants(lookup, { type }, getName, creator) {
+	const result = {};
+	const variants = lookup.getSiType(type).def.asVariant.variants;
+	for (let i = 0, count = variants.length; i < count; i++) require_lazy.lazyMethod(result, variants[i], creator, getName, i);
+	return result;
+}
+
+//#endregion
+exports.lazyVariants = lazyVariants;