@polkadot/types-codec 8.5.2-4 → 8.5.2-7

package/cjs/base/Compact.js

@@ -11,7 +11,9 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /**
  * @name Compact
  * @description
@@ -20,23 +22,36 @@ var _utils = require("../utils");
  * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
  * a number and making the compact representation thereof
  */
+
+
 class Compact {
   #Type;
   #raw;
 
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
     this.registry = registry;
-    this.#Type = (0, _utils.typeToConstructor)(registry, Type);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
     const [raw, decodedLength] = Compact.decodeCompact(registry, this.#Type, value);
     this.initialU8aLength = decodedLength;
     this.#raw = raw;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Compact {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Enum.js

@@ -13,6 +13,10 @@ var _Null = require("./Null");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+function noopSetDefinition(d) {
+  return d;
+}
+
 function isRustEnum(def) {
   const defValues = Object.values(def);
 
@@ -40,12 +44,11 @@ function extractDef(registry, _def) {
     isBasic = true;
     isIndexed = false;
   } else if (isRustEnum(_def)) {
-    const entries = Object.entries((0, _utils.mapToTypeMap)(registry, _def));
+    const [Types, keys] = (0, _utils.mapToTypeMap)(registry, _def);
 
-    for (let i = 0; i < entries.length; i++) {
-      const [key, Type] = entries[i];
-      def[key] = {
-        Type,
+    for (let i = 0; i < keys.length; i++) {
+      def[keys[i]] = {
+        Type: Types[i],
         index: i
       };
     }
@@ -147,11 +150,15 @@ class Enum {
   #raw;
 
   constructor(registry, Types, value, index) {
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     const {
       def,
       isBasic,
       isIndexed
-    } = extractDef(registry, Types); // shortcut isU8a as used in SCALE decoding
+    } = definition || setDefinition(extractDef(registry, Types)); // shortcut isU8a as used in SCALE decoding
 
     const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isNumber)(index) ? createFromValue(registry, def, value[0], value.subarray(1)) : decodeEnum(registry, def, value, index);
     this.registry = registry;
@@ -183,9 +190,16 @@ class Enum {
       isKeys[i] = `is${name}`;
     }
 
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Enum {
       constructor(registry, value, index) {
-        super(registry, Types, value, index);
+        super(registry, Types, value, index, {
+          definition,
+          setDefinition
+        });
         (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}`);
@@ -386,14 +400,15 @@ class Enum {
       }, {}) : this.defKeys;
     }
 
-    const typeMap = Object.entries(this.#def).reduce((out, _ref3) => {
+    const entries = Object.entries(this.#def);
+    return (0, _utils.typesToMap)(this.registry, entries.reduce((out, _ref3, i) => {
       let [key, {
         Type
       }] = _ref3;
-      out[key] = Type;
+      out[0][i] = Type;
+      out[1][i] = key;
       return out;
-    }, {});
-    return (0, _utils.typesToMap)(this.registry, typeMap);
+    }, [new Array(entries.length), new Array(entries.length)]));
   }
   /**
    * @description Returns the base runtime type name for this instance

package/cjs/base/Option.js

@@ -13,6 +13,10 @@ var _Null = require("./Null");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+function noopSetDefinition(d) {
+  return d;
+}
+
 class None extends _Null.Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -60,7 +64,11 @@ class Option {
   #raw;
 
   constructor(registry, typeName, value) {
-    const Type = (0, _utils.typeToConstructor)(registry, typeName);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, typeName));
     const decoded = (0, _util.isU8a)(value) && value.length && !(0, _util.isCodec)(value) ? value[0] === 0 ? new None(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
     this.registry = registry;
     this.#Type = Type;
@@ -72,9 +80,19 @@ class Option {
   }
 
   static with(Type) {
+    let definition;
+
+    const setDefinition = d => {
+      definition = d;
+      return d;
+    };
+
     return class extends Option {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/Tuple.js

@@ -13,27 +13,29 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
-function decodeTuple(registry, Classes, value) {
+
+
+function decodeTuple(registry, result, Classes, value) {
   if ((0, _util.isU8a)(value) || (0, _util.isHex)(value)) {
-    return (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), Classes);
+    return (0, _utils.decodeU8a)(registry, result, (0, _util.u8aToU8a)(value), Classes);
   }
 
-  const Types = Array.isArray(Classes) ? Classes : Object.values(Classes);
-  return [Types.map((Type, index) => {
-    try {
-      const entry = value === null || value === void 0 ? void 0 : value[index];
-
-      if (entry instanceof Type) {
-        return entry;
-      }
+  const Types = Classes[0];
 
-      return new Type(registry, entry);
+  for (let i = 0; i < Types.length; i++) {
+    try {
+      const entry = value === null || value === void 0 ? void 0 : value[i];
+      result[i] = entry instanceof Types[i] ? entry : new Types[i](registry, entry);
     } catch (error) {
-      throw new Error(`Tuple: failed on ${index}:: ${error.message}`);
+      throw new Error(`Tuple: failed on ${i}:: ${error.message}`);
     }
-  }), 0];
+  }
+
+  return [result, 0];
 }
 /**
  * @name Tuple
@@ -47,16 +49,28 @@ class Tuple extends _AbstractArray.AbstractArray {
   #Types;
 
   constructor(registry, Types, value) {
-    const Classes = Array.isArray(Types) ? Types.map(t => (0, _utils.typeToConstructor)(registry, t)) : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [(0, _utils.typeToConstructor)(registry, Types)] : (0, _utils.mapToTypeMap)(registry, Types);
-    const [values, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, Classes) : decodeTuple(registry, Classes, value);
-    super(registry, values, decodedLength);
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => (0, _utils.typeToConstructor)(registry, t)), []] : (0, _util.isFunction)(Types) || (0, _util.isString)(Types) ? [[(0, _utils.typeToConstructor)(registry, Types)], []] : (0, _utils.mapToTypeMap)(registry, Types));
+    super(registry, Classes[0].length);
+    const [, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, this, value, Classes, false) : decodeTuple(registry, this, Classes, value);
+    this.initialU8aLength = decodedLength;
     this.#Types = Classes;
   }
 
   static with(Types) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Tuple {
       constructor(registry, value) {
-        super(registry, Types, value);
+        super(registry, Types, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };
@@ -81,7 +95,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   get Types() {
-    return Array.isArray(this.#Types) ? this.#Types.map(T => new T(this.registry).toRawType()) : Object.keys(this.#Types);
+    return this.#Types[1].length ? this.#Types[1] : this.#Types[0].map(T => new T(this.registry).toRawType());
   }
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
@@ -99,7 +113,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   toRawType() {
-    const types = (Array.isArray(this.#Types) ? this.#Types : Object.values(this.#Types)).map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
+    const types = this.#Types[0].map(T => this.registry.getClassName(T) || new T(this.registry).toRawType());
     return `(${types.join(',')})`;
   }
   /**

package/cjs/base/Vec.js

@@ -17,13 +17,26 @@ var _utils = require("../utils");
 const MAX_LENGTH = 64 * 1024;
 const l = (0, _util.logger)('Vec');
 
-function decodeVec(registry, Type, value) {
-  let length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+function noopSetDefinition(d) {
+  return d;
+}
+
+function decodeVecLength(value) {
+  if (Array.isArray(value)) {
+    return [value, value.length, 0];
+  }
+
+  const u8a = (0, _util.u8aToU8a)(value);
+  const [startAt, length] = (0, _util.compactFromU8a)(u8a);
+  (0, _util.assert)(length.lten(MAX_LENGTH), () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  return [u8a, length.toNumber(), startAt];
+}
 
+function decodeVec(registry, result, value, startAt, Type) {
   if (Array.isArray(value)) {
-    const result = new Array(value.length);
+    const count = result.length;
 
-    for (let i = 0; i < value.length; i++) {
+    for (let i = 0; i < count; i++) {
       const entry = value[i];
 
       try {
@@ -34,20 +47,10 @@ function decodeVec(registry, Type, value) {
       }
     }
 
-    return [result, 0, 0];
+    return [0, 0];
   }
 
-  const u8a = (0, _util.u8aToU8a)(value);
-  let offset = 0;
-
-  if (length === -1) {
-    const [_offset, _length] = (0, _util.compactFromU8a)(u8a);
-    (0, _util.assert)(_length.lten(MAX_LENGTH), () => `Vec length ${_length.toString()} exceeds ${MAX_LENGTH}`);
-    length = _length.toNumber();
-    offset = _offset;
-  }
-
-  return (0, _utils.decodeU8aVec)(registry, u8a, offset, Type, length);
+  return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -63,16 +66,28 @@ class Vec extends _AbstractArray.AbstractArray {
 
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    const Clazz = (0, _utils.typeToConstructor)(registry, Type);
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const [decodeFrom, length, startAt] = decodeVecLength(value);
+    super(registry, length);
+    this.#Type = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
+    const [decodedLength] = (0, _util.isU8a)(decodeFrom) ? (0, _utils.decodeU8aVec)(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type);
+    this.initialU8aLength = decodedLength;
   }
 
   static with(Type) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Vec {
       constructor(registry, value) {
-        super(registry, Type, value);
+        super(registry, Type, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/base/VecFixed.js

@@ -15,17 +15,8 @@ var _Vec = require("./Vec");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
-/** @internal */
-function decodeVecFixed(registry, value, Type, length) {
-  const [values, decodedLength, decodedLengthNoOffset] = (0, _Vec.decodeVec)(registry, Type, value, length);
-
-  while (values.length < length) {
-    values.push(new Type(registry));
-  }
-
-  (0, _util.assert)(values.length === length, () => `Expected a length of exactly ${length} entries`);
-  return [values, decodedLength, decodedLengthNoOffset];
+function noopSetDefinition(d) {
+  return d;
 }
 /**
  * @name VecFixed
@@ -39,16 +30,27 @@ class VecFixed extends _AbstractArray.AbstractArray {
 
   constructor(registry, Type, length) {
     let value = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
-    const Clazz = (0, _utils.typeToConstructor)(registry, Type);
-    const [values,, decodedLengthNoOffset] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8aVec)(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
-    super(registry, values, decodedLengthNoOffset);
-    this.#Type = Clazz;
+    let {
+      definition,
+      setDefinition = noopSetDefinition
+    } = 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;
   }
 
   static with(Type, length) {
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends VecFixed {
       constructor(registry, value) {
-        super(registry, Type, length, value);
+        super(registry, Type, length, value, {
+          definition,
+          setDefinition
+        });
       }
 
     };

package/cjs/extended/BTreeSet.js

@@ -17,10 +17,12 @@ const l = (0, _util.logger)('BTreeSet');
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
   const [offset, length] = (0, _util.compactFromU8a)(u8a);
-  const [values, decodedLength] = (0, _utils.decodeU8aVec)(registry, u8a, offset, ValClass, length.toNumber());
+  const count = length.toNumber();
+  const result = new Array(count);
+  const [decodedLength] = (0, _utils.decodeU8aVec)(registry, result, u8a, offset, ValClass);
 
-  for (let i = 0; i < values.length; i++) {
-    output.add(values[i]);
+  for (let i = 0; i < count; i++) {
+    output.add(result[i]);
   }
 
   return [ValClass, output, decodedLength];

package/cjs/extended/Map.js

@@ -30,7 +30,7 @@ function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
     types.push(KeyClass, ValClass);
   }
 
-  const [values, decodedLength] = (0, _utils.decodeU8a)(registry, u8a.subarray(offset), types);
+  const [values, decodedLength] = (0, _utils.decodeU8a)(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
 
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);

package/cjs/native/Struct.js

@@ -11,21 +11,25 @@ var _utils = require("../utils");
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-
+function noopSetDefinition(d) {
+  return d;
+}
 /** @internal */
-function decodeStructFromObject(registry, Types, value, jsonMap) {
+
+
+function decodeStructFromObject(registry, _ref, value, jsonMap) {
+  let [Types, keys] = _ref;
   let jsonObj;
-  const inputKeys = Object.keys(Types);
   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 === inputKeys.length, () => `Struct: Unable to map ${(0, _util.stringify)(value)} array to object with known keys ${inputKeys.join(', ')}`);
-  const raw = new Array(inputKeys.length);
+  (0, _util.assert)(!typeofArray || value.length === keys.length, () => `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 < inputKeys.length; i++) {
-    const key = inputKeys[i];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
     const jsonKey = jsonMap.get(key) || key;
-    const Type = Types[key];
+    const Type = Types[i];
     let assign;
 
     try {
@@ -84,8 +88,12 @@ class Struct extends Map {
 
   constructor(registry, Types, value) {
     let jsonMap = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Map();
-    const typeMap = (0, _utils.mapToTypeMap)(registry, Types);
-    const [decoded, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, typeMap, true) : (0, _util.isHex)(value) ? (0, _utils.decodeU8a)(registry, (0, _util.u8aToU8a)(value), typeMap, true) : value instanceof Struct ? [value, 0] : decodeStructFromObject(registry, typeMap, value || {}, jsonMap);
+    let {
+      definition,
+      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);
     super(decoded);
     this.#registry = registry;
     this.initialU8aLength = decodedLength;
@@ -95,9 +103,16 @@ class Struct extends Map {
 
   static with(Types, jsonMap) {
     const keys = Object.keys(Types);
+    let definition; // eslint-disable-next-line no-return-assign
+
+    const setDefinition = d => definition = d;
+
     return class extends Struct {
       constructor(registry, value) {
-        super(registry, Types, value, jsonMap);
+        super(registry, Types, value, jsonMap, {
+          definition,
+          setDefinition
+        });
         (0, _util.objectProperties)(this, keys, k => this.get(k));
       }
 
@@ -109,7 +124,7 @@ class Struct extends Map {
 
 
   get defKeys() {
-    return Object.keys(this.#Types);
+    return this.#Types[1];
   }
 
   getT(key) {
@@ -136,11 +151,10 @@ class Struct extends Map {
 
   get Type() {
     const result = {};
-    const defs = Object.entries(this.#Types);
+    const [Types, keys] = this.#Types;
 
-    for (let i = 0; i < defs.length; i++) {
-      const [key, Type] = defs[i];
-      result[key] = new Type(this.registry).toRawType();
+    for (let i = 0; i < keys.length; i++) {
+      result[keys[i]] = new Types[i](this.registry).toRawType();
     }
 
     return result;

package/cjs/packageInfo.js

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

package/cjs/utils/decodeU8a.js

@@ -31,12 +31,12 @@ function getRawType(registry, Type) {
  */
 
 
-function decodeU8a(registry, u8a, types, withZip) {
-  const [Types, keys] = Array.isArray(types) ? [types, []] : [Object.values(types), Object.keys(types)];
-  const result = new Array(Types.length);
+function decodeU8a(registry, result, u8a, _ref, withZip) {
+  let [Types, keys] = _ref;
+  const count = result.length;
   let offset = 0;
 
-  for (let i = 0; i < Types.length; i++) {
+  for (let i = 0; i < count; i++) {
     try {
       const value = new Types[i](registry, u8a.subarray(offset));
       offset += value.initialU8aLength || value.encodedLength;
@@ -51,9 +51,9 @@ function decodeU8a(registry, u8a, types, withZip) {
 // since we have to do less checks (and these are intensive anyway), much faster
 
 
-function decodeU8aVec(registry, u8a, start, Type, count) {
-  const result = new Array(count);
-  let offset = start;
+function decodeU8aVec(registry, result, u8a, startAt, Type) {
+  const count = result.length;
+  let offset = startAt;
 
   for (let i = 0; i < count; i++) {
     try {
@@ -65,5 +65,5 @@ function decodeU8aVec(registry, u8a, start, Type, count) {
     }
   }
 
-  return [result, offset, offset - start];
+  return [offset, offset - startAt];
 }

package/cjs/utils/mapToTypeMap.js

@@ -15,10 +15,12 @@ var _typeToConstructor = require("./typeToConstructor");
  */
 function mapToTypeMap(registry, input) {
   const entries = Object.entries(input);
-  const output = {};
+  const count = entries.length;
+  const output = [new Array(count), new Array(count)];
 
   for (let i = 0; i < entries.length; i++) {
-    output[entries[i][0]] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
+    output[1][i] = entries[i][0];
+    output[0][i] = (0, _typeToConstructor.typeToConstructor)(registry, entries[i][1]);
   }
 
   return output;

package/cjs/utils/typesToMap.js

@@ -7,13 +7,12 @@ exports.typesToMap = typesToMap;
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-function typesToMap(registry, Types) {
-  const entries = Object.entries(Types);
+function typesToMap(registry, _ref) {
+  let [Types, keys] = _ref;
   const result = {};
 
-  for (let i = 0; i < entries.length; i++) {
-    const [key, Type] = entries[i];
-    result[key] = registry.getClassName(Type) || new Type(registry).toRawType();
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
   }
 
   return result;

package/extended/BTreeSet.js

@@ -8,10 +8,12 @@ const l = logger('BTreeSet');
 function decodeSetFromU8a(registry, ValClass, u8a) {
   const output = new Set();
   const [offset, length] = compactFromU8a(u8a);
-  const [values, decodedLength] = decodeU8aVec(registry, u8a, offset, ValClass, length.toNumber());
+  const count = length.toNumber();
+  const result = new Array(count);
+  const [decodedLength] = decodeU8aVec(registry, result, u8a, offset, ValClass);
 
-  for (let i = 0; i < values.length; i++) {
-    output.add(values[i]);
+  for (let i = 0; i < count; i++) {
+    output.add(result[i]);
   }
 
   return [ValClass, output, decodedLength];

package/extended/Map.js

@@ -18,7 +18,7 @@ function decodeMapFromU8a(registry, KeyClass, ValClass, u8a) {
     types.push(KeyClass, ValClass);
   }
 
-  const [values, decodedLength] = decodeU8a(registry, u8a.subarray(offset), types);
+  const [values, decodedLength] = decodeU8a(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
 
   for (let i = 0; i < values.length; i += 2) {
     output.set(values[i], values[i + 1]);

package/native/Struct.d.ts

@@ -1,6 +1,11 @@
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, BareOpts, Codec, CodecClass, Inspect, IStruct, IU8a, Registry } from '../types';
 declare type TypesDef<T = Codec> = Record<string, string | CodecClass<T>>;
+declare type Definition = [CodecClass[], string[]];
+interface Options {
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
+}
 /**
  * @name Struct
  * @description
@@ -23,7 +28,7 @@ export declare class Struct<S extends TypesDef = TypesDef, V extends {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Types: S, value?: V | Map<unknown, unknown> | unknown[] | HexString | null, jsonMap?: Map<string, string>);
+    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>>;
     /**
      * @description The available keys for this struct