@polkadot/types-codec 8.5.2-6 → 8.5.2-9

package/abstract/AbstractArray.d.ts

@@ -10,8 +10,7 @@ import type { AnyJson, Codec, Inspect, IU8a, IVec, Registry } from '../types';
 export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    readonly initialU8aLength?: number;
-    protected constructor(registry: Registry, values: T[], initialU8aLength?: number);
+    protected constructor(registry: Registry, length: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/abstract/AbstractArray.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { compactToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
+import { compactToU8a, u8aConcatStrict, u8aToHex } from '@polkadot/util';
 import { compareArray } from "../utils/compareArray.js";
 /**
  * @name AbstractArray
@@ -11,15 +11,9 @@ import { compareArray } from "../utils/compareArray.js";
  */
 
 export class AbstractArray extends Array {
-  constructor(registry, values, initialU8aLength) {
-    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
-
-    for (let i = 0; i < values.length; i++) {
-      this[i] = values[i];
-    }
-
+  constructor(registry, length) {
+    super(length);
     this.registry = registry;
-    this.initialU8aLength = initialU8aLength;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -160,7 +154,7 @@ export class AbstractArray extends Array {
 
   toU8a(isBare) {
     const encoded = this.toU8aInner();
-    return isBare ? u8aConcat(...encoded) : u8aConcat(compactToU8a(this.length), ...encoded);
+    return isBare ? u8aConcatStrict(encoded) : u8aConcatStrict([compactToU8a(this.length), ...encoded]);
   }
 
   toU8aInner(isBare) {

package/base/Enum.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isCodec, isHex, isNumber, isObject, isString, isU8a, isUndefined, objectProperties, stringCamelCase, stringify, stringPascalCase, u8aConcat, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { assert, isCodec, 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
 
@@ -35,12 +35,11 @@ function extractDef(registry, _def) {
     isBasic = true;
     isIndexed = false;
   } else if (isRustEnum(_def)) {
-    const entries = Object.entries(mapToTypeMap(registry, _def));
+    const [Types, keys] = 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
       };
     }
@@ -383,13 +382,14 @@ export class Enum {
       }, {}) : this.defKeys;
     }
 
-    const typeMap = Object.entries(this.#def).reduce((out, [key, {
+    const entries = Object.entries(this.#def);
+    return typesToMap(this.registry, entries.reduce((out, [key, {
       Type
-    }]) => {
-      out[key] = Type;
+    }], i) => {
+      out[0][i] = Type;
+      out[1][i] = key;
       return out;
-    }, {});
-    return typesToMap(this.registry, typeMap);
+    }, [new Array(entries.length), new Array(entries.length)]));
   }
   /**
    * @description Returns the base runtime type name for this instance
@@ -416,7 +416,7 @@ export class Enum {
 
 
   toU8a(isBare) {
-    return u8aConcat(new Uint8Array(isBare ? [] : [this.index]), this.#raw.toU8a(isBare));
+    return isBare ? this.#raw.toU8a(isBare) : u8aConcatStrict([new Uint8Array([this.index]), this.#raw.toU8a(isBare)]);
   }
 
 }

package/base/Tuple.d.ts

@@ -1,15 +1,13 @@
 import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
-declare type TupleCodecClass = CodecClass[] | {
-    [index: string]: CodecClass;
-};
 declare type TupleType = (CodecClass | string);
 declare type TupleTypes = TupleType[] | {
     [index: string]: CodecClass | string;
 };
+declare type Definition = [CodecClass[], string[]];
 interface Options {
-    definition?: TupleCodecClass;
-    setDefinition?: (d: TupleCodecClass) => TupleCodecClass;
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
 }
 /**
  * @name Tuple
@@ -19,6 +17,7 @@ interface Options {
  */
 export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
     #private;
+    readonly initialU8aLength?: number;
     constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: Options);
     static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
     /**

package/base/Tuple.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { isFunction, isHex, isString, isU8a, stringify, u8aConcat, u8aToU8a } from '@polkadot/util';
+import { isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
 
@@ -10,25 +10,23 @@ function noopSetDefinition(d) {
 /** @internal */
 
 
-function decodeTuple(registry, Classes, value) {
+function decodeTuple(registry, result, Classes, value) {
   if (isU8a(value) || isHex(value)) {
-    return decodeU8a(registry, u8aToU8a(value), Classes);
+    return decodeU8a(registry, result, 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
@@ -45,9 +43,10 @@ export class Tuple extends AbstractArray {
     definition,
     setDefinition = noopSetDefinition
   } = {}) {
-    const Classes = definition || setDefinition(Array.isArray(Types) ? Types.map(t => typeToConstructor(registry, t)) : isFunction(Types) || isString(Types) ? [typeToConstructor(registry, Types)] : mapToTypeMap(registry, Types));
-    const [values, decodedLength] = isU8a(value) ? decodeU8a(registry, value, Classes) : decodeTuple(registry, Classes, value);
-    super(registry, values, decodedLength);
+    const Classes = definition || setDefinition(Array.isArray(Types) ? [Types.map(t => typeToConstructor(registry, t)), []] : isFunction(Types) || isString(Types) ? [[typeToConstructor(registry, Types)], []] : mapToTypeMap(registry, Types));
+    super(registry, Classes[0].length);
+    const [, decodedLength] = isU8a(value) ? decodeU8a(registry, this, value, Classes, false) : decodeTuple(registry, this, Classes, value);
+    this.initialU8aLength = decodedLength;
     this.#Types = Classes;
   }
 
@@ -86,7 +85,7 @@ export class Tuple extends 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
@@ -104,7 +103,7 @@ export class Tuple extends 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(',')})`;
   }
   /**
@@ -123,7 +122,7 @@ export class Tuple extends AbstractArray {
 
 
   toU8a(isBare) {
-    return u8aConcat(...this.toU8aInner(isBare));
+    return u8aConcatStrict(this.toU8aInner(isBare));
   }
 
 }

package/base/Vec.d.ts

@@ -5,7 +5,7 @@ interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
 }
-export declare function decodeVec<T extends Codec>(registry: Registry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
+export declare function decodeVec<T extends Codec>(registry: Registry, result: T[], value: Uint8Array | HexString | unknown[], startAt: number, Type: CodecClass<T>): [number, number];
 /**
  * @name Vec
  * @description
@@ -15,6 +15,7 @@ export declare function decodeVec<T extends Codec>(registry: Registry, Type: Cod
  */
 export declare class Vec<T extends Codec> extends AbstractArray<T> {
     #private;
+    readonly initialU8aLength?: number;
     constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Vec<O>>;
     /**

package/base/Vec.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8a, logger, u8aToU8a } from '@polkadot/util';
+import { assert, compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
@@ -10,11 +10,22 @@ function noopSetDefinition(d) {
   return d;
 }
 
-export function decodeVec(registry, Type, value, length = -1) {
+function decodeVecLength(value) {
   if (Array.isArray(value)) {
-    const result = new Array(value.length);
+    return [value, value.length, 0];
+  }
+
+  const u8a = u8aToU8a(value);
+  const [startAt, length] = compactFromU8aLim(u8a);
+  assert(length <= MAX_LENGTH, () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  return [u8a, length, startAt];
+}
+
+export function decodeVec(registry, result, value, startAt, Type) {
+  if (Array.isArray(value)) {
+    const count = result.length;
 
-    for (let i = 0; i < value.length; i++) {
+    for (let i = 0; i < count; i++) {
       const entry = value[i];
 
       try {
@@ -25,20 +36,10 @@ export function decodeVec(registry, Type, value, length = -1) {
       }
     }
 
-    return [result, 0, 0];
-  }
-
-  const u8a = u8aToU8a(value);
-  let offset = 0;
-
-  if (length === -1) {
-    const [_offset, _length] = compactFromU8a(u8a);
-    assert(_length.lten(MAX_LENGTH), () => `Vec length ${_length.toString()} exceeds ${MAX_LENGTH}`);
-    length = _length.toNumber();
-    offset = _offset;
+    return [0, 0];
   }
 
-  return decodeU8aVec(registry, u8a, offset, Type, length);
+  return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -55,10 +56,11 @@ export class Vec extends AbstractArray {
     definition,
     setDefinition = noopSetDefinition
   } = {}) {
-    const Clazz = definition || setDefinition(typeToConstructor(registry, Type));
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+    const [decodeFrom, length, startAt] = decodeVecLength(value);
+    super(registry, length);
+    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+    const [decodedLength] = isU8a(decodeFrom) ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type);
+    this.initialU8aLength = decodedLength;
   }
 
   static with(Type) {

package/base/VecFixed.d.ts

@@ -12,6 +12,7 @@ interface Options<T> {
  */
 export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
     #private;
+    readonly initialU8aLength?: number;
     constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[], { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string, length: number): CodecClass<VecFixed<O>>;
     /**

package/base/VecFixed.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isU8a, u8aConcat } from '@polkadot/util';
+import { isU8a, u8aConcatStrict } from '@polkadot/util';
 import { AbstractArray } from "../abstract/AbstractArray.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 import { decodeVec } from "./Vec.js";
@@ -8,19 +8,6 @@ import { decodeVec } from "./Vec.js";
 function noopSetDefinition(d) {
   return d;
 }
-/** @internal */
-
-
-function decodeVecFixed(registry, value, Type, length) {
-  const [values, decodedLength, decodedLengthNoOffset] = decodeVec(registry, Type, value, length);
-
-  while (values.length < length) {
-    values.push(new Type(registry));
-  }
-
-  assert(values.length === length, () => `Expected a length of exactly ${length} entries`);
-  return [values, decodedLength, decodedLengthNoOffset];
-}
 /**
  * @name VecFixed
  * @description
@@ -35,10 +22,10 @@ export class VecFixed extends AbstractArray {
     definition,
     setDefinition = noopSetDefinition
   } = {}) {
-    const Clazz = definition || setDefinition(typeToConstructor(registry, Type));
-    const [values,, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, value, 0, Clazz, length) : decodeVecFixed(registry, value, Clazz, length);
-    super(registry, values, decodedLengthNoOffset);
-    this.#Type = Clazz;
+    super(registry, length);
+    this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
+    const [, decodedLengthNoOffset] = isU8a(value) ? decodeU8aVec(registry, this, value, 0, this.#Type) : decodeVec(registry, this, value, 0, this.#Type);
+    this.initialU8aLength = decodedLengthNoOffset;
   }
 
   static with(Type, length) {
@@ -93,7 +80,7 @@ export class VecFixed extends AbstractArray {
     // we override, we don't add the length prefix for ourselves, and at the same time we
     // ignore isBare on entries, since they should be properly encoded at all times
     const encoded = this.toU8aInner();
-    return encoded.length ? u8aConcat(...encoded) : new Uint8Array([]);
+    return encoded.length ? u8aConcatStrict(encoded) : new Uint8Array([]);
   }
   /**
    * @description Returns the base runtime type name for this instance

package/cjs/abstract/AbstractArray.js

@@ -20,15 +20,9 @@ var _compareArray = require("../utils/compareArray");
  * @noInheritDoc
  */
 class AbstractArray extends Array {
-  constructor(registry, values, initialU8aLength) {
-    super(values.length); // explicitly set the values here - this removes the need for any extra allocations
-
-    for (let i = 0; i < values.length; i++) {
-      this[i] = values[i];
-    }
-
+  constructor(registry, length) {
+    super(length);
     this.registry = registry;
-    this.initialU8aLength = initialU8aLength;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -169,7 +163,7 @@ class AbstractArray extends Array {
 
   toU8a(isBare) {
     const encoded = this.toU8aInner();
-    return isBare ? (0, _util.u8aConcat)(...encoded) : (0, _util.u8aConcat)((0, _util.compactToU8a)(this.length), ...encoded);
+    return isBare ? (0, _util.u8aConcatStrict)(encoded) : (0, _util.u8aConcatStrict)([(0, _util.compactToU8a)(this.length), ...encoded]);
   }
 
   toU8aInner(isBare) {

package/cjs/base/Enum.js

@@ -44,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
       };
     }
@@ -401,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
@@ -435,7 +435,7 @@ class Enum {
 
 
   toU8a(isBare) {
-    return (0, _util.u8aConcat)(new Uint8Array(isBare ? [] : [this.index]), this.#raw.toU8a(isBare));
+    return isBare ? this.#raw.toU8a(isBare) : (0, _util.u8aConcatStrict)([new Uint8Array([this.index]), this.#raw.toU8a(isBare)]);
   }
 
 }

package/cjs/base/Tuple.js

@@ -19,25 +19,23 @@ function noopSetDefinition(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
@@ -55,9 +53,10 @@ class Tuple extends _AbstractArray.AbstractArray {
       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));
-    const [values, decodedLength] = (0, _util.isU8a)(value) ? (0, _utils.decodeU8a)(registry, value, Classes) : decodeTuple(registry, Classes, value);
-    super(registry, values, decodedLength);
+    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;
   }
 
@@ -96,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
@@ -114,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(',')})`;
   }
   /**
@@ -133,7 +132,7 @@ class Tuple extends _AbstractArray.AbstractArray {
 
 
   toU8a(isBare) {
-    return (0, _util.u8aConcat)(...this.toU8aInner(isBare));
+    return (0, _util.u8aConcatStrict)(this.toU8aInner(isBare));
   }
 
 }

package/cjs/base/Vec.js

@@ -21,13 +21,22 @@ function noopSetDefinition(d) {
   return d;
 }
 
-function decodeVec(registry, Type, value) {
-  let length = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+function decodeVecLength(value) {
+  if (Array.isArray(value)) {
+    return [value, value.length, 0];
+  }
+
+  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}`);
+  return [u8a, length, 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 {
@@ -38,20 +47,10 @@ function decodeVec(registry, Type, value) {
       }
     }
 
-    return [result, 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, 0];
   }
 
-  return (0, _utils.decodeU8aVec)(registry, u8a, offset, Type, length);
+  return (0, _utils.decodeU8aVec)(registry, result, (0, _util.u8aToU8a)(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -71,10 +70,11 @@ class Vec extends _AbstractArray.AbstractArray {
       definition,
       setDefinition = noopSetDefinition
     } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const Clazz = definition || setDefinition((0, _utils.typeToConstructor)(registry, Type));
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+    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) {

package/cjs/base/VecFixed.js

@@ -18,19 +18,6 @@ var _Vec = require("./Vec");
 function noopSetDefinition(d) {
   return d;
 }
-/** @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];
-}
 /**
  * @name VecFixed
  * @description
@@ -47,10 +34,10 @@ class VecFixed extends _AbstractArray.AbstractArray {
       definition,
       setDefinition = noopSetDefinition
     } = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-    const Clazz = definition || setDefinition((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;
+    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) {
@@ -105,7 +92,7 @@ class VecFixed extends _AbstractArray.AbstractArray {
     // we override, we don't add the length prefix for ourselves, and at the same time we
     // ignore isBare on entries, since they should be properly encoded at all times
     const encoded = this.toU8aInner();
-    return encoded.length ? (0, _util.u8aConcat)(...encoded) : new Uint8Array([]);
+    return encoded.length ? (0, _util.u8aConcatStrict)(encoded) : new Uint8Array([]);
   }
   /**
    * @description Returns the base runtime type name for this instance

package/cjs/extended/BTreeSet.js

@@ -16,11 +16,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 [offset, count] = (0, _util.compactFromU8aLim)(u8a);
+  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];
@@ -221,7 +222,7 @@ class BTreeSet extends Set {
       encoded.push(v.toU8a(isBare));
     }
 
-    return (0, _util.u8aConcat)(...encoded);
+    return (0, _util.u8aConcatStrict)(encoded);
   }
 
 }