@polkadot/types-codec 8.8.3-3 → 8.8.3-6

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 { assert, BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, BN_ZERO, 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
 
@@ -43,21 +43,22 @@ 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;
+    this.isUnsigned = !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`);
@@ -79,14 +80,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 +99,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 { assert, 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
 
@@ -75,7 +75,7 @@ function createFromValue(registry, def, index = 0, value) {
   assert(!isUndefined(entry), () => `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)
   };
 }
 
@@ -153,7 +153,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 +167,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}`;
     }
@@ -303,7 +303,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 +318,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

@@ -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
    */

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 { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 const MAX_LENGTH = 64 * 1024;
 const l = logger('Vec');
@@ -59,8 +59,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>;

package/base/VecFixed.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 import { isU8a, u8aConcatStrict } from '@polkadot/util';
-import { AbstractArray } from "../abstract/AbstractArray.js";
+import { AbstractArray } from "../abstract/Array.js";
 import { decodeU8aVec, typeToConstructor } from "../utils/index.js";
 import { decodeVec } from "./Vec.js";
 
@@ -24,8 +24,7 @@ export class VecFixed extends AbstractArray {
   } = {}) {
     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;
+    this.initialU8aLength = (isU8a(value) ? decodeU8aVec(registry, this, value, 0, this.#Type) : decodeVec(registry, this, value, 0, this.#Type))[1];
   }
 
   static with(Type, length) {

package/base/index.d.ts

@@ -1,4 +1,3 @@
-export { Base } from './Base';
 export { Compact } from './Compact';
 export { DoNotConstruct } from './DoNotConstruct';
 export { Enum } from './Enum';

package/base/index.js

@@ -1,6 +1,5 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-export { Base } from "./Base.js";
 export { Compact } from "./Compact.js";
 export { DoNotConstruct } from "./DoNotConstruct.js";
 export { Enum } from "./Enum.js";

package/cjs/{base → abstract}/Base.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Base = void 0;
+exports.AbstractBase = void 0;
 
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -12,14 +12,13 @@ exports.Base = void 0;
  * @name Base
  * @description A type extends the Base class, when it holds a value
  */
-class Base {
-  #registry;
+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
@@ -49,10 +48,6 @@ 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
    */
@@ -125,4 +120,4 @@ class Base {
 
 }
 
-exports.Base = Base;
+exports.AbstractBase = AbstractBase;

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

@@ -52,24 +52,25 @@ function decodeAbstractInt(value, isNegative) {
 
 class AbstractInt extends _util.BN {
   #bitLength;
-  #isSigned;
 
   constructor(registry) {
     let value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     let bitLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_UINT_BITS;
     let isSigned = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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
-    (0, _util.isU8a)(value) ? (0, _util.u8aToBn)(value.subarray(0, bitLength / 8), {
+    (0, _util.isU8a)(value) ? bitLength <= 48 ? (0, _util.u8aToNumber)(value.subarray(0, bitLength / 8), {
+      isNegative: isSigned
+    }) : (0, _util.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;
+    this.isUnsigned = !isSigned;
     const isPositive = this.gte(_util.BN_ZERO);
     const maxBits = bitLength - (isSigned && isPositive ? 1 : 0);
     (0, _util.assert)(isSigned || isPositive, () => `${this.toRawType()}: Negative number passed to unsigned type`);
@@ -91,14 +92,6 @@ class AbstractInt extends _util.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
    */
@@ -118,7 +111,7 @@ class AbstractInt extends _util.BN {
     // number and BN inputs (no `.eqn` needed) - numbers will be converted
     return super.eq((0, _util.isHex)(other) ? (0, _util.hexToBn)(other.toString(), {
       isLe: false,
-      isNegative: this.#isSigned
+      isNegative: !this.isUnsigned
     }) : (0, _util.bnToBn)(other));
   }
   /**