@pezkuwi/types 16.5.5 → 16.5.8

package/build-tsc-cjs/metadata/PortableRegistry/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertSiV0toV1 = exports.PortableRegistry = void 0;
+var PortableRegistry_js_1 = require("./PortableRegistry.js");
+Object.defineProperty(exports, "PortableRegistry", { enumerable: true, get: function () { return PortableRegistry_js_1.PortableRegistry; } });
+var toV1_js_1 = require("./toV1.js");
+Object.defineProperty(exports, "convertSiV0toV1", { enumerable: true, get: function () { return toV1_js_1.toV1; } });

package/build-tsc-cjs/metadata/PortableRegistry/toV1.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV1 = toV1;
+const util_1 = require("@pezkuwi/util");
+function convertType(key) {
+    return (registry, { type }) => registry.createType('Si1TypeDef', {
+        [key]: {
+            type: type.toNumber()
+        }
+    });
+}
+function convertArray(registry, { len, type }) {
+    return registry.createType('Si1TypeDef', {
+        Array: {
+            len,
+            type: type.toNumber()
+        }
+    });
+}
+function convertBitSequence(registry, { bitOrderType, bitStoreType }) {
+    return registry.createType('Si1TypeDef', {
+        BitSequence: {
+            bitOrderType: bitOrderType.toNumber(),
+            bitStoreType: bitStoreType.toNumber()
+        }
+    });
+}
+const convertCompact = convertType('Compact');
+function convertComposite(registry, { fields }) {
+    return registry.createType('Si1TypeDef', {
+        Composite: {
+            fields: convertFields(registry, fields)
+        }
+    });
+}
+function convertFields(registry, fields) {
+    return fields.map(({ docs, name, type, typeName }) => registry.createType('Si1Field', {
+        docs,
+        name,
+        type: type.toNumber(),
+        typeName
+    }));
+}
+function convertPhantom(registry, path) {
+    console.warn(`Converting phantom type ${path.map((p) => p.toString()).join('::')} to empty tuple`);
+    return registry.createType('Si1TypeDef', {
+        Tuple: []
+    });
+}
+function convertPrimitive(registry, prim) {
+    return registry.createType('Si1TypeDef', {
+        Primitive: prim.toString()
+    });
+}
+const convertSequence = convertType('Sequence');
+function convertTuple(registry, types) {
+    return registry.createType('Si1TypeDef', {
+        Tuple: types.map((t) => t.toNumber())
+    });
+}
+function convertVariant(registry, { variants }) {
+    return registry.createType('Si1TypeDef', {
+        Variant: {
+            variants: variants.map(({ discriminant, docs, fields, name }, index) => registry.createType('Si1Variant', {
+                docs,
+                fields: convertFields(registry, fields),
+                index: discriminant.isSome
+                    ? discriminant.unwrap().toNumber()
+                    : index,
+                name
+            }))
+        }
+    });
+}
+function convertDef(registry, { def, path }) {
+    let result;
+    switch (def.type) {
+        case 'Array':
+            result = convertArray(registry, def.asArray);
+            break;
+        case 'BitSequence':
+            result = convertBitSequence(registry, def.asBitSequence);
+            break;
+        case 'Compact':
+            result = convertCompact(registry, def.asCompact);
+            break;
+        case 'Composite':
+            result = convertComposite(registry, def.asComposite);
+            break;
+        case 'Phantom':
+            result = convertPhantom(registry, path);
+            break;
+        case 'Primitive':
+            result = convertPrimitive(registry, def.asPrimitive);
+            break;
+        case 'Sequence':
+            result = convertSequence(registry, def.asSequence);
+            break;
+        case 'Tuple':
+            result = convertTuple(registry, def.asTuple);
+            break;
+        case 'Variant':
+            result = convertVariant(registry, def.asVariant);
+            break;
+        default: (0, util_1.assertUnreachable)(def.type);
+    }
+    return result;
+}
+function toV1(registry, types) {
+    return types.map((t, index) => registry.createType('PortableType', {
+        // offsets are +1 from v0
+        id: index + 1,
+        type: {
+            def: convertDef(registry, t),
+            docs: [],
+            params: t.params.map((p) => registry.createType('Si1TypeParameter', {
+                type: p.toNumber()
+            })),
+            path: t.path.map((p) => p.toString())
+        }
+    }));
+}

package/build-tsc-cjs/metadata/decorate/constants/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateConstants = decorateConstants;
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("../util.js");
+/** @internal */
+function decorateConstants(registry, { pallets }, _version) {
+    const result = {};
+    for (let i = 0, count = pallets.length; i < count; i++) {
+        const { constants, name } = pallets[i];
+        if (!constants.isEmpty) {
+            (0, util_1.lazyMethod)(result, (0, util_1.stringCamelCase)(name), () => (0, util_1.lazyMethods)({}, constants, (constant) => {
+                const codec = registry.createTypeUnsafe(registry.createLookupType(constant.type), [(0, util_1.hexToU8a)(constant.value.toHex())]);
+                // We are casting here since we are assigning to a read-only property
+                codec.meta = constant;
+                return codec;
+            }, util_js_1.objectNameToCamel));
+        }
+    }
+    return result;
+}

package/build-tsc-cjs/metadata/decorate/errors/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantToMeta = variantToMeta;
+exports.decorateErrors = decorateErrors;
+const util_1 = require("@pezkuwi/util");
+const lazy_js_1 = require("../../../create/lazy.js");
+const util_js_1 = require("../util.js");
+function variantToMeta(lookup, variant) {
+    return (0, util_1.objectSpread)({ args: variant.fields.map(({ type }) => lookup.getTypeDef(type).type) }, variant);
+}
+/** @internal */
+function decorateErrors(registry, { lookup, pallets }, version) {
+    const result = {};
+    for (let i = 0, count = pallets.length; i < count; i++) {
+        const { errors, index, name } = pallets[i];
+        if (errors.isSome) {
+            const sectionIndex = version >= 12 ? index.toNumber() : i;
+            (0, util_1.lazyMethod)(result, (0, util_1.stringCamelCase)(name), () => (0, lazy_js_1.lazyVariants)(lookup, errors.unwrap(), util_js_1.objectNameToString, (variant) => ({
+                // We sprinkle in isCodec & isU8a to ensure we are dealing with the correct objects
+                is: (errorMod) => (0, util_1.isCodec)(errorMod) &&
+                    (0, util_1.isCodec)(errorMod.index) &&
+                    errorMod.index.eq(sectionIndex) && ((0, util_1.isU8a)(errorMod.error)
+                    ? errorMod.error[0] === variant.index.toNumber()
+                    : (0, util_1.isCodec)(errorMod.error) && errorMod.error.eq(variant.index)),
+                meta: registry.createTypeUnsafe('ErrorMetadataLatest', [variantToMeta(lookup, variant)])
+            })));
+        }
+    }
+    return result;
+}

package/build-tsc-cjs/metadata/decorate/events/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterEventsSome = filterEventsSome;
+exports.decorateEvents = decorateEvents;
+const util_1 = require("@pezkuwi/util");
+const lazy_js_1 = require("../../../create/lazy.js");
+const index_js_1 = require("../errors/index.js");
+const util_js_1 = require("../util.js");
+function filterEventsSome({ events }) {
+    return events.isSome;
+}
+/** @internal */
+function decorateEvents(registry, { lookup, pallets }, version) {
+    const result = {};
+    const filtered = pallets.filter(filterEventsSome);
+    for (let i = 0, count = filtered.length; i < count; i++) {
+        const { events, index, name } = filtered[i];
+        const sectionIndex = version >= 12 ? index.toNumber() : i;
+        (0, util_1.lazyMethod)(result, (0, util_1.stringCamelCase)(name), () => (0, lazy_js_1.lazyVariants)(lookup, events.unwrap(), util_js_1.objectNameToString, (variant) => ({
+            // We sprinkle in isCodec & isU8a to ensure we are dealing with the correct objects
+            is: (eventRecord) => (0, util_1.isCodec)(eventRecord) &&
+                (0, util_1.isU8a)(eventRecord.index) &&
+                sectionIndex === eventRecord.index[0] &&
+                variant.index.eq(eventRecord.index[1]),
+            meta: registry.createTypeUnsafe('EventMetadataLatest', [(0, index_js_1.variantToMeta)(lookup, variant)])
+        })));
+    }
+    return result;
+}

package/build-tsc-cjs/metadata/decorate/extrinsics/createUnchecked.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnchecked = createUnchecked;
+const util_1 = require("@pezkuwi/util");
+function isTx(tx, callIndex) {
+    return tx.callIndex[0] === callIndex[0] && tx.callIndex[1] === callIndex[1];
+}
+/** @internal */
+function createUnchecked(registry, section, callIndex, callMetadata) {
+    const expectedArgs = callMetadata.fields;
+    const funcName = (0, util_1.stringCamelCase)(callMetadata.name);
+    const extrinsicFn = (...args) => {
+        if (expectedArgs.length !== args.length) {
+            throw new Error(`Extrinsic ${section}.${funcName} expects ${expectedArgs.length} arguments, got ${args.length}.`);
+        }
+        return registry.createTypeUnsafe('Call', [{ args, callIndex }, callMetadata]);
+    };
+    extrinsicFn.is = (tx) => isTx(tx, callIndex);
+    extrinsicFn.callIndex = callIndex;
+    extrinsicFn.meta = callMetadata;
+    extrinsicFn.method = funcName;
+    extrinsicFn.section = section;
+    extrinsicFn.toJSON = () => callMetadata.toJSON();
+    return extrinsicFn;
+}

package/build-tsc-cjs/metadata/decorate/extrinsics/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterCallsSome = filterCallsSome;
+exports.createCallFunction = createCallFunction;
+exports.decorateExtrinsics = decorateExtrinsics;
+const util_1 = require("@pezkuwi/util");
+const lazy_js_1 = require("../../../create/lazy.js");
+const index_js_1 = require("../../util/index.js");
+const util_js_1 = require("../util.js");
+const createUnchecked_js_1 = require("./createUnchecked.js");
+function filterCallsSome({ calls }) {
+    return calls.isSome;
+}
+function createCallFunction(registry, lookup, variant, sectionName, sectionIndex) {
+    const { fields, index } = variant;
+    const count = fields.length;
+    const args = new Array(count);
+    for (let i = 0; i < count; i++) {
+        const { name, type, typeName } = fields[i];
+        args[i] = (0, util_1.objectSpread)({
+            name: (0, util_1.stringCamelCase)(name.unwrapOr(`param${i}`)),
+            type: (0, index_js_1.getSiName)(lookup, type)
+        }, typeName.isSome
+            ? { typeName: typeName.unwrap() }
+            : null);
+    }
+    return (0, createUnchecked_js_1.createUnchecked)(registry, sectionName, new Uint8Array([sectionIndex, index.toNumber()]), registry.createTypeUnsafe('FunctionMetadataLatest', [(0, util_1.objectSpread)({ args }, variant)]));
+}
+/** @internal */
+function decorateExtrinsics(registry, { lookup, pallets }, version) {
+    const result = {};
+    const filtered = pallets.filter(filterCallsSome);
+    for (let i = 0, count = filtered.length; i < count; i++) {
+        const { calls, index, name } = filtered[i];
+        const sectionName = (0, util_1.stringCamelCase)(name);
+        const sectionIndex = version >= 12 ? index.toNumber() : i;
+        (0, util_1.lazyMethod)(result, sectionName, () => (0, lazy_js_1.lazyVariants)(lookup, calls.unwrap(), util_js_1.objectNameToCamel, (variant) => createCallFunction(registry, lookup, variant, sectionName, sectionIndex)));
+    }
+    return result;
+}

package/build-tsc-cjs/metadata/decorate/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterEventsSome = exports.filterCallsSome = exports.decorateStorage = exports.decorateExtrinsics = exports.decorateEvents = exports.decorateErrors = exports.decorateConstants = void 0;
+exports.expandMetadata = expandMetadata;
+const Metadata_js_1 = require("../Metadata.js");
+const index_js_1 = require("./constants/index.js");
+Object.defineProperty(exports, "decorateConstants", { enumerable: true, get: function () { return index_js_1.decorateConstants; } });
+const index_js_2 = require("./errors/index.js");
+Object.defineProperty(exports, "decorateErrors", { enumerable: true, get: function () { return index_js_2.decorateErrors; } });
+const index_js_3 = require("./events/index.js");
+Object.defineProperty(exports, "decorateEvents", { enumerable: true, get: function () { return index_js_3.decorateEvents; } });
+Object.defineProperty(exports, "filterEventsSome", { enumerable: true, get: function () { return index_js_3.filterEventsSome; } });
+const index_js_4 = require("./extrinsics/index.js");
+Object.defineProperty(exports, "decorateExtrinsics", { enumerable: true, get: function () { return index_js_4.decorateExtrinsics; } });
+Object.defineProperty(exports, "filterCallsSome", { enumerable: true, get: function () { return index_js_4.filterCallsSome; } });
+const index_js_5 = require("./storage/index.js");
+Object.defineProperty(exports, "decorateStorage", { enumerable: true, get: function () { return index_js_5.decorateStorage; } });
+/**
+ * Expands the metadata by decoration into consts, query and tx sections
+ */
+function expandMetadata(registry, metadata) {
+    if (!(metadata instanceof Metadata_js_1.Metadata)) {
+        throw new Error('You need to pass a valid Metadata instance to Decorated');
+    }
+    const latest = metadata.asLatest;
+    const version = metadata.version;
+    return {
+        consts: (0, index_js_1.decorateConstants)(registry, latest, version),
+        errors: (0, index_js_2.decorateErrors)(registry, latest, version),
+        events: (0, index_js_3.decorateEvents)(registry, latest, version),
+        query: (0, index_js_5.decorateStorage)(registry, latest, version),
+        registry,
+        tx: (0, index_js_4.decorateExtrinsics)(registry, latest, version)
+    };
+}

package/build-tsc-cjs/metadata/decorate/storage/bizinikiwi.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bizinikiwi = void 0;
+const util_js_1 = require("./util.js");
+const prefix = 'Bizinikiwi';
+const section = 'bizinikiwi';
+function createBizinikiwiFn(method, key, meta) {
+    return (0, util_js_1.createRuntimeFunction)({ method, prefix, section }, key, meta);
+}
+exports.bizinikiwi = {
+    changesTrieConfig: createBizinikiwiFn('changesTrieConfig', ':changes_trie', {
+        docs: 'Changes trie configuration is stored under this key.',
+        type: 'u32'
+    }),
+    childStorageKeyPrefix: createBizinikiwiFn('childStorageKeyPrefix', ':child_storage:', {
+        docs: 'Prefix of child storage keys.',
+        type: 'u32'
+    }),
+    code: createBizinikiwiFn('code', ':code', {
+        docs: 'Wasm code of the runtime.',
+        type: 'Bytes'
+    }),
+    defaultChildStorageKeyPrefix: createBizinikiwiFn('defaultChildStorageKeyPrefix', ':child_storage:default:', {
+        docs: 'Prefix of the default child storage keys in the top trie.',
+        type: 'u32'
+    }),
+    extrinsicIndex: createBizinikiwiFn('extrinsicIndex', ':extrinsic_index', {
+        docs: 'Current extrinsic index (u32) is stored under this key.',
+        type: 'u32'
+    }),
+    heapPages: createBizinikiwiFn('heapPages', ':heappages', {
+        docs: 'Number of wasm linear memory pages required for execution of the runtime.',
+        type: 'u64'
+    }),
+    intrablockEntropy: createBizinikiwiFn('intrablockEntropy', ':intrablock_entropy', {
+        docs: 'Current intra-block entropy (a universally unique `[u8; 32]` value) is stored here.',
+        type: '[u8; 32]'
+    }),
+    storageVersionStorageKeyPostfix: createBizinikiwiFn('storageVersionStorageKeyPostfix', ':__STORAGE_VERSION__:', {
+        docs: 'The storage key postfix that is used to store the [`StorageVersion`] per pallet.',
+        type: 'u16'
+    }),
+    transactionLevelKey: createBizinikiwiFn('transactionLevelKey', ':transaction_level:', {
+        docs: 'The key that holds the current number of active layers.',
+        type: 'u32'
+    })
+};

package/build-tsc-cjs/metadata/decorate/storage/createFunction.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_RAW_ARGS = void 0;
+exports.createKeyRawParts = createKeyRawParts;
+exports.createKeyInspect = createKeyInspect;
+exports.createKeyRaw = createKeyRaw;
+exports.createFunction = createFunction;
+const types_codec_1 = require("@pezkuwi/types-codec");
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const index_js_1 = require("../../util/index.js");
+const getHasher_js_1 = require("./getHasher.js");
+exports.NO_RAW_ARGS = {
+    args: [],
+    hashers: [],
+    keys: []
+};
+/** @internal */
+function filterDefined(a) {
+    return !(0, util_1.isUndefined)(a);
+}
+/** @internal */
+function assertArgs({ method, section }, { args, keys }) {
+    if (!Array.isArray(args)) {
+        throw new Error(`Call to ${(0, util_1.stringCamelCase)(section || 'unknown')}.${(0, util_1.stringCamelCase)(method || 'unknown')} needs ${keys.length} arguments`);
+    }
+    else if (args.filter(filterDefined).length !== keys.length) {
+        throw new Error(`Call to ${(0, util_1.stringCamelCase)(section || 'unknown')}.${(0, util_1.stringCamelCase)(method || 'unknown')} needs ${keys.length} arguments, found [${args.join(', ')}]`);
+    }
+}
+/** @internal */
+function createKeyRawParts(registry, itemFn, { args, hashers, keys }) {
+    const count = keys.length;
+    const extra = new Array(count);
+    for (let i = 0; i < count; i++) {
+        extra[i] = (0, getHasher_js_1.getHasher)(hashers[i])(registry.createTypeUnsafe(registry.createLookupType(keys[i]), [args[i]]).toU8a());
+    }
+    return [
+        [
+            (0, util_crypto_1.xxhashAsU8a)(itemFn.prefix, 128),
+            (0, util_crypto_1.xxhashAsU8a)(itemFn.method, 128)
+        ],
+        extra
+    ];
+}
+/** @internal */
+function createKeyInspect(registry, itemFn, args) {
+    assertArgs(itemFn, args);
+    const { meta } = itemFn;
+    const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
+    let types = [];
+    if (meta.type.isMap) {
+        const { hashers, key } = meta.type.asMap;
+        types = hashers.length === 1
+            ? [`${hashers[0].type}(${(0, index_js_1.getSiName)(registry.lookup, key)})`]
+            : registry.lookup.getSiType(key).def.asTuple.map((k, i) => `${hashers[i].type}(${(0, index_js_1.getSiName)(registry.lookup, k)})`);
+    }
+    const names = ['module', 'method'].concat(...args.args.map((_, i) => types[i]));
+    return {
+        inner: prefix
+            .concat(...extra)
+            .map((v, i) => ({ name: names[i], outer: [v] }))
+    };
+}
+/** @internal */
+function createKeyRaw(registry, itemFn, args) {
+    const [prefix, extra] = createKeyRawParts(registry, itemFn, args);
+    return (0, util_1.u8aConcat)(...prefix, ...extra);
+}
+/** @internal */
+function createKey(registry, itemFn, args) {
+    assertArgs(itemFn, args);
+    // always add the length prefix (underlying it is Bytes)
+    return (0, util_1.compactAddLength)(createKeyRaw(registry, itemFn, args));
+}
+/** @internal */
+function createStorageInspect(registry, itemFn, options) {
+    const { meta: { type } } = itemFn;
+    return (...args) => {
+        if (type.isPlain) {
+            return options.skipHashing
+                ? { inner: [], name: 'wellKnown', outer: [(0, util_1.u8aToU8a)(options.key)] }
+                : createKeyInspect(registry, itemFn, exports.NO_RAW_ARGS);
+        }
+        const { hashers, key } = type.asMap;
+        return hashers.length === 1
+            ? createKeyInspect(registry, itemFn, { args, hashers, keys: [key] })
+            : createKeyInspect(registry, itemFn, { args, hashers, keys: registry.lookup.getSiType(key).def.asTuple });
+    };
+}
+/** @internal */
+function createStorageFn(registry, itemFn, options) {
+    const { meta: { type } } = itemFn;
+    let cacheKey = null;
+    // Can only have zero or one argument:
+    //   - storage.system.account(address)
+    //   - storage.timestamp.blockPeriod()
+    // For higher-map queries the params are passed in as an tuple, [key1, key2]
+    return (...args) => {
+        if (type.isPlain) {
+            if (!cacheKey) {
+                cacheKey = options.skipHashing
+                    ? (0, util_1.compactAddLength)((0, util_1.u8aToU8a)(options.key))
+                    : createKey(registry, itemFn, exports.NO_RAW_ARGS);
+            }
+            return cacheKey;
+        }
+        const { hashers, key } = type.asMap;
+        return hashers.length === 1
+            ? createKey(registry, itemFn, { args, hashers, keys: [key] })
+            : createKey(registry, itemFn, { args, hashers, keys: registry.lookup.getSiType(key).def.asTuple });
+    };
+}
+/** @internal */
+function createWithMeta(registry, itemFn, options) {
+    const { meta, method, prefix, section } = itemFn;
+    const storageFn = createStorageFn(registry, itemFn, options);
+    storageFn.inspect = createStorageInspect(registry, itemFn, options);
+    storageFn.meta = meta;
+    storageFn.method = (0, util_1.stringCamelCase)(method);
+    storageFn.prefix = prefix;
+    storageFn.section = section;
+    // explicitly add the actual method in the toJSON, this gets used to determine caching and without it
+    // instances (e.g. collective) will not work since it is only matched on param meta
+    storageFn.toJSON = () => (0, util_1.objectSpread)({ storage: { method, prefix, section } }, meta.toJSON());
+    return storageFn;
+}
+/** @internal */
+function extendHeadMeta(registry, { meta: { docs, name, type }, section }, { method }, iterFn) {
+    // metadata with a fallback value using the type of the key, the normal
+    // meta fallback only applies to actual entry values, create one for head
+    const meta = registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
+            docs,
+            fallback: registry.createTypeUnsafe('Bytes', []),
+            modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', [1]), // required
+            name,
+            type: registry.createTypeUnsafe('StorageEntryTypeLatest', [type.asMap.key, 0])
+        }]);
+    iterFn.meta = meta;
+    const fn = (...args) => registry.createTypeUnsafe('StorageKey', [iterFn(...args), { method, section }]);
+    fn.meta = meta;
+    return fn;
+}
+/** @internal */
+function extendPrefixedMap(registry, itemFn, storageFn) {
+    const { meta: { type }, method, section } = itemFn;
+    storageFn.iterKey = extendHeadMeta(registry, itemFn, storageFn, (...args) => {
+        if (args.length && (type.isPlain || (args.length >= type.asMap.hashers.length))) {
+            throw new Error(`Iteration of ${(0, util_1.stringCamelCase)(section || 'unknown')}.${(0, util_1.stringCamelCase)(method || 'unknown')} needs arguments to be at least one less than the full arguments, found [${args.join(', ')}]`);
+        }
+        if (args.length) {
+            if (type.isMap) {
+                const { hashers, key } = type.asMap;
+                const keysVec = hashers.length === 1
+                    ? [key]
+                    : registry.lookup.getSiType(key).def.asTuple;
+                return new types_codec_1.Raw(registry, createKeyRaw(registry, itemFn, { args, hashers: hashers.slice(0, args.length), keys: keysVec.slice(0, args.length) }));
+            }
+        }
+        return new types_codec_1.Raw(registry, createKeyRaw(registry, itemFn, exports.NO_RAW_ARGS));
+    });
+    return storageFn;
+}
+/** @internal */
+function createFunction(registry, itemFn, options) {
+    const { meta: { type } } = itemFn;
+    const storageFn = createWithMeta(registry, itemFn, options);
+    if (type.isMap) {
+        extendPrefixedMap(registry, itemFn, storageFn);
+    }
+    storageFn.keyPrefix = (...args) => (storageFn.iterKey && storageFn.iterKey(...args)) ||
+        (0, util_1.compactStripLength)(storageFn())[1];
+    return storageFn;
+}

package/build-tsc-cjs/metadata/decorate/storage/getHasher.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHasher = getHasher;
+const util_1 = require("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/util-crypto");
+const DEFAULT_FN = (data) => (0, util_crypto_1.xxhashAsU8a)(data, 128);
+const HASHERS = {
+    Blake2_128: (data) => // eslint-disable-line camelcase
+     (0, util_crypto_1.blake2AsU8a)(data, 128),
+    Blake2_128Concat: (data) => // eslint-disable-line camelcase
+     (0, util_1.u8aConcat)((0, util_crypto_1.blake2AsU8a)(data, 128), (0, util_1.u8aToU8a)(data)),
+    Blake2_256: (data) => // eslint-disable-line camelcase
+     (0, util_crypto_1.blake2AsU8a)(data, 256),
+    Identity: (data) => (0, util_1.u8aToU8a)(data),
+    Twox128: (data) => (0, util_crypto_1.xxhashAsU8a)(data, 128),
+    Twox256: (data) => (0, util_crypto_1.xxhashAsU8a)(data, 256),
+    Twox64Concat: (data) => (0, util_1.u8aConcat)((0, util_crypto_1.xxhashAsU8a)(data, 64), (0, util_1.u8aToU8a)(data))
+};
+/** @internal */
+function getHasher(hasher) {
+    return HASHERS[hasher.type] || DEFAULT_FN;
+}

package/build-tsc-cjs/metadata/decorate/storage/getStorage.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStorage = getStorage;
+const bizinikiwi_js_1 = require("./bizinikiwi.js");
+/** @internal */
+function getStorage(registry) {
+    const storage = {};
+    const entries = Object.entries(bizinikiwi_js_1.bizinikiwi);
+    for (let e = 0, count = entries.length; e < count; e++) {
+        storage[entries[e][0]] = entries[e][1](registry);
+    }
+    return { bizinikiwi: storage };
+}

package/build-tsc-cjs/metadata/decorate/storage/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateStorage = decorateStorage;
+const util_1 = require("@pezkuwi/util");
+const util_js_1 = require("../util.js");
+const createFunction_js_1 = require("./createFunction.js");
+const getStorage_js_1 = require("./getStorage.js");
+const util_js_2 = require("./util.js");
+const VERSION_NAME = 'palletVersion';
+const VERSION_KEY = ':__STORAGE_VERSION__:';
+const VERSION_DOCS = { docs: 'Returns the current pallet version from storage', type: 'u16' };
+/** @internal */
+function decorateStorage(registry, { pallets }, _metaVersion) {
+    const result = (0, getStorage_js_1.getStorage)(registry);
+    for (let i = 0, count = pallets.length; i < count; i++) {
+        const { name, storage } = pallets[i];
+        if (storage.isSome) {
+            const section = (0, util_1.stringCamelCase)(name);
+            const { items, prefix: _prefix } = storage.unwrap();
+            const prefix = _prefix.toString();
+            (0, util_1.lazyMethod)(result, section, () => (0, util_1.lazyMethods)({
+                palletVersion: (0, util_js_2.createRuntimeFunction)({ method: VERSION_NAME, prefix, section }, (0, createFunction_js_1.createKeyRaw)(registry, { method: VERSION_KEY, prefix: name.toString() }, createFunction_js_1.NO_RAW_ARGS), VERSION_DOCS)(registry)
+            }, items, (meta) => (0, createFunction_js_1.createFunction)(registry, { meta, method: meta.name.toString(), prefix, section }, {}), util_js_1.objectNameToCamel));
+        }
+    }
+    return result;
+}

package/build-tsc-cjs/metadata/decorate/storage/util.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeFunction = createRuntimeFunction;
+const types_create_1 = require("@pezkuwi/types-create");
+const createFunction_js_1 = require("./createFunction.js");
+function findSiPrimitive(registry, type) {
+    const prim = type.toLowerCase();
+    return registry.lookup.types.find((t) => (t.type.def.isPrimitive &&
+        t.type.def.asPrimitive.toString().toLowerCase() === prim) || (t.type.def.isHistoricMetaCompat &&
+        t.type.def.asHistoricMetaCompat.toString().toLowerCase() === prim));
+}
+function findSiType(registry, type) {
+    let portable = findSiPrimitive(registry, type);
+    // some types are either Sequence or Arrays, cater for these
+    // specifically (these all come from the base bizinikiwi known keys)
+    if (!portable && (type === 'Bytes' || type.startsWith('[u8;'))) {
+        const u8 = findSiPrimitive(registry, 'u8');
+        if (u8) {
+            if (type === 'Bytes') {
+                portable = registry.lookup.types.find((t) => (t.type.def.isSequence &&
+                    t.type.def.asSequence.type.eq(u8.id)) || (t.type.def.isHistoricMetaCompat &&
+                    t.type.def.asHistoricMetaCompat.eq(type)));
+            }
+            else {
+                const td = (0, types_create_1.getTypeDef)(type);
+                portable = registry.lookup.types.find((t) => (t.type.def.isArray &&
+                    t.type.def.asArray.eq({
+                        len: td.length,
+                        type: u8.id
+                    })) || (t.type.def.isHistoricMetaCompat &&
+                    t.type.def.asHistoricMetaCompat.eq(type)));
+            }
+        }
+    }
+    if (!portable) {
+        // Not fatal, however if this happens the storage key using this
+        // type will not return valid values, rather it will most probably
+        // be decoded incorrectly
+        console.warn(`Unable to map ${type} to a lookup index`);
+    }
+    return portable;
+}
+/** @internal */
+function createRuntimeFunction({ method, prefix, section }, key, { docs, type }) {
+    return (registry) => (0, createFunction_js_1.createFunction)(registry, {
+        meta: registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
+                docs: registry.createTypeUnsafe('Vec<Text>', [[docs]]),
+                modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', ['Required']),
+                name: registry.createTypeUnsafe('Text', [method]),
+                toJSON: () => key,
+                type: registry.createTypeUnsafe('StorageEntryTypeLatest', [{ Plain: findSiType(registry, type)?.id || 0 }])
+            }]),
+        method,
+        prefix,
+        section
+    }, { key, skipHashing: true });
+}

package/build-tsc-cjs/metadata/decorate/types.js

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