@polkadot/types-codec 8.8.3-11 → 8.8.3-12

package/abstract/Int.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, BN_ZERO, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isHex, isNumber, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
+import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isHex, isNumber, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
 export const DEFAULT_UINT_BITS = 64; // Maximum allowed integer for JS is 2^53 - 1, set limit at 52
 // In this case however, we always print any >32 as hex
 
@@ -16,7 +16,10 @@ function toPercentage(value, divisor) {
 
 function decodeAbstractInt(value, isNegative) {
   if (isNumber(value)) {
-    assert(value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER && Number.isInteger(value), 'Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
+    if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+      throw new Error('Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
+    }
+
     return value;
   } else if (isString(value)) {
     if (isHex(value, -1, true)) {
@@ -26,7 +29,10 @@ function decodeAbstractInt(value, isNegative) {
       }).toString();
     }
 
-    assert(!(value.includes('.') || value.includes(',') || value.includes('e')), 'String should not contain decimal points or scientific notation');
+    if (value.includes('.') || value.includes(',') || value.includes('e')) {
+      throw new Error('String should not contain decimal points or scientific notation');
+    }
+
     return value;
   } else if (isBn(value)) {
     return value.toString();
@@ -59,10 +65,14 @@ export class AbstractInt extends BN {
     this.#bitLength = bitLength;
     this.encodedLength = this.#bitLength / 8;
     this.isUnsigned = !isSigned;
-    const isPositive = this.gte(BN_ZERO);
-    const maxBits = bitLength - (isSigned && isPositive ? 1 : 0);
-    assert(isSigned || isPositive, () => `${this.toRawType()}: Negative number passed to unsigned type`);
-    assert(super.bitLength() <= maxBits, () => `${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
+    const isNegative = this.isNeg();
+    const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
+
+    if (isNegative && !isSigned) {
+      throw new Error(`${this.toRawType()}: Negative number passed to unsigned type`);
+    } else if (super.bitLength() > maxBits) {
+      throw new Error(`${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
+    }
   }
   /**
    * @description returns a hash of the contents

package/base/Enum.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isHex, isNumber, isObject, isString, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isHex, isNumber, isObject, isString, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { mapToTypeMap, typesToMap } from "../utils/index.js";
 import { Null } from "./Null.js"; // export interface, this is used in Enum.with, so required as public by TS
 
@@ -12,7 +12,10 @@ function isRustEnum(def) {
   const defValues = Object.values(def);
 
   if (defValues.some(v => isNumber(v))) {
-    assert(defValues.every(v => isNumber(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    if (!defValues.every(v => isNumber(v) && v >= 0 && v <= 255)) {
+      throw new Error('Invalid number-indexed enum definition');
+    }
+
     return false;
   }
 
@@ -72,7 +75,11 @@ function extractDef(registry, _def) {
 
 function createFromValue(registry, def, index = 0, value) {
   const entry = Object.values(def).find(e => e.index === index);
-  assert(!isUndefined(entry), () => `Unable to create Enum via index ${index}, in ${Object.keys(def).join(', ')}`);
+
+  if (isUndefined(entry)) {
+    throw new Error(`Unable to create Enum via index ${index}, in ${Object.keys(def).join(', ')}`);
+  }
+
   return {
     index,
     value: value instanceof entry.Type ? value : new entry.Type(registry, value)
@@ -85,7 +92,10 @@ function decodeFromJSON(registry, def, key, value) {
   const keys = Object.keys(def).map(k => k.toLowerCase());
   const keyLower = key.toLowerCase();
   const index = keys.indexOf(keyLower);
-  assert(index !== -1, () => `Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+
+  if (index === -1) {
+    throw new Error(`Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+  }
 
   try {
     return createFromValue(registry, def, Object.values(def)[index].index, value);
@@ -184,7 +194,10 @@ export class Enum {
         });
         objectProperties(this, isKeys, (_, i) => this.type === keys[i]);
         objectProperties(this, asKeys, (k, i) => {
-          assert(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);
+          if (!this[isKeys[i]]) {
+            throw new Error(`Cannot convert '${this.type}' via ${k}`);
+          }
+
           return this.value;
         });
       }

package/base/Option.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
+import { isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
 import { typeToConstructor } from "../utils/index.js";
 import { Null } from "./Null.js";
 
@@ -244,7 +244,10 @@ export class Option {
 
 
   unwrap() {
-    assert(this.isSome, 'Option: unwrapping a None value');
+    if (this.isNone) {
+      throw new Error('Option: unwrapping a None value');
+    }
+
     return this.#raw;
   }
   /**

package/base/Result.js

@@ -1,6 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert } from '@polkadot/util';
 import { Enum } from "./Enum.js";
 /**
  * @name Result
@@ -32,7 +31,10 @@ export class Result extends Enum {
 
 
   get asErr() {
-    assert(this.isErr, 'Cannot extract Err value from Ok result, check isErr first');
+    if (!this.isErr) {
+      throw new Error('Cannot extract Err value from Ok result, check isErr first');
+    }
+
     return this.value;
   }
   /**
@@ -49,7 +51,10 @@ export class Result extends Enum {
 
 
   get asOk() {
-    assert(this.isOk, 'Cannot extract Ok value from Err result, check isOk first');
+    if (!this.isOk) {
+      throw new Error('Cannot extract Ok value from Err result, check isOk first');
+    }
+
     return this.value;
   }
   /**

package/base/Vec.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
+import { compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
@@ -17,7 +17,11 @@ function decodeVecLength(value) {
 
   const u8a = u8aToU8a(value);
   const [startAt, length] = compactFromU8aLim(u8a);
-  assert(length <= MAX_LENGTH, () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+
+  if (length > MAX_LENGTH) {
+    throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  }
+
   return [u8a, length, startAt];
 }
 

package/cjs/abstract/Int.js

@@ -25,7 +25,10 @@ function toPercentage(value, divisor) {
 
 function decodeAbstractInt(value, isNegative) {
   if ((0, _util.isNumber)(value)) {
-    (0, _util.assert)(value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER && Number.isInteger(value), 'Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
+    if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+      throw new Error('Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
+    }
+
     return value;
   } else if ((0, _util.isString)(value)) {
     if ((0, _util.isHex)(value, -1, true)) {
@@ -35,7 +38,10 @@ function decodeAbstractInt(value, isNegative) {
       }).toString();
     }
 
-    (0, _util.assert)(!(value.includes('.') || value.includes(',') || value.includes('e')), 'String should not contain decimal points or scientific notation');
+    if (value.includes('.') || value.includes(',') || value.includes('e')) {
+      throw new Error('String should not contain decimal points or scientific notation');
+    }
+
     return value;
   } else if ((0, _util.isBn)(value)) {
     return value.toString();
@@ -71,10 +77,14 @@ class AbstractInt extends _util.BN {
     this.#bitLength = bitLength;
     this.encodedLength = this.#bitLength / 8;
     this.isUnsigned = !isSigned;
-    const isPositive = this.gte(_util.BN_ZERO);
-    const maxBits = bitLength - (isSigned && isPositive ? 1 : 0);
-    (0, _util.assert)(isSigned || isPositive, () => `${this.toRawType()}: Negative number passed to unsigned type`);
-    (0, _util.assert)(super.bitLength() <= maxBits, () => `${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
+    const isNegative = this.isNeg();
+    const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
+
+    if (isNegative && !isSigned) {
+      throw new Error(`${this.toRawType()}: Negative number passed to unsigned type`);
+    } else if (super.bitLength() > maxBits) {
+      throw new Error(`${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
+    }
   }
   /**
    * @description returns a hash of the contents

package/cjs/base/Enum.js

@@ -21,7 +21,10 @@ function isRustEnum(def) {
   const defValues = Object.values(def);
 
   if (defValues.some(v => (0, _util.isNumber)(v))) {
-    (0, _util.assert)(defValues.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    if (!defValues.every(v => (0, _util.isNumber)(v) && v >= 0 && v <= 255)) {
+      throw new Error('Invalid number-indexed enum definition');
+    }
+
     return false;
   }
 
@@ -86,7 +89,11 @@ function createFromValue(registry, def) {
   let index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
   let value = arguments.length > 3 ? arguments[3] : undefined;
   const entry = Object.values(def).find(e => e.index === index);
-  (0, _util.assert)(!(0, _util.isUndefined)(entry), () => `Unable to create Enum via index ${index}, in ${Object.keys(def).join(', ')}`);
+
+  if ((0, _util.isUndefined)(entry)) {
+    throw new Error(`Unable to create Enum via index ${index}, in ${Object.keys(def).join(', ')}`);
+  }
+
   return {
     index,
     value: value instanceof entry.Type ? value : new entry.Type(registry, value)
@@ -99,7 +106,10 @@ function decodeFromJSON(registry, def, key, value) {
   const keys = Object.keys(def).map(k => k.toLowerCase());
   const keyLower = key.toLowerCase();
   const index = keys.indexOf(keyLower);
-  (0, _util.assert)(index !== -1, () => `Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+
+  if (index === -1) {
+    throw new Error(`Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+  }
 
   try {
     return createFromValue(registry, def, Object.values(def)[index].index, value);
@@ -202,7 +212,10 @@ class Enum {
         });
         (0, _util.objectProperties)(this, isKeys, (_, i) => this.type === keys[i]);
         (0, _util.objectProperties)(this, asKeys, (k, i) => {
-          (0, _util.assert)(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);
+          if (!this[isKeys[i]]) {
+            throw new Error(`Cannot convert '${this.type}' via ${k}`);
+          }
+
           return this.value;
         });
       }

package/cjs/base/Option.js

@@ -254,7 +254,10 @@ class Option {
 
 
   unwrap() {
-    (0, _util.assert)(this.isSome, 'Option: unwrapping a None value');
+    if (this.isNone) {
+      throw new Error('Option: unwrapping a None value');
+    }
+
     return this.#raw;
   }
   /**

package/cjs/base/Result.js

@@ -5,8 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Result = void 0;
 
-var _util = require("@polkadot/util");
-
 var _Enum = require("./Enum");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
@@ -41,7 +39,10 @@ class Result extends _Enum.Enum {
 
 
   get asErr() {
-    (0, _util.assert)(this.isErr, 'Cannot extract Err value from Ok result, check isErr first');
+    if (!this.isErr) {
+      throw new Error('Cannot extract Err value from Ok result, check isErr first');
+    }
+
     return this.value;
   }
   /**
@@ -58,7 +59,10 @@ class Result extends _Enum.Enum {
 
 
   get asOk() {
-    (0, _util.assert)(this.isOk, 'Cannot extract Ok value from Err result, check isOk first');
+    if (!this.isOk) {
+      throw new Error('Cannot extract Ok value from Err result, check isOk first');
+    }
+
     return this.value;
   }
   /**

package/cjs/base/Vec.js

@@ -28,7 +28,11 @@ function decodeVecLength(value) {
 
   const u8a = (0, _util.u8aToU8a)(value);
   const [startAt, length] = (0, _util.compactFromU8aLim)(u8a);
-  (0, _util.assert)(length <= MAX_LENGTH, () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+
+  if (length > MAX_LENGTH) {
+    throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  }
+
   return [u8a, length, startAt];
 }
 

package/cjs/extended/BitVec.js

@@ -21,7 +21,11 @@ function decodeBitVecU8a(value) {
 
   const [offset, length] = (0, _util.compactFromU8aLim)(value);
   const total = offset + Math.ceil(length / 8);
-  (0, _util.assert)(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+
+  if (total > value.length) {
+    throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  }
+
   return [length, value.subarray(offset, total)];
 }
 /** @internal */

package/cjs/extended/Bytes.js

@@ -23,8 +23,13 @@ function decodeBytesU8a(value) {
 
   const [offset, length] = (0, _util.compactFromU8aLim)(value);
   const total = offset + length;
-  (0, _util.assert)(length <= MAX_LENGTH, () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
-  (0, _util.assert)(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+
+  if (length > MAX_LENGTH) {
+    throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  } else if (total > value.length) {
+    throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  }
+
   return [value.subarray(offset, total), total];
 }
 /**

package/cjs/extended/U8aFixed.js

@@ -21,7 +21,10 @@ function decodeU8aFixed(value, bitLength) {
     return [new Uint8Array(byteLength), 0];
   }
 
-  (0, _util.assert)((0, _util.isU8a)(value) ? u8a.length >= byteLength : u8a.length === byteLength, () => `Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  if ((0, _util.isU8a)(value) ? u8a.length < byteLength : u8a.length !== byteLength) {
+    throw new Error(`Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  }
+
   return [u8a.subarray(0, byteLength), byteLength];
 }
 /**

package/cjs/extended/WrapperKeepOpaque.js

@@ -106,7 +106,11 @@ class WrapperKeepOpaque extends _Bytes.Bytes {
 
 
   unwrap() {
-    return (0, _util.assertReturn)(this.#decoded, () => `${this.#opaqueName}: unwrapping an undecodable value`);
+    if (!this.#decoded) {
+      throw new Error(`${this.#opaqueName}: unwrapping an undecodable value`);
+    }
+
+    return this.#decoded;
   }
 
 }

package/cjs/native/Raw.js

@@ -190,7 +190,10 @@ class Raw extends Uint8Array {
 
 
   toUtf8() {
-    (0, _util.assert)(this.isUtf8, 'The character sequence is not a valid Utf8 string');
+    if (!this.isUtf8) {
+      throw new Error('The character sequence is not a valid Utf8 string');
+    }
+
     return (0, _util.u8aToString)(this);
   }
 

package/cjs/native/Set.js

@@ -28,7 +28,11 @@ function decodeSetArray(setValues, values) {
 
   for (let i = 0; i < values.length; i++) {
     const key = values[i];
-    (0, _util.assert)(!(0, _util.isUndefined)(setValues[key]), () => `Set: Invalid key '${key}' passed to Set, allowed ${Object.keys(setValues).join(', ')}`);
+
+    if ((0, _util.isUndefined)(setValues[key])) {
+      throw new Error(`Set: Invalid key '${key}' passed to Set, allowed ${Object.keys(setValues).join(', ')}`);
+    }
+
     result[i] = key;
   }
 
@@ -51,7 +55,11 @@ function decodeSetNumber(setValues, _value) {
   }
 
   const computed = encodeSet(setValues, result);
-  (0, _util.assert)(bn.eq(computed), () => `Set: Mismatch decoding '${bn.toString()}', computed as '${computed.toString()}' with ${result.join(', ')}`);
+
+  if (!bn.eq(computed)) {
+    throw new Error(`Set: Mismatch decoding '${bn.toString()}', computed as '${computed.toString()}' with ${result.join(', ')}`);
+  }
+
   return result;
 }
 /** @internal */
@@ -60,7 +68,11 @@ function decodeSetNumber(setValues, _value) {
 function decodeSet(setValues) {
   let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
   let bitLength = arguments.length > 2 ? arguments[2] : undefined;
-  (0, _util.assert)(bitLength % 8 === 0, () => `Expected valid bitLength, power of 8, found ${bitLength}`);
+
+  if (bitLength % 8 !== 0) {
+    throw new Error(`Expected valid bitLength, power of 8, found ${bitLength}`);
+  }
+
   const byteLength = bitLength / 8;
 
   if ((0, _util.isU8a)(value)) {
@@ -161,7 +173,10 @@ class CodecSet extends Set {
     // ^^^ add = () property done to assign this instance's this, otherwise Set.add creates "some" chaos
     // we have the isUndefined(this._setValues) in here as well, add is used internally
     // in the Set constructor (so it is undefined at this point, and should allow)
-    (0, _util.assert)((0, _util.isUndefined)(this.#allowed) || !(0, _util.isUndefined)(this.#allowed[key]), () => `Set: Invalid key '${key}' on add`);
+    if (this.#allowed && (0, _util.isUndefined)(this.#allowed[key])) {
+      throw new Error(`Set: Invalid key '${key}' on add`);
+    }
+
     super.add(key);
     return this;
   };

package/cjs/native/Struct.js

@@ -22,8 +22,13 @@ function decodeStructFromObject(registry, _ref, value, jsonMap) {
   let jsonObj;
   const typeofArray = Array.isArray(value);
   const typeofMap = value instanceof Map;
-  (0, _util.assert)(typeofArray || typeofMap || (0, _util.isObject)(value), () => `Struct: Cannot decode value ${(0, _util.stringify)(value)} (typeof ${typeof value}), expected an input object, map or array`);
-  (0, _util.assert)(!typeofArray || value.length === keys.length, () => `Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${keys.join(', ')}`);
+
+  if (!typeofArray && !typeofMap && !(0, _util.isObject)(value)) {
+    throw new Error(`Struct: Cannot decode value ${(0, _util.stringify)(value)} (typeof ${typeof value}), expected an input object, map or array`);
+  } else if (typeofArray && value.length !== keys.length) {
+    throw new Error(`Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${keys.join(', ')}`);
+  }
+
   const raw = new Array(keys.length);
 
   for (let i = 0; i < keys.length; i++) {

package/cjs/native/Text.js

@@ -28,8 +28,13 @@ function decodeText(value) {
 
     const [offset, length] = (0, _util.compactFromU8aLim)(value);
     const total = offset + length;
-    (0, _util.assert)(length <= MAX_LENGTH, () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
-    (0, _util.assert)(total <= value.length, () => `Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
+
+    if (length > MAX_LENGTH) {
+      throw new Error(`Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    } else if (total > value.length) {
+      throw new Error(`Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
+    }
+
     return [(0, _util.u8aToString)(value.subarray(offset, total)), total];
   } else if ((0, _util.isHex)(value)) {
     return [(0, _util.u8aToString)((0, _util.hexToU8a)(value)), 0];

package/cjs/packageInfo.js

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

package/extended/BitVec.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8aLim, compactToU8a, isString, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
+import { compactFromU8aLim, compactToU8a, isString, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
 /** @internal */
 
@@ -12,7 +12,11 @@ function decodeBitVecU8a(value) {
 
   const [offset, length] = compactFromU8aLim(value);
   const total = offset + Math.ceil(length / 8);
-  assert(total <= value.length, () => `BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+
+  if (total > value.length) {
+    throw new Error(`BitVec: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  }
+
   return [length, value.subarray(offset, total)];
 }
 /** @internal */

package/extended/Bytes.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactAddLength, compactFromU8aLim, compactToU8a, isString, isU8a, u8aToU8a } from '@polkadot/util';
+import { compactAddLength, compactFromU8aLim, compactToU8a, isString, isU8a, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js"; // Bytes are used for things like on-chain code, so it has a healthy limit
 
 const MAX_LENGTH = 10 * 1024 * 1024;
@@ -14,8 +14,13 @@ function decodeBytesU8a(value) {
 
   const [offset, length] = compactFromU8aLim(value);
   const total = offset + length;
-  assert(length <= MAX_LENGTH, () => `Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
-  assert(total <= value.length, () => `Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+
+  if (length > MAX_LENGTH) {
+    throw new Error(`Bytes length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  } else if (total > value.length) {
+    throw new Error(`Bytes: required length less than remainder, expected at least ${total}, found ${value.length}`);
+  }
+
   return [value.subarray(offset, total), total];
 }
 /**

package/extended/U8aFixed.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isU8a, u8aToU8a } from '@polkadot/util';
+import { isU8a, u8aToU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
 /** @internal */
 
@@ -12,7 +12,10 @@ function decodeU8aFixed(value, bitLength) {
     return [new Uint8Array(byteLength), 0];
   }
 
-  assert(isU8a(value) ? u8a.length >= byteLength : u8a.length === byteLength, () => `Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  if (isU8a(value) ? u8a.length < byteLength : u8a.length !== byteLength) {
+    throw new Error(`Expected input with ${byteLength} bytes (${bitLength} bits), found ${u8a.length} bytes`);
+  }
+
   return [u8a.subarray(0, byteLength), byteLength];
 }
 /**

package/extended/WrapperKeepOpaque.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assertReturn, compactAddLength, compactStripLength, compactToU8a, isHex, isU8a } from '@polkadot/util';
+import { compactAddLength, compactStripLength, compactToU8a, isHex, isU8a } from '@polkadot/util';
 import { Raw } from "../native/Raw.js";
 import { typeToConstructor } from "../utils/index.js";
 import { Bytes } from "./Bytes.js";
@@ -95,7 +95,11 @@ export class WrapperKeepOpaque extends Bytes {
 
 
   unwrap() {
-    return assertReturn(this.#decoded, () => `${this.#opaqueName}: unwrapping an undecodable value`);
+    if (!this.#decoded) {
+      throw new Error(`${this.#opaqueName}: unwrapping an undecodable value`);
+    }
+
+    return this.#decoded;
   }
 
 }

package/native/Raw.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isAscii, isUndefined, isUtf8, u8aToHex, u8aToString, u8aToU8a } from '@polkadot/util';
+import { isAscii, isUndefined, isUtf8, u8aToHex, u8aToString, u8aToU8a } from '@polkadot/util';
 /**
  * @name Raw
  * @description
@@ -182,7 +182,10 @@ export class Raw extends Uint8Array {
 
 
   toUtf8() {
-    assert(this.isUtf8, 'The character sequence is not a valid Utf8 string');
+    if (!this.isUtf8) {
+      throw new Error('The character sequence is not a valid Utf8 string');
+    }
+
     return u8aToString(this);
   }
 

package/native/Set.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, BN, bnToBn, bnToU8a, isBn, isNumber, isString, isU8a, isUndefined, objectProperties, stringify, stringPascalCase, u8aToBn, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { BN, bnToBn, bnToU8a, isBn, isNumber, isString, isU8a, isUndefined, objectProperties, stringify, stringPascalCase, u8aToBn, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareArray } from "../utils/index.js";
 
 function encodeSet(setValues, values) {
@@ -20,7 +20,11 @@ function decodeSetArray(setValues, values) {
 
   for (let i = 0; i < values.length; i++) {
     const key = values[i];
-    assert(!isUndefined(setValues[key]), () => `Set: Invalid key '${key}' passed to Set, allowed ${Object.keys(setValues).join(', ')}`);
+
+    if (isUndefined(setValues[key])) {
+      throw new Error(`Set: Invalid key '${key}' passed to Set, allowed ${Object.keys(setValues).join(', ')}`);
+    }
+
     result[i] = key;
   }
 
@@ -43,14 +47,21 @@ function decodeSetNumber(setValues, _value) {
   }
 
   const computed = encodeSet(setValues, result);
-  assert(bn.eq(computed), () => `Set: Mismatch decoding '${bn.toString()}', computed as '${computed.toString()}' with ${result.join(', ')}`);
+
+  if (!bn.eq(computed)) {
+    throw new Error(`Set: Mismatch decoding '${bn.toString()}', computed as '${computed.toString()}' with ${result.join(', ')}`);
+  }
+
   return result;
 }
 /** @internal */
 
 
 function decodeSet(setValues, value = 0, bitLength) {
-  assert(bitLength % 8 === 0, () => `Expected valid bitLength, power of 8, found ${bitLength}`);
+  if (bitLength % 8 !== 0) {
+    throw new Error(`Expected valid bitLength, power of 8, found ${bitLength}`);
+  }
+
   const byteLength = bitLength / 8;
 
   if (isU8a(value)) {
@@ -150,7 +161,10 @@ export class CodecSet extends Set {
     // ^^^ add = () property done to assign this instance's this, otherwise Set.add creates "some" chaos
     // we have the isUndefined(this._setValues) in here as well, add is used internally
     // in the Set constructor (so it is undefined at this point, and should allow)
-    assert(isUndefined(this.#allowed) || !isUndefined(this.#allowed[key]), () => `Set: Invalid key '${key}' on add`);
+    if (this.#allowed && isUndefined(this.#allowed[key])) {
+      throw new Error(`Set: Invalid key '${key}' on add`);
+    }
+
     super.add(key);
     return this;
   };

package/native/Struct.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isBoolean, isFunction, isHex, isObject, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { compareMap, decodeU8aStruct, mapToTypeMap, typesToMap } from "../utils/index.js";
 
 function noopSetDefinition(d) {
@@ -13,8 +13,13 @@ function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
   let jsonObj;
   const typeofArray = Array.isArray(value);
   const typeofMap = value instanceof Map;
-  assert(typeofArray || typeofMap || isObject(value), () => `Struct: Cannot decode value ${stringify(value)} (typeof ${typeof value}), expected an input object, map or array`);
-  assert(!typeofArray || value.length === keys.length, () => `Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
+
+  if (!typeofArray && !typeofMap && !isObject(value)) {
+    throw new Error(`Struct: Cannot decode value ${stringify(value)} (typeof ${typeof value}), expected an input object, map or array`);
+  } else if (typeofArray && value.length !== keys.length) {
+    throw new Error(`Struct: Unable to map ${stringify(value)} array to object with known keys ${keys.join(', ')}`);
+  }
+
   const raw = new Array(keys.length);
 
   for (let i = 0; i < keys.length; i++) {

package/native/Text.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
+import { compactAddLength, compactFromU8aLim, compactToU8a, hexToU8a, isHex, isString, isU8a, stringToU8a, u8aToHex, u8aToString } from '@polkadot/util';
 import { Raw } from "./Raw.js";
 const MAX_LENGTH = 128 * 1024;
 /** @internal */
@@ -19,8 +19,13 @@ function decodeText(value) {
 
     const [offset, length] = compactFromU8aLim(value);
     const total = offset + length;
-    assert(length <= MAX_LENGTH, () => `Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
-    assert(total <= value.length, () => `Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
+
+    if (length > MAX_LENGTH) {
+      throw new Error(`Text: length ${length.toString()} exceeds ${MAX_LENGTH}`);
+    } else if (total > value.length) {
+      throw new Error(`Text: required length less than remainder, expected at least ${total}, found ${value.length}`);
+    }
+
     return [u8aToString(value.subarray(offset, total)), total];
   } else if (isHex(value)) {
     return [u8aToString(hexToU8a(value)), 0];

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",

package/packageInfo.js

@@ -5,5 +5,5 @@ export const packageInfo = {
   name: '@polkadot/types-codec',
   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'
 };