@pezkuwi/types-codec 16.5.5 → 16.5.6

package/cjs/primitive/U8.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.u8 = void 0;
+const UInt_js_1 = require("../base/UInt.js");
+/**
+ * @name u8
+ * @description
+ * An 8-bit unsigned integer
+ */
+class u8 extends UInt_js_1.UInt.with(8) {
+    // NOTE without this, we cannot properly determine extensions
+    __UIntType = 'u8';
+}
+exports.u8 = u8;

package/cjs/primitive/USize.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usize = void 0;
+const U32_js_1 = require("./U32.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.
+ */
+class usize extends U32_js_1.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.');
+    }
+}
+exports.usize = usize;

package/cjs/primitive/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usize = exports.USize = exports.u256 = exports.U256 = exports.u128 = exports.U128 = exports.u64 = exports.U64 = exports.u32 = exports.U32 = exports.u16 = exports.U16 = exports.u8 = exports.U8 = exports.isize = exports.ISize = exports.i256 = exports.I256 = exports.i128 = exports.I128 = exports.i64 = exports.I64 = exports.i32 = exports.I32 = exports.i16 = exports.I16 = exports.i8 = exports.I8 = exports.f64 = exports.F64 = exports.f32 = exports.F32 = void 0;
+var F32_js_1 = require("./F32.js");
+Object.defineProperty(exports, "F32", { enumerable: true, get: function () { return F32_js_1.f32; } });
+Object.defineProperty(exports, "f32", { enumerable: true, get: function () { return F32_js_1.f32; } });
+var F64_js_1 = require("./F64.js");
+Object.defineProperty(exports, "F64", { enumerable: true, get: function () { return F64_js_1.f64; } });
+Object.defineProperty(exports, "f64", { enumerable: true, get: function () { return F64_js_1.f64; } });
+var I8_js_1 = require("./I8.js");
+Object.defineProperty(exports, "I8", { enumerable: true, get: function () { return I8_js_1.i8; } });
+Object.defineProperty(exports, "i8", { enumerable: true, get: function () { return I8_js_1.i8; } });
+var I16_js_1 = require("./I16.js");
+Object.defineProperty(exports, "I16", { enumerable: true, get: function () { return I16_js_1.i16; } });
+Object.defineProperty(exports, "i16", { enumerable: true, get: function () { return I16_js_1.i16; } });
+var I32_js_1 = require("./I32.js");
+Object.defineProperty(exports, "I32", { enumerable: true, get: function () { return I32_js_1.i32; } });
+Object.defineProperty(exports, "i32", { enumerable: true, get: function () { return I32_js_1.i32; } });
+var I64_js_1 = require("./I64.js");
+Object.defineProperty(exports, "I64", { enumerable: true, get: function () { return I64_js_1.i64; } });
+Object.defineProperty(exports, "i64", { enumerable: true, get: function () { return I64_js_1.i64; } });
+var I128_js_1 = require("./I128.js");
+Object.defineProperty(exports, "I128", { enumerable: true, get: function () { return I128_js_1.i128; } });
+Object.defineProperty(exports, "i128", { enumerable: true, get: function () { return I128_js_1.i128; } });
+var I256_js_1 = require("./I256.js");
+Object.defineProperty(exports, "I256", { enumerable: true, get: function () { return I256_js_1.i256; } });
+Object.defineProperty(exports, "i256", { enumerable: true, get: function () { return I256_js_1.i256; } });
+var ISize_js_1 = require("./ISize.js");
+Object.defineProperty(exports, "ISize", { enumerable: true, get: function () { return ISize_js_1.isize; } });
+Object.defineProperty(exports, "isize", { enumerable: true, get: function () { return ISize_js_1.isize; } });
+var U8_js_1 = require("./U8.js");
+Object.defineProperty(exports, "U8", { enumerable: true, get: function () { return U8_js_1.u8; } });
+Object.defineProperty(exports, "u8", { enumerable: true, get: function () { return U8_js_1.u8; } });
+var U16_js_1 = require("./U16.js");
+Object.defineProperty(exports, "U16", { enumerable: true, get: function () { return U16_js_1.u16; } });
+Object.defineProperty(exports, "u16", { enumerable: true, get: function () { return U16_js_1.u16; } });
+var U32_js_1 = require("./U32.js");
+Object.defineProperty(exports, "U32", { enumerable: true, get: function () { return U32_js_1.u32; } });
+Object.defineProperty(exports, "u32", { enumerable: true, get: function () { return U32_js_1.u32; } });
+var U64_js_1 = require("./U64.js");
+Object.defineProperty(exports, "U64", { enumerable: true, get: function () { return U64_js_1.u64; } });
+Object.defineProperty(exports, "u64", { enumerable: true, get: function () { return U64_js_1.u64; } });
+var U128_js_1 = require("./U128.js");
+Object.defineProperty(exports, "U128", { enumerable: true, get: function () { return U128_js_1.u128; } });
+Object.defineProperty(exports, "u128", { enumerable: true, get: function () { return U128_js_1.u128; } });
+var U256_js_1 = require("./U256.js");
+Object.defineProperty(exports, "U256", { enumerable: true, get: function () { return U256_js_1.u256; } });
+Object.defineProperty(exports, "u256", { enumerable: true, get: function () { return U256_js_1.u256; } });
+var USize_js_1 = require("./USize.js");
+Object.defineProperty(exports, "USize", { enumerable: true, get: function () { return USize_js_1.usize; } });
+Object.defineProperty(exports, "usize", { enumerable: true, get: function () { return USize_js_1.usize; } });

package/{build → cjs}/types/codec.d.ts

@@ -37,7 +37,7 @@ export interface Codec {
      *
      * With metadata fallback values (available as defaults on most storage entries)
      * any empty storage item should erturn the default. (This is the same as the
-     * implementation on the Substrate runtime)
+     * implementation on the Bizinikiwi runtime)
      */
     isStorageFallback?: boolean;
     /**

package/cjs/types/codec.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./codec.js"), exports);
+tslib_1.__exportStar(require("./helpers.js"), exports);
+tslib_1.__exportStar(require("./interfaces.js"), exports);
+tslib_1.__exportStar(require("./registry.js"), exports);

package/cjs/types/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/registry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils/compareArray.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareArray = compareArray;
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("./util.js");
+function compareArray(a, b) {
+    if (Array.isArray(b)) {
+        return (a.length === b.length) && (0, util_1.isUndefined)(a.find((v, index) => (0, util_js_1.hasEq)(v)
+            ? !v.eq(b[index])
+            : v !== b[index]));
+    }
+    return false;
+}

package/cjs/utils/compareMap.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareMap = compareMap;
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("./util.js");
+function hasMismatch(a, b) {
+    return (0, util_1.isUndefined)(a) || ((0, util_js_1.hasEq)(a)
+        ? !a.eq(b)
+        : a !== b);
+}
+function notEntry(value) {
+    return !Array.isArray(value) || value.length !== 2;
+}
+function compareMapArray(a, b) {
+    // equal number of entries and each entry in the array should match
+    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 ((0, util_1.isObject)(b)) {
+        return compareMapArray(a, Object.entries(b));
+    }
+    return false;
+}

package/cjs/utils/compareSet.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSet = compareSet;
+const util_1 = require("@pezkuwi/util");
+function compareSetArray(a, b) {
+    // equal number of entries and each entry in the array should match
+    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 ((0, util_1.isObject)(b)) {
+        return compareSetArray(a, Object.values(b));
+    }
+    return false;
+}

package/cjs/utils/decodeU8a.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeU8a = decodeU8a;
+exports.decodeU8aStruct = decodeU8aStruct;
+exports.decodeU8aVec = decodeU8aVec;
+const util_1 = require("@pezkuwi/util");
+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 {
+        // ignore
+    }
+    // This is extra debugging info (we most-probably want this in in some way, shape or form,
+    // but at this point not quite sure how to include and format it (it can be quite massive)
+    // console.error(JSON.stringify(result, null, 2));
+    return `${fn}: failed at ${(0, util_1.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];
+}

package/cjs/utils/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typesToMap = exports.typeToConstructor = exports.typesToConstructors = exports.mapToTypeMap = exports.sortSet = exports.sortMap = exports.sortAsc = exports.sanitize = exports.decodeU8aVec = exports.decodeU8aStruct = exports.decodeU8a = exports.compareSet = exports.compareMap = exports.compareArray = void 0;
+var compareArray_js_1 = require("./compareArray.js");
+Object.defineProperty(exports, "compareArray", { enumerable: true, get: function () { return compareArray_js_1.compareArray; } });
+var compareMap_js_1 = require("./compareMap.js");
+Object.defineProperty(exports, "compareMap", { enumerable: true, get: function () { return compareMap_js_1.compareMap; } });
+var compareSet_js_1 = require("./compareSet.js");
+Object.defineProperty(exports, "compareSet", { enumerable: true, get: function () { return compareSet_js_1.compareSet; } });
+var decodeU8a_js_1 = require("./decodeU8a.js");
+Object.defineProperty(exports, "decodeU8a", { enumerable: true, get: function () { return decodeU8a_js_1.decodeU8a; } });
+Object.defineProperty(exports, "decodeU8aStruct", { enumerable: true, get: function () { return decodeU8a_js_1.decodeU8aStruct; } });
+Object.defineProperty(exports, "decodeU8aVec", { enumerable: true, get: function () { return decodeU8a_js_1.decodeU8aVec; } });
+var sanitize_js_1 = require("./sanitize.js");
+Object.defineProperty(exports, "sanitize", { enumerable: true, get: function () { return sanitize_js_1.sanitize; } });
+var sortValues_js_1 = require("./sortValues.js");
+Object.defineProperty(exports, "sortAsc", { enumerable: true, get: function () { return sortValues_js_1.sortAsc; } });
+Object.defineProperty(exports, "sortMap", { enumerable: true, get: function () { return sortValues_js_1.sortMap; } });
+Object.defineProperty(exports, "sortSet", { enumerable: true, get: function () { return sortValues_js_1.sortSet; } });
+var toConstructors_js_1 = require("./toConstructors.js");
+Object.defineProperty(exports, "mapToTypeMap", { enumerable: true, get: function () { return toConstructors_js_1.mapToTypeMap; } });
+Object.defineProperty(exports, "typesToConstructors", { enumerable: true, get: function () { return toConstructors_js_1.typesToConstructors; } });
+Object.defineProperty(exports, "typeToConstructor", { enumerable: true, get: function () { return toConstructors_js_1.typeToConstructor; } });
+var typesToMap_js_1 = require("./typesToMap.js");
+Object.defineProperty(exports, "typesToMap", { enumerable: true, get: function () { return typesToMap_js_1.typesToMap; } });

package/cjs/utils/sanitize.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trim = trim;
+exports.findClosing = findClosing;
+exports.alias = alias;
+exports.cleanupCompact = cleanupCompact;
+exports.flattenSingleTuple = flattenSingleTuple;
+exports.removeExtensions = removeExtensions;
+exports.removeColons = removeColons;
+exports.removeGenerics = removeGenerics;
+exports.removePairOf = removePairOf;
+exports.removeTraits = removeTraits;
+exports.removeWrap = removeWrap;
+exports.sanitize = sanitize;
+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 = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
+const mappings = [
+    // alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
+    alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false),
+    alias('VecDeque<', 'Vec<', false),
+    // <T::Balance as HasCompact>
+    cleanupCompact(),
+    // Change BoundedVec<Type, Size> to Vec<Type>
+    removeExtensions('Bounded', true),
+    // Change WeakVec<Type> to Vec<Type>
+    removeExtensions('Weak', false),
+    // Remove all the trait prefixes
+    removeTraits(),
+    // remove PairOf<T> -> (T, T)
+    removePairOf(),
+    // remove boxing, `Box<Proposal>` -> `Proposal`
+    removeWrap('Box<'),
+    // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
+    removeGenerics(),
+    // alias String -> Text (compat with jsonrpc methods)
+    alias('String', 'Text'),
+    // alias Vec<u8> -> Bytes
+    alias('Vec<u8>', 'Bytes'),
+    alias('&\\[u8\\]', 'Bytes'),
+    alias("&'static\\[u8\\]", 'Bytes'),
+    // alias RawAddress -> Address
+    alias('RawAddress', 'Address'),
+    // lookups, mapped to Address/AccountId as appropriate in runtime
+    alias('Lookup::Source', 'LookupSource'),
+    alias('Lookup::Target', 'LookupTarget'),
+    // HACK duplication between contracts & primitives, however contracts prefixed with exec
+    alias('exec::StorageKey', 'ContractStorageKey'),
+    // flattens tuples with one value, `(AccountId)` -> `AccountId`
+    flattenSingleTuple(),
+    // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
+    removeColons(),
+    // remove all trailing spaces - this should always be the last
+    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
+            // tuples may have trailing commas, e.g. (u32, BlockNumber, )
+            .replace(from1, ')')
+            // change (u32) -> u32
+            .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] === '<') {
+                // check against the allowed wrappers, be it Vec<..>, Option<...> ...
+                const box = ALLOWED_BOXES.find((box) => {
+                    const start = i - box.length;
+                    return ((start >= 0 &&
+                        value.substring(start, i) === box) && (
+                    // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
+                    start === 0 ||
+                        BOX_PRECEDING.includes(value[start - 1])));
+                });
+                // we have not found anything, unwrap generic innards
+                if (!box) {
+                    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
+            // remove all whitespaces
+            .replace(from1, '')
+            // anything `T::<type>` to end up as `<type>`
+            .replace(from2, '')
+            // replace `<T as Trait>::` (whitespaces were removed above)
+            .replace(from3, '')
+            // replace `<T as something::Trait>::` (whitespaces were removed above)
+            .replace(from4, '')
+            // replace <Lookup as StaticLookup>
+            .replace(from5, 'Lookup')
+            // replace `<...>::Type`
+            .replace(from6, '');
+    };
+}
+function removeWrap(check) {
+    const replacer = (v) => v;
+    return (value) => replaceTagWith(value, check, replacer);
+}
+const sanitizeMap = 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;
+}

package/cjs/utils/sortValues.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortAsc = sortAsc;
+exports.sortSet = sortSet;
+exports.sortMap = sortMap;
+const util_1 = require("@pezkuwi/util");
+/** @internal **/
+function isArrayLike(arg) {
+    return arg instanceof Uint8Array || Array.isArray(arg);
+}
+/** @internal **/
+function isEnum(arg) {
+    return (0, util_1.isCodec)(arg) && (0, util_1.isNumber)(arg.index) && (0, util_1.isCodec)(arg.value);
+}
+/** @internal **/
+function isOption(arg) {
+    return (0, util_1.isCodec)(arg) && (0, util_1.isBoolean)(arg.isSome) && (0, util_1.isCodec)(arg.value);
+}
+/** @internal */
+function isNumberLike(arg) {
+    return (0, util_1.isNumber)(arg) || (0, util_1.isBn)(arg) || (0, util_1.isBigInt)(arg);
+}
+/** @internal */
+function sortArray(a, b) {
+    // Vec, Tuple, Bytes etc.
+    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) {
+    // Convert the value to hex.
+    if ((0, util_1.isCodec)(arg)) {
+        const hex = arg.toHex();
+        // Check if we have seen the value.
+        if (seen.has(hex)) {
+            // Duplicates are not allowed.
+            throw new Error(`Duplicate value in ${container}: ${(0, util_1.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 (0, util_1.bnToBn)(a).cmp((0, util_1.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 ((0, util_1.isCodec)(a) && (0, util_1.isCodec)(b)) {
+        // Text, Bool etc.
+        return sortAsc(a.toU8a(true), b.toU8a(true));
+    }
+    throw new Error(`Attempting to sort unrecognized values: ${(0, util_1.stringify)(a)} (typeof ${typeof a}) <-> ${(0, util_1.stringify)(b)} (typeof ${typeof b})`);
+}
+function sortSet(set) {
+    const seen = new Set();
+    return new Set(Array.from(set).filter((value) => checkForDuplicates('BTreeSet', seen, value)).sort(sortAsc));
+}
+function sortMap(map) {
+    const seen = new Set();
+    return new Map(Array.from(map.entries()).filter(([key]) => checkForDuplicates('BTreeMap', seen, key)).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
+}