@polkadot/types-create 9.14.2 → 10.0.1

package/util/encodeTypes.js

@@ -1,168 +1,124 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { isNumber, isUndefined, objectSpread, stringify } from '@polkadot/util';
-import { TypeDefInfo } from "../types/index.js";
-const stringIdentity = value => value.toString();
+import { TypeDefInfo } from '../types/index.js';
+const stringIdentity = (value) => value.toString();
 const INFO_WRAP = ['BTreeMap', 'BTreeSet', 'Compact', 'HashMap', 'Option', 'Result', 'Vec'];
 export function paramsNotation(outer, inner, transform = stringIdentity) {
-  return `${outer}${inner ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>` : ''}`;
+    return `${outer}${inner
+        ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>`
+        : ''}`;
 }
 function encodeWithParams(registry, typeDef, outer) {
-  const {
-    info,
-    sub
-  } = typeDef;
-  switch (info) {
-    case TypeDefInfo.BTreeMap:
-    case TypeDefInfo.BTreeSet:
-    case TypeDefInfo.Compact:
-    case TypeDefInfo.HashMap:
-    case TypeDefInfo.Linkage:
-    case TypeDefInfo.Option:
-    case TypeDefInfo.Range:
-    case TypeDefInfo.RangeInclusive:
-    case TypeDefInfo.Result:
-    case TypeDefInfo.Vec:
-    case TypeDefInfo.WrapperKeepOpaque:
-    case TypeDefInfo.WrapperOpaque:
-      return paramsNotation(outer, sub, p => encodeTypeDef(registry, p));
-  }
-  throw new Error(`Unable to encode ${stringify(typeDef)} with params`);
+    const { info, sub } = typeDef;
+    switch (info) {
+        case TypeDefInfo.BTreeMap:
+        case TypeDefInfo.BTreeSet:
+        case TypeDefInfo.Compact:
+        case TypeDefInfo.HashMap:
+        case TypeDefInfo.Linkage:
+        case TypeDefInfo.Option:
+        case TypeDefInfo.Range:
+        case TypeDefInfo.RangeInclusive:
+        case TypeDefInfo.Result:
+        case TypeDefInfo.Vec:
+        case TypeDefInfo.WrapperKeepOpaque:
+        case TypeDefInfo.WrapperOpaque:
+            return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
+    }
+    throw new Error(`Unable to encode ${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 = objectSpread({}, extra);
-  for (let i = 0; i < sub.length; i++) {
-    const def = sub[i];
-    inner[def.name] = encodeTypeDef(registry, def);
-  }
-  return stringify(asEnum ? {
-    _enum: inner
-  } : inner);
-}
-
-// We setup a record here to ensure we have comprehensive coverage (any item not covered will result
-// in a compile-time error with the missing index)
-const encoders = {
-  [TypeDefInfo.BTreeMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeMap'),
-  [TypeDefInfo.BTreeSet]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeSet'),
-  [TypeDefInfo.Compact]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Compact'),
-  [TypeDefInfo.DoNotConstruct]: (registry, {
-    displayName,
-    lookupIndex,
-    lookupName
-  }) => `DoNotConstruct<${lookupName || displayName || (isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
-  [TypeDefInfo.Enum]: (registry, {
-    sub
-  }) => {
-    if (!Array.isArray(sub)) {
-      throw new Error('Unable to encode Enum type');
-    }
-
-    // c-like enums have all Null entries
-    // TODO We need to take the disciminant into account and auto-add empty entries
-    return sub.every(({
-      type
-    }) => type === 'Null') ? stringify({
-      _enum: sub.map(({
-        name
-      }, index) => `${name || `Empty${index}`}`)
-    }) : encodeSubTypes(registry, sub, true);
-  },
-  [TypeDefInfo.HashMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'HashMap'),
-  [TypeDefInfo.Int]: (registry, {
-    length = 32
-  }) => `Int<${length}>`,
-  [TypeDefInfo.Linkage]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Linkage'),
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Null]: (registry, typeDef) => 'Null',
-  [TypeDefInfo.Option]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Option'),
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Plain]: (registry, {
-    displayName,
-    type
-  }) => displayName || type,
-  [TypeDefInfo.Range]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Range'),
-  [TypeDefInfo.RangeInclusive]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'RangeInclusive'),
-  [TypeDefInfo.Result]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Result'),
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Set]: (registry, {
-    length = 8,
-    sub
-  }) => {
-    if (!Array.isArray(sub)) {
-      throw new Error('Unable to encode Set type');
-    }
-    return stringify({
-      _set: sub.reduce((all, {
-        index,
-        name
-      }, count) => objectSpread(all, {
-        [`${name || `Unknown${index || count}`}`]: index || count
-      }), {
-        _bitLength: length || 8
-      })
-    });
-  },
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [TypeDefInfo.Si]: (registry, {
-    lookupName,
-    type
-  }) => lookupName || type,
-  [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]) => objectSpread(all, {
-        [k]: v
-      }), {})
-    } : {});
-  },
-  [TypeDefInfo.Tuple]: (registry, {
-    sub
-  }) => {
-    if (!Array.isArray(sub)) {
-      throw new Error('Unable to encode Tuple type');
+    const names = sub.map(({ name }) => name);
+    if (!names.every((n) => !!n)) {
+        throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
     }
-    return `(${sub.map(type => encodeTypeDef(registry, type)).join(',')})`;
-  },
-  [TypeDefInfo.UInt]: (registry, {
-    length = 32
-  }) => `UInt<${length}>`,
-  [TypeDefInfo.Vec]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Vec'),
-  [TypeDefInfo.VecFixed]: (registry, {
-    length,
-    sub
-  }) => {
-    if (!isNumber(length) || !sub || Array.isArray(sub)) {
-      throw new Error('Unable to encode VecFixed type');
+    const inner = objectSpread({}, extra);
+    for (let i = 0; i < sub.length; i++) {
+        const def = sub[i];
+        inner[def.name] = encodeTypeDef(registry, def);
     }
-    return `[${sub.type};${length}]`;
-  },
-  [TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
-  [TypeDefInfo.WrapperOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperOpaque')
+    return stringify(asEnum
+        ? { _enum: inner }
+        : inner);
+}
+const encoders = {
+    [TypeDefInfo.BTreeMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeMap'),
+    [TypeDefInfo.BTreeSet]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'BTreeSet'),
+    [TypeDefInfo.Compact]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Compact'),
+    [TypeDefInfo.DoNotConstruct]: (registry, { displayName, lookupIndex, lookupName }) => `DoNotConstruct<${lookupName || displayName || (isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
+    [TypeDefInfo.Enum]: (registry, { sub }) => {
+        if (!Array.isArray(sub)) {
+            throw new Error('Unable to encode Enum type');
+        }
+        // c-like enums have all Null entries
+        // TODO We need to take the disciminant into account and auto-add empty entries
+        return sub.every(({ type }) => type === 'Null')
+            ? stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
+            : encodeSubTypes(registry, sub, true);
+    },
+    [TypeDefInfo.HashMap]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'HashMap'),
+    [TypeDefInfo.Int]: (registry, { length = 32 }) => `Int<${length}>`,
+    [TypeDefInfo.Linkage]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Linkage'),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    [TypeDefInfo.Null]: (registry, typeDef) => 'Null',
+    [TypeDefInfo.Option]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Option'),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    [TypeDefInfo.Plain]: (registry, { displayName, type }) => displayName || type,
+    [TypeDefInfo.Range]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Range'),
+    [TypeDefInfo.RangeInclusive]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'RangeInclusive'),
+    [TypeDefInfo.Result]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Result'),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    [TypeDefInfo.Set]: (registry, { length = 8, sub }) => {
+        if (!Array.isArray(sub)) {
+            throw new Error('Unable to encode Set type');
+        }
+        return stringify({
+            _set: sub.reduce((all, { index, name }, count) => objectSpread(all, { [`${name || `Unknown${index || count}`}`]: index || count }), { _bitLength: length || 8 })
+        });
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    [TypeDefInfo.Si]: (registry, { lookupName, type }) => lookupName || type,
+    [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]) => objectSpread(all, { [k]: v }), {})
+            }
+            : {});
+    },
+    [TypeDefInfo.Tuple]: (registry, { sub }) => {
+        if (!Array.isArray(sub)) {
+            throw new Error('Unable to encode Tuple type');
+        }
+        return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
+    },
+    [TypeDefInfo.UInt]: (registry, { length = 32 }) => `UInt<${length}>`,
+    [TypeDefInfo.Vec]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'Vec'),
+    [TypeDefInfo.VecFixed]: (registry, { length, sub }) => {
+        if (!isNumber(length) || !sub || Array.isArray(sub)) {
+            throw new Error('Unable to encode VecFixed type');
+        }
+        return `[${sub.type};${length}]`;
+    },
+    [TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
+    [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);
+    return withLookup && typeDef.lookupName
+        ? typeDef.lookupName
+        : encoders[typeDef.info](registry, typeDef);
 }
 export function encodeTypeDef(registry, typeDef) {
-  // In the case of contracts we do have the unfortunate situation where the displayName would
-  // refer to "Option" when it is an option. For these, string it out, only using when actually
-  // not a top-level element to be used
-  return typeDef.displayName && !INFO_WRAP.some(i => typeDef.displayName === i) ? typeDef.displayName : encodeType(registry, typeDef);
+    // In the case of contracts we do have the unfortunate situation where the displayName would
+    // refer to "Option" when it is an option. For these, string it out, only using when actually
+    // not a top-level element to be used
+    return (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i))
+        ? typeDef.displayName
+        : encodeType(registry, typeDef);
 }
 export function withTypeString(registry, typeDef) {
-  return objectSpread({}, typeDef, {
-    type: encodeType(registry, typeDef, false)
-  });
+    return objectSpread({}, typeDef, {
+        type: encodeType(registry, typeDef, false)
+    });
 }

package/util/getTypeDef.js

@@ -1,198 +1,192 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { sanitize } from '@polkadot/types-codec';
 import { isNumber, isString, objectSpread } from '@polkadot/util';
-import { TypeDefInfo } from "../types/index.js";
-import { typeSplit } from "./typeSplit.js";
+import { TypeDefInfo } from '../types/index.js';
+import { typeSplit } from './typeSplit.js';
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 function getTypeString(typeOrObj) {
-  return isString(typeOrObj) ? typeOrObj.toString() : JSON.stringify(typeOrObj);
+    return isString(typeOrObj)
+        ? typeOrObj.toString()
+        : JSON.stringify(typeOrObj);
 }
 function isRustEnum(details) {
-  const values = Object.values(details);
-  if (values.some(v => isNumber(v))) {
-    if (!values.every(v => isNumber(v) && v >= 0 && v <= 255)) {
-      throw new Error('Invalid number-indexed enum definition');
+    const values = Object.values(details);
+    if (values.some((v) => isNumber(v))) {
+        if (!values.every((v) => isNumber(v) && v >= 0 && v <= 255)) {
+            throw new Error('Invalid number-indexed enum definition');
+        }
+        return false;
     }
-    return false;
-  }
-  return true;
+    return true;
 }
-
-// decode an enum of either of the following forms
-//  { _enum: ['A', 'B', 'C'] }
-//  { _enum: { A: AccountId, B: Balance, C: u32 } }
-//  { _enum: { A: 1, B: 2 } }
 function _decodeEnum(value, details, count, fallbackType) {
-  value.info = 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: TypeDefInfo.Plain,
-      name,
-      type: 'Null'
-    }));
-  } else if (isRustEnum(details)) {
-    value.sub = Object.entries(details).map(([name, typeOrObj], index) => objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), {
-      name
-    }, count), {
-      index
-    }));
-  } else {
-    value.sub = Object.entries(details).map(([name, index]) => ({
-      index,
-      info: TypeDefInfo.Plain,
-      name,
-      type: 'Null'
-    }));
-  }
-  return value;
+    value.info = 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: TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    else if (isRustEnum(details)) {
+        value.sub = Object.entries(details).map(([name, typeOrObj], index) => objectSpread({}, getTypeDef(getTypeString(typeOrObj || 'Null'), { name }, count), { index }));
+    }
+    else {
+        value.sub = Object.entries(details).map(([name, index]) => ({
+            index,
+            info: TypeDefInfo.Plain,
+            name,
+            type: 'Null'
+        }));
+    }
+    return value;
 }
-
-// decode a set of the form
-//   { _set: { A: 0b0001, B: 0b0010, C: 0b0100 } }
 function _decodeSet(value, details, fallbackType) {
-  value.info = TypeDefInfo.Set;
-  value.fallbackType = fallbackType;
-  value.length = details._bitLength;
-  value.sub = Object.entries(details).filter(([name]) => !name.startsWith('_')).map(([name, index]) => ({
-    index,
-    info: TypeDefInfo.Plain,
-    name,
-    type: 'Null'
-  }));
-  return value;
+    value.info = TypeDefInfo.Set;
+    value.fallbackType = fallbackType;
+    value.length = details._bitLength;
+    value.sub = Object
+        .entries(details)
+        .filter(([name]) => !name.startsWith('_'))
+        .map(([name, index]) => ({
+        index,
+        info: TypeDefInfo.Plain,
+        name,
+        type: 'Null'
+    }));
+    return value;
 }
-
-// decode a struct, set or enum
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeStruct(value, type, _, count) {
-  const parsed = JSON.parse(type);
-  const keys = Object.keys(parsed);
-  if (keys.includes('_enum')) {
-    return _decodeEnum(value, parsed._enum, count, parsed._fallback);
-  } else if (keys.includes('_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;
+    const parsed = JSON.parse(type);
+    const keys = Object.keys(parsed);
+    if (keys.includes('_enum')) {
+        return _decodeEnum(value, parsed._enum, count, parsed._fallback);
+    }
+    else if (keys.includes('_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;
 }
-
-// decode a fixed vector, e.g. [u8;32]
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 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;
+    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;
         }
-      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;
+    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;
 }
-
-// decode a tuple
 function _decodeTuple(value, _, subType, count) {
-  value.sub = subType.length === 0 ? [] : typeSplit(subType).map(inner => getTypeDef(inner, {}, count));
-  return value;
+    value.sub = subType.length === 0
+        ? []
+        : typeSplit(subType).map((inner) => getTypeDef(inner, {}, count));
+    return value;
 }
-
-// decode a Int/UInt<bitLength[, name]>
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 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;
+    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');
+    return _decodeAnyInt(value, type, subType, 'Int');
 }
 function _decodeUInt(value, type, subType) {
-  return _decodeAnyInt(value, type, subType, 'UInt');
+    return _decodeAnyInt(value, type, subType, 'UInt');
 }
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function _decodeDoNotConstruct(value, type, _) {
-  const NAME_LENGTH = 'DoNotConstruct'.length;
-  value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
-  return value;
+    const NAME_LENGTH = 'DoNotConstruct'.length;
+    value.displayName = type.substring(NAME_LENGTH + 1, type.length - 1);
+    return value;
 }
 function hasWrapper(type, [start, end]) {
-  return type.substring(0, start.length) === start && type.slice(-1 * end.length) === end;
+    return (type.substring(0, start.length) === start) && (type.slice(-1 * end.length) === end);
 }
-const nestedExtraction = [['[', ']', TypeDefInfo.VecFixed, _decodeFixedVec], ['{', '}', TypeDefInfo.Struct, _decodeStruct], ['(', ')', TypeDefInfo.Tuple, _decodeTuple],
-// the inner for these are the same as tuple, multiple values
-['BTreeMap<', '>', TypeDefInfo.BTreeMap, _decodeTuple], ['HashMap<', '>', TypeDefInfo.HashMap, _decodeTuple], ['Int<', '>', TypeDefInfo.Int, _decodeInt], ['Result<', '>', TypeDefInfo.Result, _decodeTuple], ['UInt<', '>', TypeDefInfo.UInt, _decodeUInt], ['DoNotConstruct<', '>', TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]];
-const wrappedExtraction = [['BTreeSet<', '>', TypeDefInfo.BTreeSet], ['Compact<', '>', TypeDefInfo.Compact], ['Linkage<', '>', TypeDefInfo.Linkage], ['Opaque<', '>', TypeDefInfo.WrapperOpaque], ['Option<', '>', TypeDefInfo.Option], ['Range<', '>', TypeDefInfo.Range], ['RangeInclusive<', '>', TypeDefInfo.RangeInclusive], ['Vec<', '>', TypeDefInfo.Vec], ['WrapperKeepOpaque<', '>', TypeDefInfo.WrapperKeepOpaque], ['WrapperOpaque<', '>', TypeDefInfo.WrapperOpaque]];
+const nestedExtraction = [
+    ['[', ']', TypeDefInfo.VecFixed, _decodeFixedVec],
+    ['{', '}', TypeDefInfo.Struct, _decodeStruct],
+    ['(', ')', TypeDefInfo.Tuple, _decodeTuple],
+    // the inner for these are the same as tuple, multiple values
+    ['BTreeMap<', '>', TypeDefInfo.BTreeMap, _decodeTuple],
+    ['HashMap<', '>', TypeDefInfo.HashMap, _decodeTuple],
+    ['Int<', '>', TypeDefInfo.Int, _decodeInt],
+    ['Result<', '>', TypeDefInfo.Result, _decodeTuple],
+    ['UInt<', '>', TypeDefInfo.UInt, _decodeUInt],
+    ['DoNotConstruct<', '>', TypeDefInfo.DoNotConstruct, _decodeDoNotConstruct]
+];
+const wrappedExtraction = [
+    ['BTreeSet<', '>', TypeDefInfo.BTreeSet],
+    ['Compact<', '>', TypeDefInfo.Compact],
+    ['Linkage<', '>', TypeDefInfo.Linkage],
+    ['Opaque<', '>', TypeDefInfo.WrapperOpaque],
+    ['Option<', '>', TypeDefInfo.Option],
+    ['Range<', '>', TypeDefInfo.Range],
+    ['RangeInclusive<', '>', TypeDefInfo.RangeInclusive],
+    ['Vec<', '>', TypeDefInfo.Vec],
+    ['WrapperKeepOpaque<', '>', TypeDefInfo.WrapperKeepOpaque],
+    ['WrapperOpaque<', '>', TypeDefInfo.WrapperOpaque]
+];
 function extractSubType(type, [start, end]) {
-  return type.substring(start.length, type.length - end.length);
+    return type.substring(start.length, type.length - end.length);
 }
-export function getTypeDef(_type, {
-  displayName,
-  name
-} = {}, count = 0) {
-  // create the type via Type, allowing types to be sanitized
-  const type = sanitize(_type);
-  const value = {
-    displayName,
-    info: 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;
+export function getTypeDef(_type, { displayName, name } = {}, count = 0) {
+    // create the type via Type, allowing types to be sanitized
+    const type = sanitize(_type);
+    const value = { displayName, info: 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/util/index.js

@@ -1,7 +1,4 @@
-// Copyright 2017-2023 @polkadot/types-create authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from "./encodeTypes.js";
-export * from "./getTypeDef.js";
-export * from "./typeSplit.js";
-export * from "./xcm.js";
+export * from './encodeTypes.js';
+export * from './getTypeDef.js';
+export * from './typeSplit.js';
+export * from './xcm.js';