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

package/{base → abstract}/Base.d.ts

@@ -4,10 +4,11 @@ import type { AnyJson, BareOpts, Codec, Inspect, IU8a, Registry } from '../types
  * @name Base
  * @description A type extends the Base class, when it holds a value
  */
-export declare abstract class Base<T extends Codec> implements Codec {
+export declare abstract class AbstractBase<T extends Codec> implements Codec {
     #private;
     createdAtHash?: IU8a;
     readonly initialU8aLength?: number;
+    readonly registry: Registry;
     protected constructor(registry: Registry, value: T, initialU8aLength?: number);
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -22,7 +23,6 @@ export declare abstract class Base<T extends Codec> implements Codec {
      * @description Checks if the value is an empty value
      */
     get isEmpty(): boolean;
-    get registry(): Registry;
     /**
      * @description Compares the value of the input to see if there is a match
      */

package/{base → abstract}/Base.js

@@ -5,14 +5,13 @@
  * @name Base
  * @description A type extends the Base class, when it holds a value
  */
-export class Base {
-  #registry;
+export class AbstractBase {
   #raw;
 
   constructor(registry, value, initialU8aLength) {
-    this.#registry = registry;
     this.#raw = value;
     this.initialU8aLength = initialU8aLength;
+    this.registry = registry;
   }
   /**
    * @description The length of the value when encoded as a Uint8Array
@@ -42,10 +41,6 @@ export class Base {
   get isEmpty() {
     return this.#raw.isEmpty;
   }
-
-  get registry() {
-    return this.#registry;
-  }
   /**
    * @description Compares the value of the input to see if there is a match
    */

package/abstract/{AbstractInt.d.ts → Int.d.ts}

@@ -13,6 +13,7 @@ export declare abstract class AbstractInt extends BN implements INumber {
     readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly encodedLength: number;
+    readonly isUnsigned: boolean;
     constructor(registry: Registry, value?: AnyNumber, bitLength?: UIntBitLength, isSigned?: boolean);
     /**
      * @description returns a hash of the contents
@@ -22,10 +23,6 @@ export declare abstract class AbstractInt extends BN implements INumber {
      * @description Checks if the value is a zero value (align elsewhere)
      */
     get isEmpty(): boolean;
-    /**
-     * @description Checks if the value is an unsigned type
-     */
-    get isUnsigned(): boolean;
     /**
      * @description Returns the number of bits in the value
      */

package/abstract/{AbstractInt.js → Int.js}

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, BN_ZERO, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isHex, isNumber, isString, isU8a, u8aToBn } from '@polkadot/util';
+import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isHex, isNumber, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
 export const DEFAULT_UINT_BITS = 64; // Maximum allowed integer for JS is 2^53 - 1, set limit at 52
 // In this case however, we always print any >32 as hex
 
@@ -16,7 +16,10 @@ function toPercentage(value, divisor) {
 
 function decodeAbstractInt(value, isNegative) {
   if (isNumber(value)) {
-    assert(value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER && Number.isInteger(value), 'Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
+    if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+      throw new Error('Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
+    }
+
     return value;
   } else if (isString(value)) {
     if (isHex(value, -1, true)) {
@@ -26,7 +29,10 @@ function decodeAbstractInt(value, isNegative) {
       }).toString();
     }
 
-    assert(!(value.includes('.') || value.includes(',') || value.includes('e')), 'String should not contain decimal points or scientific notation');
+    if (value.includes('.') || value.includes(',') || value.includes('e')) {
+      throw new Error('String should not contain decimal points or scientific notation');
+    }
+
     return value;
   } else if (isBn(value)) {
     return value.toString();
@@ -43,25 +49,30 @@ function decodeAbstractInt(value, isNegative) {
 
 export class AbstractInt extends BN {
   #bitLength;
-  #isSigned;
 
   constructor(registry, value = 0, bitLength = DEFAULT_UINT_BITS, isSigned = false) {
-    // Construct via a string, which will be passed in the BN constructor.
+    // Construct via a string/number, which will be passed in the BN constructor.
     // It would be ideal to actually return a BN, but there is an issue:
     // https://github.com/indutny/bn.js/issues/206
     super( // shortcut isU8a as used in SCALE decoding
-    isU8a(value) ? u8aToBn(value.subarray(0, bitLength / 8), {
+    isU8a(value) ? bitLength <= 48 ? u8aToNumber(value.subarray(0, bitLength / 8), {
+      isNegative: isSigned
+    }) : u8aToBn(value.subarray(0, bitLength / 8), {
       isLe: true,
       isNegative: isSigned
     }).toString() : decodeAbstractInt(value, isSigned));
     this.registry = registry;
     this.#bitLength = bitLength;
     this.encodedLength = this.#bitLength / 8;
-    this.#isSigned = isSigned;
-    const isPositive = this.gte(BN_ZERO);
-    const maxBits = bitLength - (isSigned && isPositive ? 1 : 0);
-    assert(isSigned || isPositive, () => `${this.toRawType()}: Negative number passed to unsigned type`);
-    assert(super.bitLength() <= maxBits, () => `${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
+    this.isUnsigned = !isSigned;
+    const isNegative = this.isNeg();
+    const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
+
+    if (isNegative && !isSigned) {
+      throw new Error(`${this.toRawType()}: Negative number passed to unsigned type`);
+    } else if (super.bitLength() > maxBits) {
+      throw new Error(`${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
+    }
   }
   /**
    * @description returns a hash of the contents
@@ -79,14 +90,6 @@ export class AbstractInt extends BN {
   get isEmpty() {
     return this.isZero();
   }
-  /**
-   * @description Checks if the value is an unsigned type
-   */
-
-
-  get isUnsigned() {
-    return !this.#isSigned;
-  }
   /**
    * @description Returns the number of bits in the value
    */
@@ -106,7 +109,7 @@ export class AbstractInt extends BN {
     // number and BN inputs (no `.eqn` needed) - numbers will be converted
     return super.eq(isHex(other) ? hexToBn(other.toString(), {
       isLe: false,
-      isNegative: this.#isSigned
+      isNegative: !this.isUnsigned
     }) : bnToBn(other));
   }
   /**

package/abstract/index.d.ts

@@ -1,2 +1,3 @@
-export { AbstractArray } from './AbstractArray';
-export { AbstractInt } from './AbstractInt';
+export { AbstractArray } from './Array';
+export { AbstractBase } from './Base';
+export { AbstractInt } from './Int';

package/abstract/index.js

@@ -1,4 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-export { AbstractArray } from "./AbstractArray.js";
-export { AbstractInt } from "./AbstractInt.js";
+export { AbstractArray } from "./Array.js";
+export { AbstractBase } from "./Base.js";
+export { AbstractInt } from "./Int.js";

package/base/Compact.d.ts

@@ -21,8 +21,6 @@ export declare class Compact<T extends INumber> implements ICompact<T> {
     readonly initialU8aLength?: number;
     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];
     /**
      * @description The length of the value when encoded as a Uint8Array
      */

package/base/Compact.js

@@ -6,6 +6,20 @@ import { typeToConstructor } from "../utils/index.js";
 function noopSetDefinition(d) {
   return d;
 }
+
+function decodeCompact(registry, Type, value) {
+  if (isU8a(value)) {
+    const [decodedLength, bn] = (value[0] & 0b11) < 0b11 ? compactFromU8aLim(value) : compactFromU8a(value);
+    return [new Type(registry, bn), decodedLength];
+  } else if (value instanceof Compact) {
+    const raw = value.unwrap();
+    return raw instanceof Type ? [raw, 0] : [new Type(registry, raw), 0];
+  } else if (value instanceof Type) {
+    return [value, 0];
+  }
+
+  return [new Type(registry, value), 0];
+}
 /**
  * @name Compact
  * @description
@@ -26,7 +40,7 @@ export class Compact {
   } = {}) {
     this.registry = registry;
     this.#Type = definition || setDefinition(typeToConstructor(registry, Type));
-    const [raw, decodedLength] = Compact.decodeCompact(registry, this.#Type, value);
+    const [raw, decodedLength] = decodeCompact(registry, this.#Type, value);
     this.initialU8aLength = decodedLength;
     this.#raw = raw;
   }
@@ -46,21 +60,6 @@ export class Compact {
 
     };
   }
-  /** @internal */
-
-
-  static decodeCompact(registry, Type, value) {
-    if (isU8a(value)) {
-      const [decodedLength, bn] = (value[0] & 0b11) < 0b11 ? compactFromU8aLim(value) : compactFromU8a(value);
-      return [new Type(registry, bn), decodedLength];
-    } else if (value instanceof Compact) {
-      return value.#raw instanceof Type ? [value.#raw, 0] : [new Type(registry, value.#raw), 0];
-    } else if (value instanceof Type) {
-      return [value, 0];
-    }
-
-    return [new Type(registry, value), 0];
-  }
   /**
    * @description The length of the value when encoded as a Uint8Array
    */

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, u8aConcatStrict, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { 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
 
@@ -12,7 +12,10 @@ function isRustEnum(def) {
   const defValues = Object.values(def);
 
   if (defValues.some(v => isNumber(v))) {
-    assert(defValues.every(v => isNumber(v) && v >= 0 && v <= 255), 'Invalid number-indexed enum definition');
+    if (!defValues.every(v => isNumber(v) && v >= 0 && v <= 255)) {
+      throw new Error('Invalid number-indexed enum definition');
+    }
+
     return false;
   }
 
@@ -72,10 +75,14 @@ function extractDef(registry, _def) {
 
 function createFromValue(registry, def, index = 0, value) {
   const entry = Object.values(def).find(e => e.index === index);
-  assert(!isUndefined(entry), () => `Unable to create Enum via index ${index}, in ${Object.keys(def).join(', ')}`);
+
+  if (isUndefined(entry)) {
+    throw new Error(`Unable to create Enum via index ${index}, in ${Object.keys(def).join(', ')}`);
+  }
+
   return {
     index,
-    value: isCodec(value) && value instanceof entry.Type ? value : new entry.Type(registry, value)
+    value: value instanceof entry.Type ? value : new entry.Type(registry, value)
   };
 }
 
@@ -85,7 +92,10 @@ function decodeFromJSON(registry, def, key, value) {
   const keys = Object.keys(def).map(k => k.toLowerCase());
   const keyLower = key.toLowerCase();
   const index = keys.indexOf(keyLower);
-  assert(index !== -1, () => `Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+
+  if (index === -1) {
+    throw new Error(`Cannot map Enum JSON, unable to find '${key}' in ${keys.join(', ')}`);
+  }
 
   try {
     return createFromValue(registry, def, Object.values(def)[index].index, value);
@@ -153,7 +163,7 @@ export class Enum {
     this.#indexes = Object.values(def).map(({
       index
     }) => index);
-    this.#entryIndex = this.#indexes.indexOf(decoded.index) || 0;
+    this.#entryIndex = this.#indexes.indexOf(decoded.index);
     this.#raw = decoded.value;
 
     if (this.#raw.initialU8aLength) {
@@ -167,7 +177,7 @@ export class Enum {
     const isKeys = new Array(keys.length);
 
     for (let i = 0; i < keys.length; i++) {
-      const name = stringPascalCase(keys[i].replace(' ', '_'));
+      const name = stringPascalCase(keys[i]);
       asKeys[i] = `as${name}`;
       isKeys[i] = `is${name}`;
     }
@@ -184,7 +194,10 @@ export class Enum {
         });
         objectProperties(this, isKeys, (_, i) => this.type === keys[i]);
         objectProperties(this, asKeys, (k, i) => {
-          assert(this[isKeys[i]], () => `Cannot convert '${this.type}' via ${k}`);
+          if (!this[isKeys[i]]) {
+            throw new Error(`Cannot convert '${this.type}' via ${k}`);
+          }
+
           return this.value;
         });
       }
@@ -303,7 +316,7 @@ export class Enum {
       return this.type === other;
     } else if (isHex(other)) {
       return this.toHex() === other;
-    } else if (isCodec(other) && other instanceof Enum) {
+    } else if (other instanceof Enum) {
       return this.index === other.index && this.value.eq(other.value);
     } else if (isObject(other)) {
       return this.value.eq(other[this.type]);
@@ -318,7 +331,7 @@ export class Enum {
 
 
   inspect() {
-    if (this.isBasic) {
+    if (this.#isBasic) {
       return {
         outer: [new Uint8Array([this.index])]
       };

package/base/Int.d.ts

@@ -1,5 +1,5 @@
 import type { AnyNumber, CodecClass, Registry, UIntBitLength } from '../types';
-import { AbstractInt } from '../abstract/AbstractInt';
+import { AbstractInt } from '../abstract/Int';
 /**
  * @name Int
  * @description

package/base/Int.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { AbstractInt } from "../abstract/AbstractInt.js";
+import { AbstractInt } from "../abstract/Int.js";
 /**
  * @name Int
  * @description

package/base/Null.d.ts

@@ -6,22 +6,16 @@ import type { Codec, Inspect, IU8a, Registry } from '../types';
  * Implements a type that does not contain anything (apart from `null`)
  */
 export declare class Null implements Codec {
+    readonly encodedLength = 0;
+    readonly isEmpty = true;
     readonly registry: Registry;
     createdAtHash?: IU8a;
     readonly initialU8aLength = 0;
     constructor(registry: Registry);
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength(): number;
     /**
      * @description returns a hash of the contents
      */
     get hash(): IU8a;
-    /**
-     * @description Checks if the value is an empty value (always true)
-     */
-    get isEmpty(): boolean;
     /**
      * @description Compares the value of the input to see if there is a match
      */

package/base/Null.js

@@ -8,20 +8,14 @@ import { isNull } from '@polkadot/util';
  */
 
 export class Null {
+  encodedLength = 0;
+  isEmpty = true;
   // Added for compatibility reasons, e.g. see Option
   initialU8aLength = 0;
 
   constructor(registry) {
     this.registry = registry;
   }
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-
-
-  get encodedLength() {
-    return 0;
-  }
   /**
    * @description returns a hash of the contents
    */
@@ -30,14 +24,6 @@ export class Null {
   get hash() {
     throw new Error('.hash is not implemented on Null');
   }
-  /**
-   * @description Checks if the value is an empty value (always true)
-   */
-
-
-  get isEmpty() {
-    return true;
-  }
   /**
    * @description Compares the value of the input to see if there is a match
    */

package/base/Option.d.ts

@@ -16,16 +16,13 @@ export declare class Option<T extends Codec> implements IOption<T> {
     #private;
     readonly registry: Registry;
     createdAtHash?: IU8a;
+    initialU8aLength?: number;
     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
      */
     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/base/Option.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
+import { isCodec, isNull, isU8a, isUndefined, u8aToHex } from '@polkadot/util';
 import { typeToConstructor } from "../utils/index.js";
 import { Null } from "./Null.js";
 
@@ -58,7 +58,6 @@ function decodeOption(registry, Type, value) {
 
 export class Option {
   #Type;
-  #initialU8aLength;
   #raw;
 
   constructor(registry, typeName, value, {
@@ -72,7 +71,7 @@ export class Option {
     this.#raw = decoded;
 
     if (decoded && decoded.initialU8aLength) {
-      this.#initialU8aLength = 1 + decoded.initialU8aLength;
+      this.initialU8aLength = 1 + decoded.initialU8aLength;
     }
   }
 
@@ -103,14 +102,6 @@ export class Option {
     // boolean byte (has value, doesn't have) along with wrapped length
     return 1 + this.#raw.encodedLength;
   }
-  /**
-   * @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
    */
@@ -253,7 +244,10 @@ export class Option {
 
 
   unwrap() {
-    assert(this.isSome, 'Option: unwrapping a None value');
+    if (this.isNone) {
+      throw new Error('Option: unwrapping a None value');
+    }
+
     return this.#raw;
   }
   /**

package/base/Result.js

@@ -1,6 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert } from '@polkadot/util';
 import { Enum } from "./Enum.js";
 /**
  * @name Result
@@ -32,7 +31,10 @@ export class Result extends Enum {
 
 
   get asErr() {
-    assert(this.isErr, 'Cannot extract Err value from Ok result, check isErr first');
+    if (!this.isErr) {
+      throw new Error('Cannot extract Err value from Ok result, check isErr first');
+    }
+
     return this.value;
   }
   /**
@@ -49,7 +51,10 @@ export class Result extends Enum {
 
 
   get asOk() {
-    assert(this.isOk, 'Cannot extract Ok value from Err result, check isOk first');
+    if (!this.isOk) {
+      throw new Error('Cannot extract Ok value from Err result, check isOk first');
+    }
+
     return this.value;
   }
   /**

package/base/Tuple.d.ts

@@ -1,5 +1,5 @@
 import type { AnyTupleValue, Codec, CodecClass, Inspect, ITuple, Registry } from '../types';
-import { AbstractArray } from '../abstract/AbstractArray';
+import { AbstractArray } from '../abstract/Array';
 declare type TupleType = (CodecClass | string);
 declare type TupleTypes = TupleType[] | {
     [index: string]: CodecClass | string;

package/base/Tuple.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { isFunction, isHex, isString, isU8a, stringify, u8aConcatStrict, u8aToU8a } from '@polkadot/util';
-import { AbstractArray } from "../abstract/AbstractArray.js";
+import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8a, mapToTypeMap, typeToConstructor } from "../utils/index.js";
 
 function noopSetDefinition(d) {
@@ -10,7 +10,7 @@ function noopSetDefinition(d) {
 /** @internal */
 
 
-function decodeTuple(registry, result, Classes, value) {
+function decodeTuple(registry, result, value, Classes) {
   if (isU8a(value) || isHex(value)) {
     return decodeU8a(registry, result, u8aToU8a(value), Classes);
   }
@@ -45,8 +45,7 @@ export class Tuple extends AbstractArray {
   } = {}) {
     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.initialU8aLength = (isU8a(value) ? decodeU8a(registry, this, value, Classes) : decodeTuple(registry, this, value, Classes))[1];
     this.#Types = Classes;
   }
 

package/base/UInt.d.ts

@@ -1,5 +1,5 @@
 import type { CodecClass, UIntBitLength } from '../types';
-import { AbstractInt } from '../abstract/AbstractInt';
+import { AbstractInt } from '../abstract/Int';
 /**
  * @name UInt
  * @description

package/base/UInt.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { AbstractInt } from "../abstract/AbstractInt.js";
+import { AbstractInt } from "../abstract/Int.js";
 /**
  * @name UInt
  * @description

package/base/Vec.d.ts

@@ -1,6 +1,6 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, CodecClass, Registry } from '../types';
-import { AbstractArray } from '../abstract/AbstractArray';
+import { AbstractArray } from '../abstract/Array';
 interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;

package/base/Vec.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { assert, compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
-import { AbstractArray } from "../abstract/AbstractArray.js";
+import { compactFromU8aLim, isU8a, logger, u8aToU8a } from '@polkadot/util';
+import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
 const l = logger('Vec');
@@ -17,7 +17,11 @@ function decodeVecLength(value) {
 
   const u8a = u8aToU8a(value);
   const [startAt, length] = compactFromU8aLim(u8a);
-  assert(length <= MAX_LENGTH, () => `Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+
+  if (length > MAX_LENGTH) {
+    throw new Error(`Vec length ${length.toString()} exceeds ${MAX_LENGTH}`);
+  }
+
   return [u8a, length, startAt];
 }
 
@@ -59,8 +63,7 @@ export class Vec extends AbstractArray {
     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;
+    this.initialU8aLength = (isU8a(decodeFrom) ? decodeU8aVec(registry, this, decodeFrom, startAt, this.#Type) : decodeVec(registry, this, decodeFrom, startAt, this.#Type))[0];
   }
 
   static with(Type) {

package/base/VecAny.d.ts

@@ -1,5 +1,5 @@
 import type { Codec } from '../types';
-import { AbstractArray } from '../abstract/AbstractArray';
+import { AbstractArray } from '../abstract/Array';
 /**
  * @name VecAny
  * @description

package/base/VecAny.js

@@ -1,6 +1,6 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { AbstractArray } from "../abstract/AbstractArray.js";
+import { AbstractArray } from "../abstract/Array.js";
 /**
  * @name VecAny
  * @description

package/base/VecFixed.d.ts

@@ -1,6 +1,6 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Codec, CodecClass, Inspect, Registry } from '../types';
-import { AbstractArray } from '../abstract/AbstractArray';
+import { AbstractArray } from '../abstract/Array';
 interface Options<T> {
     definition?: CodecClass<T>;
     setDefinition?: (d: CodecClass<T>) => CodecClass<T>;