@polkadot/types-codec 8.5.1 → 8.5.2-10

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/Compact.d.ts

@@ -2,6 +2,10 @@
 import type { BN } from '@polkadot/util';
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, AnyNumber, CodecClass, ICompact, Inspect, INumber, IU8a, Registry } from '../types';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 /**
  * @name Compact
  * @description
@@ -15,8 +19,8 @@ export declare class Compact<T extends INumber> implements ICompact<T> {
     readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber);
-    static with<T extends INumber>(Type: CodecClass<T> | string): CodecClass<Compact<T>>;
+    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Compact<T> | AnyNumber, { definition, setDefinition }?: Options<T>);
+    static with<O extends INumber>(Type: CodecClass<O> | string): CodecClass<Compact<O>>;
     /** @internal */
     static decodeCompact<T extends INumber>(registry: Registry, Type: CodecClass<T>, value: Compact<T> | AnyNumber): [T, number];
     /**
@@ -85,3 +89,4 @@ export declare class Compact<T extends INumber> implements ICompact<T> {
      */
     unwrap(): T;
 }
+export {};

package/base/Compact.js

@@ -2,6 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 import { compactFromU8a, compactToU8a, isU8a } from '@polkadot/util';
 import { typeToConstructor } from "../utils/index.js";
+
+function noopSetDefinition(d) {
+  return d;
+}
 /**
  * @name Compact
  * @description
@@ -11,22 +15,33 @@ import { typeToConstructor } from "../utils/index.js";
  * a number and making the compact representation thereof
  */
 
+
 export class Compact {
   #Type;
   #raw;
 
-  constructor(registry, Type, value = 0) {
+  constructor(registry, Type, value = 0, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
     this.registry = registry;
-    this.#Type = typeToConstructor(registry, Type);
+    this.#Type = definition || setDefinition(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/base/Enum.d.ts

@@ -3,6 +3,20 @@ import type { AnyJson, Codec, CodecClass, IEnum, Inspect, IU8a, Registry } from
 export interface EnumCodecClass<T = Codec> {
     new (registry: Registry, value?: any, index?: number): T;
 }
+interface Definition {
+    def: TypesDef;
+    isBasic: boolean;
+    isIndexed: boolean;
+}
+interface EntryDef {
+    Type: CodecClass;
+    index: number;
+}
+declare type TypesDef = Record<string, EntryDef>;
+interface Options {
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
+}
 /**
  * @name Enum
  * @description
@@ -14,7 +28,7 @@ export declare class Enum implements IEnum {
     readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
-    constructor(registry: Registry, Types: Record<string, string | CodecClass> | Record<string, number> | string[], value?: unknown, index?: number);
+    constructor(registry: Registry, Types: Record<string, string | CodecClass> | Record<string, number> | string[], value?: unknown, index?: number, { definition, setDefinition }?: Options);
     static with(Types: Record<string, string | CodecClass> | Record<string, number> | string[]): EnumCodecClass<Enum>;
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -107,3 +121,4 @@ export declare class Enum implements IEnum {
      */
     toU8a(isBare?: boolean): Uint8Array;
 }
+export {};

package/base/Enum.js

@@ -1,9 +1,13 @@
 // 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
 
+function noopSetDefinition(d) {
+  return d;
+}
+
 function isRustEnum(def) {
   const defValues = Object.values(def);
 
@@ -31,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
       };
     }
@@ -132,12 +135,15 @@ export class Enum {
   #isIndexed;
   #raw;
 
-  constructor(registry, Types, value, index) {
+  constructor(registry, Types, value, index, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
     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 = isU8a(value) && value.length && !isNumber(index) ? createFromValue(registry, def, value[0], value.subarray(1)) : decodeEnum(registry, def, value, index);
     this.registry = registry;
@@ -166,9 +172,16 @@ export 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
+        });
         objectProperties(this, isKeys, (_, i) => this.type === keys[i]);
         objectProperties(this, asKeys, (k, i) => {
           assert(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);
@@ -369,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
@@ -402,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/Option.d.ts

@@ -1,5 +1,9 @@
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, Codec, CodecClass, Inspect, IOption, IU8a, Registry } from '../types';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 /**
  * @name Option
  * @description
@@ -12,7 +16,7 @@ export declare class Option<T extends Codec> implements IOption<T> {
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
-    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown);
+    constructor(registry: Registry, typeName: CodecClass<T> | string, value?: unknown, { definition, setDefinition }?: Options<T>);
     static with<O extends Codec>(Type: CodecClass<O> | string): CodecClass<Option<O>>;
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -41,7 +45,7 @@ export declare class Option<T extends Codec> implements IOption<T> {
     /**
      * @description The actual value for the Option
      */
-    get value(): Codec;
+    get value(): T;
     /**
      * @description Compares the value of the input to see if there is a match
      */
@@ -90,3 +94,4 @@ export declare class Option<T extends Codec> implements IOption<T> {
      */
     unwrapOrDefault(): T;
 }
+export {};

package/base/Option.js

@@ -4,6 +4,10 @@ import { assert, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot
 import { typeToConstructor } from "../utils/index.js";
 import { Null } from "./Null.js";
 
+function noopSetDefinition(d) {
+  return d;
+}
+
 class None extends Null {
   /**
    * @description Returns the base runtime type name for this instance
@@ -50,8 +54,11 @@ export class Option {
   #initialU8aLength;
   #raw;
 
-  constructor(registry, typeName, value) {
-    const Type = typeToConstructor(registry, typeName);
+  constructor(registry, typeName, value, {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    const Type = definition || setDefinition(typeToConstructor(registry, typeName));
     const decoded = isU8a(value) && value.length && !isCodec(value) ? value[0] === 0 ? new None(registry) : new Type(registry, value.subarray(1)) : decodeOption(registry, Type, value);
     this.registry = registry;
     this.#Type = Type;
@@ -63,9 +70,19 @@ export 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/base/Tuple.d.ts

@@ -4,6 +4,11 @@ declare type TupleType = (CodecClass | string);
 declare type TupleTypes = TupleType[] | {
     [index: string]: CodecClass | string;
 };
+declare type Definition = [CodecClass[], string[]];
+interface Options {
+    definition?: Definition;
+    setDefinition?: (d: Definition) => Definition;
+}
 /**
  * @name Tuple
  * @description
@@ -12,7 +17,8 @@ declare type TupleTypes = TupleType[] | {
  */
 export declare class Tuple extends AbstractArray<Codec> implements ITuple<Codec[]> {
     #private;
-    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue);
+    readonly initialU8aLength?: number;
+    constructor(registry: Registry, Types: TupleTypes | TupleType, value?: AnyTupleValue, { definition, setDefinition }?: Options);
     static with(Types: TupleTypes | TupleType): CodecClass<Tuple>;
     /**
      * @description The length of the value when encoded as a Uint8Array

package/base/Tuple.js

@@ -1,29 +1,32 @@
 // 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";
 
+function noopSetDefinition(d) {
+  return 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
@@ -36,17 +39,28 @@ function decodeTuple(registry, Classes, value) {
 export class Tuple extends AbstractArray {
   #Types;
 
-  constructor(registry, Types, value) {
-    const Classes = 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);
+  constructor(registry, Types, value, {
+    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));
+    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;
   }
 
   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
+        });
       }
 
     };
@@ -71,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
@@ -89,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(',')})`;
   }
   /**
@@ -108,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

@@ -1,7 +1,11 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, CodecClass, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
-export declare function decodeVec<T extends Codec>(registry: Registry, Type: CodecClass<T>, value: Uint8Array | HexString | unknown[], length?: number): [T[], number, number];
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
+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
@@ -11,7 +15,8 @@ export declare function decodeVec<T extends Codec>(registry: Registry, Type: Cod
  */
 export declare class Vec<T extends Codec> extends AbstractArray<T> {
     #private;
-    constructor(registry: Registry, Type: CodecClass<T> | string, value?: Uint8Array | HexString | unknown[]);
+    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>>;
     /**
      * @description The type for the items
@@ -26,3 +31,4 @@ export declare class Vec<T extends Codec> extends AbstractArray<T> {
      */
     toRawType(): string;
 }
+export {};

package/base/Vec.js

@@ -1,15 +1,31 @@
 // 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;
 const l = logger('Vec');
-export function decodeVec(registry, Type, value, length = -1) {
+
+function noopSetDefinition(d) {
+  return d;
+}
+
+function decodeVecLength(value) {
   if (Array.isArray(value)) {
-    const result = new Array(value.length);
+    return [value, value.length, 0];
+  }
 
-    for (let i = 0; i < value.length; i++) {
+  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 < count; i++) {
       const entry = value[i];
 
       try {
@@ -20,20 +36,10 @@ export function decodeVec(registry, Type, value, length = -1) {
       }
     }
 
-    return [result, 0, 0];
+    return [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 decodeU8aVec(registry, u8a, offset, Type, length);
+  return decodeU8aVec(registry, result, u8aToU8a(value), startAt, Type);
 }
 /**
  * @name Vec
@@ -46,17 +52,28 @@ export function decodeVec(registry, Type, value, length = -1) {
 export class Vec extends AbstractArray {
   #Type;
 
-  constructor(registry, Type, value = []) {
-    const Clazz = typeToConstructor(registry, Type);
-    const [values, decodedLength] = decodeVec(registry, Clazz, value);
-    super(registry, values, decodedLength);
-    this.#Type = Clazz;
+  constructor(registry, Type, value = [], {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    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) {
+    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/base/VecFixed.d.ts

@@ -1,6 +1,10 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, CodecClass, Inspect, Registry } from '../types';
 import { AbstractArray } from '../abstract/AbstractArray';
+interface Options<T> {
+    definition?: CodecClass<T>;
+    setDefinition?: (d: CodecClass<T>) => CodecClass<T>;
+}
 /**
  * @name VecFixed
  * @description
@@ -8,7 +12,8 @@ import { AbstractArray } from '../abstract/AbstractArray';
  */
 export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
     #private;
-    constructor(registry: Registry, Type: CodecClass<T> | string, length: number, value?: Uint8Array | HexString | unknown[]);
+    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>>;
     /**
      * @description The type for the items
@@ -28,3 +33,4 @@ export declare class VecFixed<T extends Codec> extends AbstractArray<T> {
      */
     toRawType(): string;
 }
+export {};

package/base/VecFixed.js

@@ -1,20 +1,12 @@
 // 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";
-/** @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];
+function noopSetDefinition(d) {
+  return d;
 }
 /**
  * @name VecFixed
@@ -26,17 +18,27 @@ function decodeVecFixed(registry, value, Type, length) {
 export class VecFixed extends AbstractArray {
   #Type;
 
-  constructor(registry, Type, length, value = []) {
-    const Clazz = 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;
+  constructor(registry, Type, length, value = [], {
+    definition,
+    setDefinition = noopSetDefinition
+  } = {}) {
+    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) {
+    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
+        });
       }
 
     };
@@ -78,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