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

package/cjs/base/VecFixed.js

@@ -36,8 +36,7 @@ class VecFixed extends _AbstractArray.AbstractArray {
     } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     super(registry, length);
     this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
-    const [, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, this, value, 0, this.#Type) : (0, _Vec.decodeVec)(registry, this, value, 0, this.#Type);
-    this.initialU8aLength = decodedLengthNoOffset;
+    this.initialU8aLength = ((0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, this, value, 0, this.#Type) : (0, _Vec.decodeVec)(registry, this, value, 0, this.#Type))[1];
   }
 
   static with(Type, length) {

package/cjs/extended/Bytes.js

@@ -38,7 +38,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/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/native/Struct.js

@@ -82,7 +82,6 @@ function decodeStructFromObject(registry, _ref, value, jsonMap) {
 
 
 class Struct extends Map {
-  #registry;
   #jsonMap;
   #Types;
 
@@ -93,10 +92,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 +180,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

@@ -48,14 +48,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 +64,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-4'
 };
 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/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 { assert, 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;
@@ -29,7 +29,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/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/native/Raw.d.ts

@@ -10,9 +10,9 @@ import type { AnyJson, AnyU8a, Inspect, IU8a, Registry } from '../types';
  * @noInheritDoc
  */
 export declare class Raw extends Uint8Array implements IU8a {
-    readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
+    readonly registry: Registry;
     constructor(registry: Registry, value?: AnyU8a, initialU8aLength?: number);
     /**
      * @description The length of the value when encoded as a Uint8Array

package/native/Struct.d.ts

@@ -28,6 +28,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
+    readonly registry: Registry;
     constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>, { definition, setDefinition }?: Options);
     static with<S extends TypesDef>(Types: S, jsonMap?: Map<string, string>): CodecClass<Struct<S>>;
     /**
@@ -51,7 +52,6 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
      * @description returns a hash of the contents
      */
     get hash(): IU8a;
-    get registry(): Registry;
     /**
      * @description Compares the value of the input to see if there is a match
      */

package/native/Struct.js

@@ -1,7 +1,7 @@
 // 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 { compareMap, decodeU8a, mapToTypeMap, typesToMap } from "../utils/index.js";
+import { compareMap, decodeU8aStruct, mapToTypeMap, typesToMap } from "../utils/index.js";
 
 function noopSetDefinition(d) {
   return d;
@@ -73,7 +73,6 @@ function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
 
 
 export class Struct extends Map {
-  #registry;
   #jsonMap;
   #Types;
 
@@ -82,10 +81,10 @@ export class Struct extends Map {
     setDefinition = noopSetDefinition
   } = {}) {
     const typeMap = definition || setDefinition(mapToTypeMap(registry, Types));
-    const [decoded, decodedLength] = isU8a(value) || isHex(value) ? decodeU8a(registry, new Array(typeMap[0].length), u8aToU8a(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+    const [decoded, decodedLength] = isU8a(value) || isHex(value) ? decodeU8aStruct(registry, new Array(typeMap[0].length), 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;
   }
@@ -170,10 +169,6 @@ export 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/native/Text.d.ts

@@ -10,8 +10,9 @@ import type { AnyString, AnyU8a, Inspect, IText, IU8a, Registry } from '../types
  */
 export declare class Text extends String implements IText {
     #private;
-    readonly registry: Registry;
     createdAtHash?: IU8a;
+    readonly initialU8aLength?: number;
+    readonly registry: Registry;
     constructor(registry: Registry, value?: null | AnyString | AnyU8a | {
         toString: () => string;
     });
@@ -19,10 +20,6 @@ export declare class Text extends String implements IText {
      * @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 | undefined;
     /**
      * @description returns a hash of the contents
      */

package/native/Text.js

@@ -39,14 +39,13 @@ function decodeText(value) {
 
 
 export 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
@@ -56,14 +55,6 @@ export 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/package.json

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

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-1'
+  version: '8.8.3-4'
 };

package/utils/decodeU8a.d.ts

@@ -1,5 +1,7 @@
 import type { Codec, CodecClass, Registry } from '../types';
 /**
+ * @internal
+ *
  * Given an u8a, and an array of Type constructors, decode the u8a against the
  * types, and return an array of decoded values.
  *
@@ -7,5 +9,18 @@ import type { Codec, CodecClass, Registry } from '../types';
  * @param result - The result array (will be returned with values pushed)
  * @param types - The array of CodecClass to decode the U8a against.
  */
-export declare function decodeU8a<T extends Codec = Codec, E = T>(registry: Registry, result: unknown[], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]], withZip?: boolean): [E[], number];
+export declare function decodeU8a<T extends Codec = Codec>(registry: Registry, result: T[], u8a: Uint8Array, [Types, keys]: [CodecClass<T>[], string[]]): [T[], number];
+/**
+ * @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
+ */
+export declare function decodeU8aStruct(registry: Registry, result: [string, Codec][], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]]): [[string, Codec][], number];
+/**
+ * @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
+ */
 export declare function decodeU8aVec<T extends Codec = Codec>(registry: Registry, result: unknown[], u8a: Uint8Array, startAt: number, Type: CodecClass<T>): [number, number];

package/utils/decodeU8a.js

@@ -1,19 +1,23 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { u8aToHex } from '@polkadot/util';
+/** @internal */
 
-function formatFailure(error, type, u8a, key) {
-  return `decodeU8a: failed at ${u8aToHex(u8a)}…${key ? ` on ${key}` : ''}${type ? `: ${type}` : ''}:: ${error.message}`;
-}
+function formatFailure(registry, {
+  message
+}, u8a, i, count, Type, key) {
+  let type = '';
 
-function getRawType(registry, Type) {
   try {
-    return new Type(registry).toRawType();
-  } catch {
-    return null;
+    type = `: ${new Type(registry).toRawType()}`;
+  } catch {// ignore
   }
+
+  return `decodeU8a: failed at ${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.
  *
@@ -23,36 +27,70 @@ function getRawType(registry, Type) {
  */
 
 
-export function decodeU8a(registry, result, u8a, [Types, keys], withZip) {
+export function decodeU8a(registry, result, u8a, [Types, keys]) {
   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
+ */
+
+export function decodeU8aStruct(registry, result, u8a, [Types, keys]) {
+  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
+ */
 
 export 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/utils/index.d.ts

@@ -1,7 +1,7 @@
 export { compareArray } from './compareArray';
 export { compareMap } from './compareMap';
 export { compareSet } from './compareSet';
-export { decodeU8a, decodeU8aVec } from './decodeU8a';
+export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a';
 export { mapToTypeMap } from './mapToTypeMap';
 export { typeToConstructor } from './typeToConstructor';
 export { sanitize } from './sanitize';

package/utils/index.js

@@ -3,7 +3,7 @@
 export { compareArray } from "./compareArray.js";
 export { compareMap } from "./compareMap.js";
 export { compareSet } from "./compareSet.js";
-export { decodeU8a, decodeU8aVec } from "./decodeU8a.js";
+export { decodeU8a, decodeU8aStruct, decodeU8aVec } from "./decodeU8a.js";
 export { mapToTypeMap } from "./mapToTypeMap.js";
 export { typeToConstructor } from "./typeToConstructor.js";
 export { sanitize } from "./sanitize.js";

package/utils/mapToTypeMap.js

@@ -10,7 +10,7 @@ export 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] = typeToConstructor(registry, entries[i][1]);
   }