@polkadot/types-create 8.8.3-11 → 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-11'
+  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,9 +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 MAX_FIX_LEN = 2048;
-const MAX_BIT_LEN = 8192;
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
 function getTypeString(typeOrObj) {
@@ -28,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;
   }
 
@@ -147,11 +147,18 @@ function _decodeFixedVec(value, type, _, count) {
     }
   }
 
-  (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);
-  (0, _util.assert)(length <= MAX_FIX_LEN, () => `${type}: Only support for [Type; <length>], where length <= ${MAX_FIX_LEN}`);
+
+  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);
@@ -169,7 +176,11 @@ 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);
-  (0, _util.assert)(length <= MAX_BIT_LEN && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= ${MAX_BIT_LEN} and a power of 8, found ${length}`);
+
+  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;
@@ -218,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,8 +5,6 @@ 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
 // safely split a string on ', ' while taking care of any nested occurences
@@ -72,7 +70,10 @@ function typeSplit(type) {
   } // ensure we have all the terminators taken care of
 
 
-  (0, _util.assert)(!(c || f || s || t), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
+  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/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-11",
+  "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-11",
+    "@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-11'
+  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.js

@@ -1,12 +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 MAX_FIX_LEN = 2048;
-const MAX_BIT_LEN = 8192;
 const KNOWN_INTERNALS = ['_alias', '_fallback'];
 
 function getTypeString(typeOrObj) {
@@ -17,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;
   }
 
@@ -124,11 +124,18 @@ function _decodeFixedVec(value, type, _, count) {
     }
   }
 
-  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);
-  assert(length <= MAX_FIX_LEN, () => `${type}: Only support for [Type; <length>], where length <= ${MAX_FIX_LEN}`);
+
+  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);
@@ -146,7 +153,11 @@ 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);
-  assert(length <= MAX_BIT_LEN && length % 8 === 0, () => `${type}: Only support for ${clazz}<bitLength>, where length <= ${MAX_BIT_LEN} and a power of 8, found ${length}`);
+
+  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;
@@ -191,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,7 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-create authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert } from '@polkadot/util'; // 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) {
   const result = []; // these are the depths of the various tokens: <, [, {, (
 
@@ -64,7 +63,10 @@ export function typeSplit(type) {
   } // ensure we have all the terminators taken care of
 
 
-  assert(!(c || f || s || t), () => `Invalid definition (missing terminators) found in ${type}`); // the final leg of the journey
+  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;