@polkadot/types-create 8.8.3-1 → 8.8.3-12

package/cjs/create/class.js

@@ -26,12 +26,18 @@ function getTypeDefType(_ref) {
 }
 
 function getSubDefArray(value) {
-  (0, _util.assert)(value.sub && Array.isArray(value.sub), () => `Expected subtype as TypeDef[] in ${(0, _util.stringify)(value)}`);
+  if (!Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef[] in ${(0, _util.stringify)(value)}`);
+  }
+
   return value.sub;
 }
 
 function getSubDef(value) {
-  (0, _util.assert)(value.sub && !Array.isArray(value.sub), () => `Expected subtype as TypeDef in ${(0, _util.stringify)(value)}`);
+  if (!value.sub || Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef in ${(0, _util.stringify)(value)}`);
+  }
+
   return value.sub;
 }
 
@@ -61,7 +67,11 @@ function createInt(Clazz, _ref2) {
     displayName,
     length
   } = _ref2;
-  (0, _util.assert)((0, _util.isNumber)(length), () => `Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+
+  if (!(0, _util.isNumber)(length)) {
+    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+  }
+
   return Clazz.with(length, displayName);
 }
 
@@ -117,11 +127,14 @@ const infoMapping = {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   [_types.TypeDefInfo.Null]: (registry, _) => _typesCodec.Null,
   [_types.TypeDefInfo.Option]: (registry, value) => {
-    (0, _util.assert)(value.sub && !Array.isArray(value.sub), 'Expected type information for Option'); // NOTE This is opt-in (unhandled), not by default
+    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(_typesCodec.Option, value);
   },
   [_types.TypeDefInfo.Plain]: (registry, value) => registry.getOrUnknown(value.type),
@@ -151,7 +164,11 @@ const infoMapping = {
     let {
       sub
     } = _ref6;
-    (0, _util.assert)(sub && !Array.isArray(sub), 'Expected type information for vector');
+
+    if (!sub || Array.isArray(sub)) {
+      throw new Error('Expected type information for vector');
+    }
+
     return sub.type === 'u8' ? _typesCodec.Bytes : _typesCodec.Vec.with(getTypeDefType(sub));
   },
   [_types.TypeDefInfo.VecFixed]: (registry, _ref7) => {
@@ -160,7 +177,11 @@ const infoMapping = {
       length,
       sub
     } = _ref7;
-    (0, _util.assert)(sub && (0, _util.isNumber)(length) && !Array.isArray(sub), 'Expected length & type information for fixed vector');
+
+    if (!(0, _util.isNumber)(length) || !sub || Array.isArray(sub)) {
+      throw new Error('Expected length & type information for fixed vector');
+    }
+
     return sub.type === 'u8' ? _typesCodec.U8aFixed.with(length * 8, displayName) : _typesCodec.VecFixed.with(getTypeDefType(sub), length);
   },
   [_types.TypeDefInfo.WrapperKeepOpaque]: (registry, value) => createWithSub(_typesCodec.WrapperKeepOpaque, value),
@@ -170,7 +191,11 @@ const infoMapping = {
 function constructTypeClass(registry, typeDef) {
   try {
     const Type = infoMapping[typeDef.info](registry, typeDef);
-    (0, _util.assert)(Type, 'No class created'); // don't clobber any existing
+
+    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

package/cjs/create/type.js

@@ -22,7 +22,10 @@ function checkInstance(created, matcher) {
   (0, _util.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);
-  (0, _util.assert)(isOk, () => `${rawType}:: Decoded input doesn't match input, received ${(0, _util.u8aToHex)(matcher, 512)} (${matcher.length} bytes), created ${(0, _util.u8aToHex)(u8a, 512)} (${u8a.length} bytes)`);
+
+  if (!isOk) {
+    throw new Error(`${rawType}:: Decoded input doesn't match input, received ${(0, _util.u8aToHex)(matcher, 512)} (${matcher.length} bytes), created ${(0, _util.u8aToHex)(u8a, 512)} (${u8a.length} bytes)`);
+  }
 }
 
 function checkPedantic(created, _ref) {

package/cjs/packageInfo.js

@@ -11,6 +11,6 @@ const packageInfo = {
   name: '@polkadot/types-create',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '8.8.3-1'
+  version: '8.8.3-12'
 };
 exports.packageInfo = packageInfo;

package/cjs/util/encodeTypes.js

@@ -54,7 +54,11 @@ function encodeSubTypes(registry, sub, asEnum, extra) {
     } = _ref;
     return name;
   });
-  (0, _util.assert)(names.every(n => !!n), () => `Subtypes does not have consistent names, ${names.join(', ')}`);
+
+  if (!names.every(n => !!n)) {
+    throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
+  }
+
   const inner = (0, _util.objectSpread)({}, extra);
 
   for (let i = 0; i < sub.length; i++) {
@@ -85,9 +89,13 @@ const encoders = {
     let {
       sub
     } = _ref3;
-    (0, _util.assert)(sub && Array.isArray(sub), 'Unable to encode Enum type'); // c-like enums have all Null entries
+
+    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(_ref4 => {
       let {
         type
@@ -130,7 +138,11 @@ const encoders = {
       length = 8,
       sub
     } = _ref8;
-    (0, _util.assert)(sub && Array.isArray(sub), 'Unable to encode Set type');
+
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Set type');
+    }
+
     return (0, _util.stringify)({
       _set: sub.reduce((all, _ref9, count) => {
         let {
@@ -158,7 +170,11 @@ const encoders = {
       alias,
       sub
     } = _ref11;
-    (0, _util.assert)(sub && Array.isArray(sub), 'Unable to encode Struct type');
+
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Struct type');
+    }
+
     return encodeSubTypes(registry, sub, false, alias ? {
       _alias: [...alias.entries()].reduce((all, _ref12) => {
         let [k, v] = _ref12;
@@ -172,7 +188,11 @@ const encoders = {
     let {
       sub
     } = _ref13;
-    (0, _util.assert)(sub && Array.isArray(sub), 'Unable to encode Tuple type');
+
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Tuple type');
+    }
+
     return `(${sub.map(type => encodeTypeDef(registry, type)).join(',')})`;
   },
   [_types.TypeDefInfo.UInt]: (registry, _ref14) => {
@@ -187,7 +207,11 @@ const encoders = {
       length,
       sub
     } = _ref15;
-    (0, _util.assert)((0, _util.isNumber)(length) && !(0, _util.isUndefined)(sub) && !Array.isArray(sub), 'Unable to encode VecFixed type');
+
+    if (!(0, _util.isNumber)(length) || !sub || Array.isArray(sub)) {
+      throw new Error('Unable to encode VecFixed type');
+    }
+
     return `[${sub.type};${length}]`;
   },
   [_types.TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef) => encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),

package/cjs/util/getTypeDef.js

@@ -15,7 +15,6 @@ var _typeSplit = require("./typeSplit");
 
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-const MAX_NESTED = 64;
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
 function getTypeString(typeOrObj) {
@@ -26,7 +25,10 @@ function isRustEnum(details) {
   const values = Object.values(details);
 
   if (values.some(v => (0, _util.isNumber)(v))) {
-    (0, _util.assert)(values.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    if (!values.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255)) {
+      throw new Error('Invalid number-indexed enum definition');
+    }
+
     return false;
   }
 
@@ -121,21 +123,42 @@ function _decodeFixedVec(value, type, _, count) {
   let inner = 0;
 
   for (let i = 1; i < max && index === -1; i++) {
-    if (type[i] === ';' && inner === 0) {
-      index = i;
-    } else if (['[', '(', '<'].includes(type[i])) {
-      inner++;
-    } else if ([']', ')', '>'].includes(type[i])) {
-      inner--;
+    switch (type[i]) {
+      case ';':
+        {
+          if (inner === 0) {
+            index = i;
+          }
+
+          break;
+        }
+
+      case '[':
+      case '(':
+      case '<':
+        inner++;
+        break;
+
+      case ']':
+      case ')':
+      case '>':
+        inner--;
+        break;
     }
   }
 
-  (0, _util.assert)(index !== -1, () => `${type}: Unable to extract location of ';'`);
+  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); // as a first round, only u8 via u8aFixed, we can add more support
+  const length = parseInt(strLength.trim(), 10);
+
+  if (length > 2048) {
+    throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
+  }
 
-  (0, _util.assert)(length <= 256, () => `${type}: Only support for [Type; <length>], where length <= 256`);
   value.displayName = displayName;
   value.length = length;
   value.sub = getTypeDef(vecType, {}, count);
@@ -152,9 +175,12 @@ function _decodeTuple(value, _, subType, count) {
 
 function _decodeAnyInt(value, type, _, clazz) {
   const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
-  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
+  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}`);
+  }
 
-  (0, _util.assert)(length <= 8192 && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
   value.displayName = displayName;
   value.length = length;
   return value;
@@ -187,8 +213,7 @@ const wrappedExtraction = [['BTreeSet<', '>', _types.TypeDefInfo.BTreeSet], ['Co
 function extractSubType(type, _ref6) {
   let [start, end] = _ref6;
   return type.substring(start.length, type.length - end.length);
-} // eslint-disable-next-line @typescript-eslint/ban-types
-
+}
 
 function getTypeDef(_type) {
   let {
@@ -204,7 +229,11 @@ function getTypeDef(_type) {
     name,
     type
   };
-  (0, _util.assert)(++count !== MAX_NESTED, 'getTypeDef: Maximum nested limit reached');
+
+  if (++count > 64) {
+    throw new Error('getTypeDef: Maximum nested limit reached');
+  }
+
   const nested = nestedExtraction.find(nested => hasWrapper(type, nested));
 
   if (nested) {

package/cjs/util/typeSplit.js

@@ -5,76 +5,75 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.typeSplit = typeSplit;
 
-var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-function isNotNested() {
-  for (var _len = arguments.length, counters = new Array(_len), _key = 0; _key < _len; _key++) {
-    counters[_key] = arguments[_key];
-  }
-
-  return !counters.some(counter => counter !== 0);
-} // safely split a string on ', ' while taking care of any nested occurences
-
-
+// safely split a string on ', ' while taking care of any nested occurences
 function typeSplit(type) {
-  let [cDepth, fDepth, sDepth, tDepth, start] = [0, 0, 0, 0, 0];
-  const result = [];
+  const result = []; // these are the depths of the various tokens: <, [, {, (
 
-  const extract = index => {
-    if (isNotNested(cDepth, fDepth, sDepth, tDepth)) {
-      result.push(type.substring(start, index).trim());
-      start = index + 1;
-    }
-  };
+  let c = 0;
+  let f = 0;
+  let s = 0;
+  let t = 0; // current start position
 
-  for (let index = 0; index < type.length; index++) {
-    switch (type[index]) {
+  let start = 0;
+
+  for (let i = 0; i < type.length; i++) {
+    switch (type[i]) {
       // if we are not nested, add the type
       case ',':
-        extract(index);
-        break;
+        {
+          if (!(c || f || s || t)) {
+            result.push(type.substring(start, i).trim());
+            start = i + 1;
+          }
+
+          break;
+        }
       // adjust compact/vec (and friends) depth
 
       case '<':
-        cDepth++;
+        c++;
         break;
 
       case '>':
-        cDepth--;
+        c--;
         break;
       // adjust fixed vec depths
 
       case '[':
-        fDepth++;
+        f++;
         break;
 
       case ']':
-        fDepth--;
+        f--;
         break;
       // adjust struct depth
 
       case '{':
-        sDepth++;
+        s++;
         break;
 
       case '}':
-        sDepth--;
+        s--;
         break;
       // adjust tuple depth
 
       case '(':
-        tDepth++;
+        t++;
         break;
 
       case ')':
-        tDepth--;
+        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
 
-  (0, _util.assert)(isNotNested(cDepth, fDepth, sDepth, tDepth), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
 
   result.push(type.substring(start, type.length).trim());
   return result;

package/create/class.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from '@polkadot/types-codec';
-import { assert, isNumber, stringify } from '@polkadot/util';
+import { isNumber, stringify } from '@polkadot/util';
 import { TypeDefInfo } from "../types/index.js";
 import { getTypeDef } from "../util/getTypeDef.js";
 
@@ -13,12 +13,18 @@ function getTypeDefType({
 }
 
 function getSubDefArray(value) {
-  assert(value.sub && Array.isArray(value.sub), () => `Expected subtype as TypeDef[] in ${stringify(value)}`);
+  if (!Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
+  }
+
   return value.sub;
 }
 
 function getSubDef(value) {
-  assert(value.sub && !Array.isArray(value.sub), () => `Expected subtype as TypeDef in ${stringify(value)}`);
+  if (!value.sub || Array.isArray(value.sub)) {
+    throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
+  }
+
   return value.sub;
 }
 
@@ -47,7 +53,10 @@ function createInt(Clazz, {
   displayName,
   length
 }) {
-  assert(isNumber(length), () => `Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+  if (!isNumber(length)) {
+    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
+  }
+
   return Clazz.with(length, displayName);
 }
 
@@ -98,11 +107,14 @@ const infoMapping = {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   [TypeDefInfo.Null]: (registry, _) => Null,
   [TypeDefInfo.Option]: (registry, value) => {
-    assert(value.sub && !Array.isArray(value.sub), 'Expected type information for Option'); // NOTE This is opt-in (unhandled), not by default
+    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),
@@ -130,7 +142,10 @@ const infoMapping = {
   [TypeDefInfo.Vec]: (registry, {
     sub
   }) => {
-    assert(sub && !Array.isArray(sub), 'Expected type information for vector');
+    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, {
@@ -138,7 +153,10 @@ const infoMapping = {
     length,
     sub
   }) => {
-    assert(sub && isNumber(length) && !Array.isArray(sub), 'Expected length & type information for fixed vector');
+    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),
@@ -147,7 +165,11 @@ const infoMapping = {
 export function constructTypeClass(registry, typeDef) {
   try {
     const Type = infoMapping[typeDef.info](registry, typeDef);
-    assert(Type, 'No class created'); // don't clobber any existing
+
+    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

package/create/type.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { Option } from '@polkadot/types-codec';
-import { assert, isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { createClassUnsafe } from "./class.js"; // With isPedantic, actually check that the encoding matches that supplied. This
 // is much slower, but verifies that we have the correct types defined
 
@@ -12,7 +12,10 @@ function checkInstance(created, matcher) {
   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);
-  assert(isOk, () => `${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
+
+  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]) {

package/package.json

@@ -20,7 +20,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "8.8.3-1",
+  "version": "8.8.3-12",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -121,7 +121,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.18.3",
-    "@polkadot/types-codec": "8.8.3-1",
-    "@polkadot/util": "^9.4.1"
+    "@polkadot/types-codec": "8.8.3-12",
+    "@polkadot/util": "^9.4.2-22"
   }
 }

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-create',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '8.8.3-1'
+  version: '8.8.3-12'
 };

package/util/encodeTypes.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isNumber, isUndefined, objectSpread, stringify } from '@polkadot/util';
+import { isNumber, isUndefined, objectSpread, stringify } from '@polkadot/util';
 import { TypeDefInfo } from "../types/index.js";
 
 const stringIdentity = value => value.toString();
@@ -39,7 +39,11 @@ function encodeSubTypes(registry, sub, asEnum, extra) {
   const names = sub.map(({
     name
   }) => name);
-  assert(names.every(n => !!n), () => `Subtypes does not have consistent names, ${names.join(', ')}`);
+
+  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++) {
@@ -66,9 +70,12 @@ const encoders = {
   [TypeDefInfo.Enum]: (registry, {
     sub
   }) => {
-    assert(sub && Array.isArray(sub), 'Unable to encode Enum type'); // c-like enums have all Null entries
+    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({
@@ -98,7 +105,10 @@ const encoders = {
     length = 8,
     sub
   }) => {
-    assert(sub && Array.isArray(sub), 'Unable to encode Set type');
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Set type');
+    }
+
     return stringify({
       _set: sub.reduce((all, {
         index,
@@ -119,7 +129,10 @@ const encoders = {
     alias,
     sub
   }) => {
-    assert(sub && Array.isArray(sub), 'Unable to encode Struct type');
+    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
@@ -129,7 +142,10 @@ const encoders = {
   [TypeDefInfo.Tuple]: (registry, {
     sub
   }) => {
-    assert(sub && Array.isArray(sub), 'Unable to encode Tuple type');
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Tuple type');
+    }
+
     return `(${sub.map(type => encodeTypeDef(registry, type)).join(',')})`;
   },
   [TypeDefInfo.UInt]: (registry, {
@@ -140,7 +156,10 @@ const encoders = {
     length,
     sub
   }) => {
-    assert(isNumber(length) && !isUndefined(sub) && !Array.isArray(sub), 'Unable to encode VecFixed type');
+    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'),

package/util/getTypeDef.d.ts

@@ -1,7 +1,8 @@
+import type { AnyString } from '@polkadot/types-codec/types';
 import type { TypeDef } from '@polkadot/types-create/types';
 interface TypeDefOptions {
     name?: string;
     displayName?: string;
 }
-export declare function getTypeDef(_type: String | string, { displayName, name }?: TypeDefOptions, count?: number): TypeDef;
+export declare function getTypeDef(_type: AnyString, { displayName, name }?: TypeDefOptions, count?: number): TypeDef;
 export {};

package/util/getTypeDef.js

@@ -1,10 +1,9 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { sanitize } from '@polkadot/types-codec';
-import { assert, isNumber, isString, objectSpread } from '@polkadot/util';
+import { isNumber, isString, objectSpread } from '@polkadot/util';
 import { TypeDefInfo } from "../types/index.js";
 import { typeSplit } from "./typeSplit.js";
-const MAX_NESTED = 64;
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
 function getTypeString(typeOrObj) {
@@ -15,7 +14,10 @@ function isRustEnum(details) {
   const values = Object.values(details);
 
   if (values.some(v => isNumber(v))) {
-    assert(values.every(v => isNumber(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    if (!values.every(v => isNumber(v) && v >= 0 && v <= 255)) {
+      throw new Error('Invalid number-indexed enum definition');
+    }
+
     return false;
   }
 
@@ -98,21 +100,42 @@ function _decodeFixedVec(value, type, _, count) {
   let inner = 0;
 
   for (let i = 1; i < max && index === -1; i++) {
-    if (type[i] === ';' && inner === 0) {
-      index = i;
-    } else if (['[', '(', '<'].includes(type[i])) {
-      inner++;
-    } else if ([']', ')', '>'].includes(type[i])) {
-      inner--;
+    switch (type[i]) {
+      case ';':
+        {
+          if (inner === 0) {
+            index = i;
+          }
+
+          break;
+        }
+
+      case '[':
+      case '(':
+      case '<':
+        inner++;
+        break;
+
+      case ']':
+      case ')':
+      case '>':
+        inner--;
+        break;
     }
   }
 
-  assert(index !== -1, () => `${type}: Unable to extract location of ';'`);
+  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); // as a first round, only u8 via u8aFixed, we can add more support
+  const length = parseInt(strLength.trim(), 10);
+
+  if (length > 2048) {
+    throw new Error(`${type}: Only support for [Type; <length>], where length <= 2048`);
+  }
 
-  assert(length <= 256, () => `${type}: Only support for [Type; <length>], where length <= 256`);
   value.displayName = displayName;
   value.length = length;
   value.sub = getTypeDef(vecType, {}, count);
@@ -129,9 +152,12 @@ function _decodeTuple(value, _, subType, count) {
 
 function _decodeAnyInt(value, type, _, clazz) {
   const [strLength, displayName] = type.substring(clazz.length + 1, type.length - 1).split(',');
-  const length = parseInt(strLength.trim(), 10); // as a first round, only u8 via u8aFixed, we can add more support
+  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}`);
+  }
 
-  assert(length <= 8192 && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= 8192 and a power of 8, found ${length}`);
   value.displayName = displayName;
   value.length = length;
   return value;
@@ -162,8 +188,7 @@ const wrappedExtraction = [['BTreeSet<', '>', TypeDefInfo.BTreeSet], ['Compact<'
 
 function extractSubType(type, [start, end]) {
   return type.substring(start.length, type.length - end.length);
-} // eslint-disable-next-line @typescript-eslint/ban-types
-
+}
 
 export function getTypeDef(_type, {
   displayName,
@@ -177,7 +202,11 @@ export function getTypeDef(_type, {
     name,
     type
   };
-  assert(++count !== MAX_NESTED, 'getTypeDef: Maximum nested limit reached');
+
+  if (++count > 64) {
+    throw new Error('getTypeDef: Maximum nested limit reached');
+  }
+
   const nested = nestedExtraction.find(nested => hasWrapper(type, nested));
 
   if (nested) {

package/util/typeSplit.js

@@ -1,69 +1,72 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert } from '@polkadot/util';
-
-function isNotNested(...counters) {
-  return !counters.some(counter => counter !== 0);
-} // safely split a string on ', ' while taking care of any nested occurences
-
-
+// safely split a string on ', ' while taking care of any nested occurences
 export function typeSplit(type) {
-  let [cDepth, fDepth, sDepth, tDepth, start] = [0, 0, 0, 0, 0];
-  const result = [];
+  const result = []; // these are the depths of the various tokens: <, [, {, (
 
-  const extract = index => {
-    if (isNotNested(cDepth, fDepth, sDepth, tDepth)) {
-      result.push(type.substring(start, index).trim());
-      start = index + 1;
-    }
-  };
+  let c = 0;
+  let f = 0;
+  let s = 0;
+  let t = 0; // current start position
+
+  let start = 0;
 
-  for (let index = 0; index < type.length; index++) {
-    switch (type[index]) {
+  for (let i = 0; i < type.length; i++) {
+    switch (type[i]) {
       // if we are not nested, add the type
       case ',':
-        extract(index);
-        break;
+        {
+          if (!(c || f || s || t)) {
+            result.push(type.substring(start, i).trim());
+            start = i + 1;
+          }
+
+          break;
+        }
       // adjust compact/vec (and friends) depth
 
       case '<':
-        cDepth++;
+        c++;
         break;
 
       case '>':
-        cDepth--;
+        c--;
         break;
       // adjust fixed vec depths
 
       case '[':
-        fDepth++;
+        f++;
         break;
 
       case ']':
-        fDepth--;
+        f--;
         break;
       // adjust struct depth
 
       case '{':
-        sDepth++;
+        s++;
         break;
 
       case '}':
-        sDepth--;
+        s--;
         break;
       // adjust tuple depth
 
       case '(':
-        tDepth++;
+        t++;
         break;
 
       case ')':
-        tDepth--;
+        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
 
-  assert(isNotNested(cDepth, fDepth, sDepth, tDepth), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
 
   result.push(type.substring(start, type.length).trim());
   return result;