@pezkuwi/types-create 16.5.17 → 16.5.19

package/build/cjs/util/getTypeDef.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeDef = getTypeDef;
+const types_codec_1 = require("@pezkuwi/types-codec");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../types/index.js");
+const typeSplit_js_1 = require("./typeSplit.js");
+const KNOWN_INTERNALS = ['_alias', '_fallback'];
+function getTypeString(typeOrObj) {
+    return (0, util_1.isString)(typeOrObj)
+        ? typeOrObj.toString()
+        : (0, util_1.stringify)(typeOrObj);
+}
+function isRustEnum(details) {
+    const values = Object.values(details);
+    if (values.some((v) => (0, util_1.isNumber)(v))) {
+        if (!values.every((v) => (0, util_1.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 = index_js_1.TypeDefInfo.Enum;
+    value.fallbackType = fallbackType;
+    // not as pretty, but remain compatible with oo7 for both struct and Array types
+    if (Array.isArray(details)) {
+        value.sub = details.map((name, index) => ({
+            index,
+            info: index_js_1.TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    else if (isRustEnum(details)) {
+        value.sub = Object.entries(details).map(([name, typeOrObj], index) => (0, util_1.objectSpread)({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
+    }
+    else {
+        value.sub = Object.entries(details).map(([name, index]) => ({
+            index,
+            info: index_js_1.TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    return value;
+}
+function _decodeSet(value, details, fallbackType) {
+    value.info = index_js_1.TypeDefInfo.Set;
+    value.fallbackType = fallbackType;
+    value.length = details._bitLength;
+    value.sub = Object
+        .entries(details)
+        .filter(([name]) => !name.startsWith('_'))
+        .map(([name, index]) => ({
+        index,
+        info: index_js_1.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))
+        : undefined;
+    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
+        ? []
+        : (0, typeSplit_js_1.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, _) {
+    const NAME_LENGTH = 'DoNotConstruct'.length;
+    value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
+    return value;
+}
+function hasWrapper(type, [start, end]) {
+    return (type.startsWith(start)) && (type.slice(-1 * end.length) === end);
+}
+const nestedExtraction = [
+    ['[', ']', index_js_1.TypeDefInfo.VecFixed, _decodeFixedVec],
+    ['{', '}', index_js_1.TypeDefInfo.Struct, _decodeStruct],
+    ['(', ')', index_js_1.TypeDefInfo.Tuple, _decodeTuple],
+    // the inner for these are the same as tuple, multiple values
+    ['BTreeMap<', '>', index_js_1.TypeDefInfo.BTreeMap, _decodeTuple],
+    ['HashMap<', '>', index_js_1.TypeDefInfo.HashMap, _decodeTuple],
+    ['Int<', '>', index_js_1.TypeDefInfo.Int, _decodeInt],
+    ['Result<', '>', index_js_1.TypeDefInfo.Result, _decodeTuple],
+    ['UInt<', '>', index_js_1.TypeDefInfo.UInt, _decodeUInt],
+    ['DoNotConstruct<', '>', index_js_1.TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
+];
+const wrappedExtraction = [
+    ['BTreeSet<', '>', index_js_1.TypeDefInfo.BTreeSet],
+    ['Compact<', '>', index_js_1.TypeDefInfo.Compact],
+    ['Linkage<', '>', index_js_1.TypeDefInfo.Linkage],
+    ['Opaque<', '>', index_js_1.TypeDefInfo.WrapperOpaque],
+    ['Option<', '>', index_js_1.TypeDefInfo.Option],
+    ['Range<', '>', index_js_1.TypeDefInfo.Range],
+    ['RangeInclusive<', '>', index_js_1.TypeDefInfo.RangeInclusive],
+    ['Vec<', '>', index_js_1.TypeDefInfo.Vec],
+    ['WrapperKeepOpaque<', '>', index_js_1.TypeDefInfo.WrapperKeepOpaque],
+    ['WrapperOpaque<', '>', index_js_1.TypeDefInfo.WrapperOpaque]
+];
+function extractSubType(type, [start, end]) {
+    return type.substring(start.length, type.length - end.length);
+}
+function getTypeDef(_type, { displayName, name } = {}, count = 0) {
+    // create the type via Type, allowing types to be sanitized
+    const type = (0, types_codec_1.sanitize)(_type);
+    const value = { displayName, info: index_js_1.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;
+}

package/build/cjs/util/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./encodeTypes.js"), exports);
+tslib_1.__exportStar(require("./getTypeDef.js"), exports);
+tslib_1.__exportStar(require("./typeSplit.js"), exports);
+tslib_1.__exportStar(require("./xcm.js"), exports);

package/build/cjs/util/typeSplit.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeSplit = typeSplit;
+function typeSplit(type) {
+    const result = [];
+    // these are the depths of the various tokens: <, [, {, (
+    let c = 0;
+    let f = 0;
+    let s = 0;
+    let t = 0;
+    // current start position
+    let start = 0;
+    for (let i = 0, count = type.length; i < count; i++) {
+        switch (type[i]) {
+            // if we are not nested, add the type
+            case ',': {
+                if (!(c || f || s || t)) {
+                    result.push(type.substring(start, i).trim());
+                    start = i + 1;
+                }
+                break;
+            }
+            // adjust compact/vec (and friends) depth
+            case '<':
+                c++;
+                break;
+            case '>':
+                c--;
+                break;
+            // adjust fixed vec depths
+            case '[':
+                f++;
+                break;
+            case ']':
+                f--;
+                break;
+            // adjust struct depth
+            case '{':
+                s++;
+                break;
+            case '}':
+                s--;
+                break;
+            // adjust tuple depth
+            case '(':
+                t++;
+                break;
+            case ')':
+                t--;
+                break;
+        }
+    }
+    // ensure we have all the terminators taken care of
+    if (c || f || s || t) {
+        throw new Error(`Invalid definition (missing terminators) found in ${type}`);
+    }
+    // the final leg of the journey
+    result.push(type.substring(start, type.length).trim());
+    return result;
+}

package/build/cjs/util/xcm.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XCM_MAPPINGS = void 0;
+exports.mapXcmTypes = mapXcmTypes;
+const util_1 = require("@pezkuwi/util");
+exports.XCM_MAPPINGS = ['AssetInstance', 'Fungibility', 'Junction', 'Junctions', 'MultiAsset', 'MultiAssetFilter', 'MultiLocation', 'Response', 'WildFungibility', 'WildMultiAsset', 'Xcm', 'XcmError'];
+function mapXcmTypes(version) {
+    return exports.XCM_MAPPINGS.reduce((all, key) => (0, util_1.objectSpread)(all, { [key]: `${key}${version}` }), {});
+}

package/build/create/class.d.ts

@@ -0,0 +1,5 @@
+import type { Codec, CodecClass, Registry } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '../types/index.js';
+export declare function constructTypeClass<T extends Codec = Codec>(registry: Registry, typeDef: TypeDef): CodecClass<T>;
+export declare function getTypeClass<T extends Codec = Codec>(registry: Registry, typeDef: TypeDef): CodecClass<T>;
+export declare function createClassUnsafe<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K): CodecClass<T>;

package/build/create/class.js

@@ -0,0 +1,160 @@
+import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';
+import { isNumber, stringify } from '@pezkuwi/util';
+import { TypeDefInfo } from '../types/index.js';
+import { getTypeDef } from '../util/getTypeDef.js';
+function getTypeDefType({ lookupName, type }) {
+    return lookupName || type;
+}
+function getSubDefArray(value) {
+    if (!Array.isArray(value.sub)) {
+        throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
+    }
+    return value.sub;
+}
+function getSubDef(value) {
+    if (!value.sub || Array.isArray(value.sub)) {
+        throw new Error(`Expected subtype as TypeDef in ${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 ${stringify(sub)}`);
+        }
+        map[sub.name] = getTypeDefType(sub);
+    }
+    return map;
+}
+function getTypeClassArray(value) {
+    return getSubDefArray(value).map(getTypeDefType);
+}
+function createInt(Clazz, { displayName, length }) {
+    if (!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 = {
+    [TypeDefInfo.BTreeMap]: (_registry, value) => createHashMap(BTreeMap, value),
+    [TypeDefInfo.BTreeSet]: (_registry, value) => createWithSub(BTreeSet, value),
+    [TypeDefInfo.Compact]: (_registry, value) => createWithSub(Compact, value),
+    [TypeDefInfo.DoNotConstruct]: (_registry, value) => DoNotConstruct.with(value.displayName || value.type),
+    [TypeDefInfo.Enum]: (_registry, value) => {
+        const subs = getSubDefArray(value);
+        return 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));
+    },
+    [TypeDefInfo.HashMap]: (_registry, value) => createHashMap(HashMap, value),
+    [TypeDefInfo.Int]: (_registry, value) => createInt(Int, value),
+    // We have circular deps between Linkage & Struct
+    [TypeDefInfo.Linkage]: (_registry, value) => {
+        const type = `Option<${getSubType(value)}>`;
+        // eslint-disable-next-line sort-keys
+        const Clazz = Struct.with({ previous: type, next: type });
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        Clazz.prototype.toRawType = function () {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
+            return `Linkage<${this.next.toRawType(true)}>`;
+        };
+        return Clazz;
+    },
+    [TypeDefInfo.Null]: (_registry, _value) => Null,
+    [TypeDefInfo.Option]: (_registry, value) => {
+        if (!value.sub || Array.isArray(value.sub)) {
+            throw new Error('Expected type information for Option');
+        }
+        // NOTE This is opt-in (unhandled), not by default
+        // if (value.sub.type === 'bool') {
+        //   return OptionBool;
+        // }
+        return createWithSub(Option, value);
+    },
+    [TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
+    [TypeDefInfo.Range]: (_registry, value) => createWithSub(Range, value),
+    [TypeDefInfo.RangeInclusive]: (_registry, value) => createWithSub(RangeInclusive, value),
+    [TypeDefInfo.Result]: (_registry, value) => {
+        const [Ok, Err] = getTypeClassArray(value);
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return Result.with({ Err, Ok });
+    },
+    [TypeDefInfo.Set]: (_registry, value) => CodecSet.with(getSubDefArray(value).reduce((result, { index, name }) => {
+        if (!name || !isNumber(index)) {
+            throw new Error('No name found in sub definition');
+        }
+        result[name] = index;
+        return result;
+    }, {}), value.length),
+    [TypeDefInfo.Si]: (registry, value) => getTypeClass(registry, registry.lookup.getTypeDef(value.type)),
+    [TypeDefInfo.Struct]: (_registry, value) => Struct.with(getTypeClassMap(value), value.alias),
+    [TypeDefInfo.Tuple]: (_registry, value) => Tuple.with(getTypeClassArray(value)),
+    [TypeDefInfo.UInt]: (_registry, value) => createInt(UInt, value),
+    [TypeDefInfo.Vec]: (_registry, { sub }) => {
+        if (!sub || Array.isArray(sub)) {
+            throw new Error('Expected type information for vector');
+        }
+        return (sub.type === 'u8'
+            ? Bytes
+            : Vec.with(getTypeDefType(sub)));
+    },
+    [TypeDefInfo.VecFixed]: (_registry, { displayName, length, sub }) => {
+        if (!isNumber(length) || !sub || Array.isArray(sub)) {
+            throw new Error('Expected length & type information for fixed vector');
+        }
+        return (sub.type === 'u8'
+            ? U8aFixed.with((length * 8), displayName)
+            : VecFixed.with(getTypeDefType(sub), length));
+    },
+    [TypeDefInfo.WrapperKeepOpaque]: (_registry, value) => createWithSub(WrapperKeepOpaque, value),
+    [TypeDefInfo.WrapperOpaque]: (_registry, value) => createWithSub(WrapperOpaque, value)
+};
+export function constructTypeClass(registry, typeDef) {
+    try {
+        const Type = infoMapping[typeDef.info](registry, typeDef);
+        if (!Type) {
+            throw new Error('No class created');
+        }
+        // don't clobber any existing
+        if (!Type.__fallbackType && typeDef.fallbackType) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore ...this is the only place we we actually assign this...
+            Type.__fallbackType = typeDef.fallbackType;
+        }
+        return Type;
+    }
+    catch (error) {
+        throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${error.message}`);
+    }
+}
+export function getTypeClass(registry, typeDef) {
+    return registry.getUnsafe(typeDef.type, false, typeDef);
+}
+export function createClassUnsafe(registry, type) {
+    return (
+    // just retrieve via name, no creation via typeDef
+    registry.getUnsafe(type) ||
+        // we don't have an existing type, create the class via typeDef
+        getTypeClass(registry, registry.isLookupType(type)
+            ? registry.lookup.getTypeDef(type)
+            : getTypeDef(type)));
+}

package/build/create/index.d.ts

@@ -0,0 +1,2 @@
+export * from './class.js';
+export * from './type.js';

package/build/create/index.js

@@ -0,0 +1,2 @@
+export * from './class.js';
+export * from './type.js';

package/build/create/type.d.ts

@@ -0,0 +1,3 @@
+import type { Codec, Registry } from '@pezkuwi/types-codec/types';
+import type { CreateOptions } from '../types/index.js';
+export declare function createTypeUnsafe<T extends Codec = Codec, K extends string = string>(registry: Registry, type: K, params?: unknown[], options?: CreateOptions): T;

package/build/create/type.js

@@ -0,0 +1,63 @@
+import { Option } from '@pezkuwi/types-codec';
+import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@pezkuwi/util';
+import { createClassUnsafe } from './class.js';
+function checkInstance(created, matcher) {
+    const u8a = created.toU8a();
+    const rawType = created.toRawType();
+    const isOk = (
+    // full match, all ok
+    u8aEq(u8a, matcher) ||
+        (
+        // on a length-prefixed type, just check the actual length
+        ['Bytes', 'Text', 'Type'].includes(rawType) &&
+            matcher.length === created.length) ||
+        (
+        // when the created is empty and matcher is also empty, let it slide...
+        created.isEmpty &&
+            matcher.every((v) => !v)));
+    if (!isOk) {
+        throw new Error(`${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
+    }
+}
+function checkPedantic(created, [value]) {
+    if (isU8a(value)) {
+        checkInstance(created, value);
+    }
+    else if (isHex(value)) {
+        checkInstance(created, u8aToU8a(value));
+    }
+}
+function initType(registry, Type, params = [], { blockHash, isFallback, isOptional, isPedantic } = {}) {
+    const created = new (isOptional
+        ? 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;
+}
+export function createTypeUnsafe(registry, type, params = [], options = {}) {
+    let Clazz = null;
+    let firstError = null;
+    try {
+        Clazz = createClassUnsafe(registry, type);
+        return initType(registry, Clazz, params, options);
+    }
+    catch (error) {
+        firstError = new Error(`createType(${type}):: ${error.message}`);
+    }
+    if (Clazz?.__fallbackType) {
+        try {
+            Clazz = createClassUnsafe(registry, Clazz.__fallbackType);
+            return initType(registry, Clazz, params, options);
+        }
+        catch {
+            // swallow, we will throw the first error again
+        }
+    }
+    throw firstError;
+}

package/build/exports.d.ts

@@ -0,0 +1,2 @@
+export * from './create/index.js';
+export * from './util/index.js';

package/build/exports.js

@@ -0,0 +1,2 @@
+export * from './create/index.js';
+export * from './util/index.js';

package/build/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build/index.js

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';