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

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];
 }
 /**
@@ -38,7 +43,7 @@ function decodeBytesU8a(value) {
 
 class Bytes extends _Raw.Raw {
   constructor(registry, value) {
-    const [u8a, decodedLength] = (0, _util.isU8a)(value) && !((0, _util.isCodec)(value) && value instanceof _Raw.Raw) ? decodeBytesU8a(value) : Array.isArray(value) || (0, _util.isString)(value) ? [(0, _util.u8aToU8a)(value), 0] : [value, 0];
+    const [u8a, decodedLength] = (0, _util.isU8a)(value) && !(value instanceof _Raw.Raw) ? decodeBytesU8a(value) : Array.isArray(value) || (0, _util.isString)(value) ? [(0, _util.u8aToU8a)(value), 0] : [value, 0];
     super(registry, u8a, decodedLength);
   }
   /**

package/cjs/extended/Map.js

@@ -7,7 +7,7 @@ exports.CodecMap = void 0;
 
 var _util = require("@polkadot/util");
 
-var _AbstractArray = require("../abstract/AbstractArray");
+var _Array = require("../abstract/Array");
 
 var _Enum = require("../base/Enum");
 
@@ -44,7 +44,7 @@ function decodeMapFromMap(registry, KeyClass, ValClass, value) {
   const output = new Map();
 
   for (const [key, val] of value.entries()) {
-    const isComplex = KeyClass.prototype instanceof _AbstractArray.AbstractArray || KeyClass.prototype instanceof _Struct.Struct || KeyClass.prototype instanceof _Enum.Enum;
+    const isComplex = KeyClass.prototype instanceof _Array.AbstractArray || KeyClass.prototype instanceof _Struct.Struct || KeyClass.prototype instanceof _Enum.Enum;
 
     try {
       output.set(key instanceof KeyClass ? key : new KeyClass(registry, isComplex ? JSON.parse(key) : key), val instanceof ValClass ? val : new ValClass(registry, val));

package/cjs/extended/OptionBool.js

@@ -29,6 +29,7 @@ function decodeU8a(registry, value) {
 class OptionBool extends _Option.Option {
   constructor(registry, value) {
     super(registry, _Bool.bool, (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? decodeU8a(registry, (0, _util.u8aToU8a)(value)) : value);
+    this.initialU8aLength = 1;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -38,14 +39,6 @@ class OptionBool extends _Option.Option {
   get encodedLength() {
     return 1;
   }
-  /**
-   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
-   */
-
-
-  get initialU8aLength() {
-    return 1;
-  }
   /**
    * @description Checks if the value is an empty value (always false)
    */

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++) {
@@ -82,7 +87,6 @@ function decodeStructFromObject(registry, _ref, value, jsonMap) {
 
 
 class Struct extends Map {
-  #registry;
   #jsonMap;
   #Types;
 
@@ -93,10 +97,10 @@ class Struct extends Map {
       setDefinition = noopSetDefinition
     } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     const typeMap = definition || setDefinition((0, _utils.mapToTypeMap)(registry, Types));
-    const [decoded, decodedLength] = (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, new Array(typeMap[0].length), (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+    const [decoded, decodedLength] = (0, _util.isU8a)(value) || (0, _util.isHex)(value) ? (0, _utils.decodeU8aStruct)(registry, new Array(typeMap[0].length), (0, _util.u8aToU8a)(value), typeMap) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
     super(decoded);
-    this.#registry = registry;
     this.initialU8aLength = decodedLength;
+    this.registry = registry;
     this.#jsonMap = jsonMap;
     this.#Types = typeMap;
   }
@@ -181,10 +185,6 @@ class Struct extends Map {
   get hash() {
     return this.registry.hash(this.toU8a());
   }
-
-  get registry() {
-    return this.#registry;
-  }
   /**
    * @description Compares the value of the input to see if there is a match
    */

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];
@@ -48,14 +53,13 @@ function decodeText(value) {
 
 
 class Text extends String {
-  #initialU8aLength;
   #override = null;
 
   constructor(registry, value) {
     const [str, decodedLength] = decodeText(value);
     super(str);
     this.registry = registry;
-    this.#initialU8aLength = decodedLength;
+    this.initialU8aLength = decodedLength;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -65,14 +69,6 @@ class Text extends String {
   get encodedLength() {
     return this.toU8a().length;
   }
-  /**
-   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
-   */
-
-
-  get initialU8aLength() {
-    return this.#initialU8aLength;
-  }
   /**
    * @description returns a hash of the contents
    */

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-1'
+  version: '8.8.3-12'
 };
 exports.packageInfo = packageInfo;

package/cjs/utils/decodeU8a.js

@@ -4,24 +4,31 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.decodeU8a = decodeU8a;
+exports.decodeU8aStruct = decodeU8aStruct;
 exports.decodeU8aVec = decodeU8aVec;
 
 var _util = require("@polkadot/util");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-function formatFailure(error, type, u8a, key) {
-  return `decodeU8a: failed at ${(0, _util.u8aToHex)(u8a)}…${key ? ` on ${key}` : ''}${type ? `: ${type}` : ''}:: ${error.message}`;
-}
 
-function getRawType(registry, Type) {
+/** @internal */
+function formatFailure(registry, _ref, u8a, i, count, Type, key) {
+  let {
+    message
+  } = _ref;
+  let type = '';
+
   try {
-    return new Type(registry).toRawType();
-  } catch {
-    return null;
+    type = `: ${new Type(registry).toRawType()}`;
+  } catch {// ignore
   }
+
+  return `decodeU8a: failed at ${(0, _util.u8aToHex)(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i}/${count})${type}:: ${message}`;
 }
 /**
+ * @internal
+ *
  * Given an u8a, and an array of Type constructors, decode the u8a against the
  * types, and return an array of decoded values.
  *
@@ -31,38 +38,74 @@ function getRawType(registry, Type) {
  */
 
 
-function decodeU8a(registry, result, u8a, _ref, withZip) {
-  let [Types, keys] = _ref;
+function decodeU8a(registry, result, u8a, _ref2) {
+  let [Types, keys] = _ref2;
   const count = result.length;
   let offset = 0;
+  let i = 0;
 
-  for (let i = 0; i < count; i++) {
-    try {
+  try {
+    while (i < count) {
       const value = new Types[i](registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
-      result[i] = withZip ? [keys[i], value] : value;
-    } catch (error) {
-      throw new Error(formatFailure(error, getRawType(registry, Types[i]), u8a.subarray(offset, offset + 16), keys[i]));
+      result[i] = value;
+      i++;
     }
+  } catch (error) {
+    throw new Error(formatFailure(registry, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
   }
 
   return [result, offset];
-} // Split from decodeU8a since this is specialized to 1 instance ... yes duplication, but
-// since we have to do less checks (and these are intensive anyway), much faster
+}
+/**
+ * @internal
+ *
+ * Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
+ * is all on the hot-path, so it is not great, however there is (some) method behind the madness
+ */
+
+
+function decodeU8aStruct(registry, result, u8a, _ref3) {
+  let [Types, keys] = _ref3;
+  const count = result.length;
+  let offset = 0;
+  let i = 0;
+
+  try {
+    while (i < count) {
+      const value = new Types[i](registry, u8a.subarray(offset));
+      offset += value.initialU8aLength || value.encodedLength;
+      result[i] = [keys[i], value];
+      i++;
+    }
+  } catch (error) {
+    throw new Error(formatFailure(registry, error, u8a.subarray(offset), i, count, Types[i], keys[i]));
+  }
+
+  return [result, offset];
+}
+/**
+ * @internal
+ *
+ * Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
+ * is all on the hot-path, so it is not great, however there is (some) method behind the madness
+ */
 
 
 function decodeU8aVec(registry, result, u8a, startAt, Type) {
   const count = result.length;
   let offset = startAt;
+  let i = 0;
 
-  for (let i = 0; i < count; i++) {
-    try {
+  try {
+    while (i < count) {
       const value = new Type(registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
       result[i] = value;
-    } catch (error) {
-      throw new Error(formatFailure(error, getRawType(registry, Type), u8a.subarray(offset, offset + 16)));
+      i++;
     }
+  } catch (error) {
+    throw new Error(formatFailure(registry, error, u8a.subarray(offset), i, count, Type));
   }
 
   return [offset, offset - startAt];

package/cjs/utils/index.js

@@ -27,6 +27,12 @@ Object.defineProperty(exports, "decodeU8a", {
     return _decodeU8a.decodeU8a;
   }
 });
+Object.defineProperty(exports, "decodeU8aStruct", {
+  enumerable: true,
+  get: function () {
+    return _decodeU8a.decodeU8aStruct;
+  }
+});
 Object.defineProperty(exports, "decodeU8aVec", {
   enumerable: true,
   get: function () {

package/cjs/utils/mapToTypeMap.js

@@ -18,7 +18,7 @@ function mapToTypeMap(registry, input) {
   const count = entries.length;
   const output = [new Array(count), new Array(count)];
 
-  for (let i = 0; i < entries.length; i++) {
+  for (let i = 0; i < count; i++) {
     output[1][i] = entries[i][0];
     output[0][i] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
   }

package/cjs/utils/sanitize.js

@@ -140,10 +140,7 @@ function removeExtensions(type, isSized) {
 }
 
 function removeColons() {
-  return function (value) {
-    let {
-      allowNamespaces
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return value => {
     let index = 0;
 
     while (index !== -1) {
@@ -152,10 +149,6 @@ function removeColons() {
       if (index === 0) {
         value = value.substring(2);
       } else if (index !== -1) {
-        if (allowNamespaces) {
-          return value;
-        }
-
         let start = index;
 
         while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
@@ -177,7 +170,7 @@ function removeGenerics() {
         // check against the allowed wrappers, be it Vec<..>, Option<...> ...
         const box = ALLOWED_BOXES.find(box => {
           const start = index - box.length;
-          return start >= 0 && value.substring(start, start + box.length) === box && ( // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
+          return start >= 0 && value.substring(start, index) === box && ( // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
           start === 0 || BOX_PRECEDING.includes(value[start - 1]));
         }); // we have not found anything, unwrap generic innards
 
@@ -190,17 +183,13 @@ function removeGenerics() {
 
     return value;
   };
-}
-/** @internal */
-
-
-function pairOfReplacer(v) {
-  return `(${v},${v})`;
 } // remove the PairOf wrappers
 
 
 function removePairOf() {
-  return value => replaceTagWith(value, 'PairOf<', pairOfReplacer);
+  const replacer = v => `(${v},${v})`;
+
+  return value => replaceTagWith(value, 'PairOf<', replacer);
 } // remove the type traits
 
 
@@ -226,40 +215,31 @@ function removeTraits() {
     .replace(from5, 'Lookup') // replace `<...>::Type`
     .replace(from6, '');
   };
-}
-/** @internal */
-
-
-function wrapReplacer(v) {
-  return v;
 } // remove wrapping values, i.e. Box<Proposal> -> Proposal
 
 
 function removeWrap(check) {
-  return value => replaceTagWith(value, check, wrapReplacer);
+  const replacer = v => v;
+
+  return value => replaceTagWith(value, check, replacer);
 }
 
-const sanitizeMap = new Map(); // eslint-disable-next-line @typescript-eslint/ban-types
+const sanitizeMap = new Map();
 
-function sanitize(value, options) {
+function sanitize(value) {
   const startValue = value.toString();
-  let result = startValue;
+  const memoized = sanitizeMap.get(startValue);
 
-  if (!options) {
-    const memoized = sanitizeMap.get(startValue);
-
-    if (memoized) {
-      return memoized;
-    }
+  if (memoized) {
+    return memoized;
   }
 
-  for (let i = 0; i < mappings.length; i++) {
-    result = mappings[i](result, options);
-  }
+  let result = startValue;
 
-  if (!options) {
-    sanitizeMap.set(startValue, result);
+  for (let i = 0; i < mappings.length; i++) {
+    result = mappings[i](result);
   }
 
+  sanitizeMap.set(startValue, result);
   return result;
 }

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, isCodec, 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];
 }
 /**
@@ -29,7 +34,7 @@ function decodeBytesU8a(value) {
 
 export class Bytes extends Raw {
   constructor(registry, value) {
-    const [u8a, decodedLength] = isU8a(value) && !(isCodec(value) && value instanceof Raw) ? decodeBytesU8a(value) : Array.isArray(value) || isString(value) ? [u8aToU8a(value), 0] : [value, 0];
+    const [u8a, decodedLength] = isU8a(value) && !(value instanceof Raw) ? decodeBytesU8a(value) : Array.isArray(value) || isString(value) ? [u8aToU8a(value), 0] : [value, 0];
     super(registry, u8a, decodedLength);
   }
   /**

package/extended/Map.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { compactFromU8aLim, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { AbstractArray } from "../abstract/AbstractArray.js";
+import { AbstractArray } from "../abstract/Array.js";
 import { Enum } from "../base/Enum.js";
 import { Struct } from "../native/Struct.js";
 import { compareMap, decodeU8a, sortMap, typeToConstructor } from "../utils/index.js";

package/extended/OptionBool.d.ts

@@ -12,10 +12,6 @@ export declare class OptionBool extends Option<Bool> {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength(): number;
-    /**
-     * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
-     */
-    get initialU8aLength(): number;
     /**
      * @description Checks if the value is an empty value (always false)
      */

package/extended/OptionBool.js

@@ -20,6 +20,7 @@ function decodeU8a(registry, value) {
 export class OptionBool extends Option {
   constructor(registry, value) {
     super(registry, Bool, isU8a(value) || isHex(value) ? decodeU8a(registry, u8aToU8a(value)) : value);
+    this.initialU8aLength = 1;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -29,14 +30,6 @@ export class OptionBool extends Option {
   get encodedLength() {
     return 1;
   }
-  /**
-   * @description The length of the initial encoded value (Only available when constructed from a Uint8Array)
-   */
-
-
-  get initialU8aLength() {
-    return 1;
-  }
   /**
    * @description Checks if the value is an empty value (always false)
    */

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;
   }
 
 }