@polkadot/types-codec 10.9.1 → 10.11.1

package/abstract/Array.js

@@ -8,6 +8,10 @@ import { compareArray } from '../utils/compareArray.js';
  * @noInheritDoc
  */
 export class AbstractArray extends Array {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
     /**
      * @description This ensures that operators such as clice, filter, map, etc. return
      * new Array instances (without this we need to apply overrides)

package/abstract/Base.js

@@ -3,6 +3,11 @@
  * @description A type extends the Base class, when it holds a value
  */
 export class AbstractBase {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__raw;
     constructor(registry, value, initialU8aLength) {
         this.initialU8aLength = initialU8aLength;
         this.__internal__raw = value;

package/abstract/Int.js

@@ -58,6 +58,13 @@ function decodeAbstractInt(value, isNegative) {
  * @noInheritDoc
  */
 export class AbstractInt extends BN {
+    registry;
+    encodedLength;
+    isUnsigned;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__bitLength;
     constructor(registry, value = 0, bitLength = DEFAULT_UINT_BITS, isSigned = false) {
         // 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:

package/abstract/Object.js

@@ -3,6 +3,11 @@
  * @description A type extends the Base class, when it holds a value
  */
 export class AbstractObject {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    $;
     constructor(registry, value, initialU8aLength) {
         this.$ = value;
         this.initialU8aLength = initialU8aLength;

package/base/Compact.js

@@ -27,6 +27,12 @@ function decodeCompact(registry, Type, value) {
  * a number and making the compact representation thereof
  */
 export class Compact {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__Type;
+    __internal__raw;
     constructor(registry, Type, value = 0, { definition, setDefinition = identity } = {}) {
         this.registry = registry;
         this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));

package/base/DoNotConstruct.js

@@ -4,6 +4,10 @@
  * An unknown type that fails on construction with the type info
  */
 export class DoNotConstruct {
+    registry;
+    createdAtHash;
+    isStorageFallback;
+    __internal__neverError;
     constructor(registry, typeName = 'DoNotConstruct') {
         this.registry = registry;
         this.__internal__neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);

package/base/Enum.d.ts

@@ -1,8 +1,6 @@
 import type { HexString } from '@polkadot/util/types';
 import type { AnyJson, Codec, CodecClass, DefinitionSetter, IEnum, Inspect, IU8a, Registry } from '../types/index.js';
-export interface EnumCodecClass<T = Codec> {
-    new (registry: Registry, value?: any, index?: number): T;
-}
+export type EnumCodecClass<T = Codec> = new (registry: Registry, value?: any, index?: number) => T;
 interface Definition {
     def: TypesDef;
     isBasic: boolean;

package/base/Enum.js

@@ -47,7 +47,7 @@ function extractDef(registry, _def) {
 }
 function getEntryType(def, checkIdx) {
     const values = Object.values(def);
-    for (let i = 0; i < values.length; i++) {
+    for (let i = 0, count = values.length; i < count; i++) {
         const { Type, index } = values[i];
         if (index === checkIdx) {
             return Type;
@@ -123,6 +123,16 @@ function decodeEnum(registry, def, value, index) {
  * an extension to enum where the value type is determined by the actual index.
  */
 export class Enum {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__def;
+    __internal__entryIndex;
+    __internal__indexes;
+    __internal__isBasic;
+    __internal__isIndexed;
+    __internal__raw;
     constructor(registry, Types, value, index, { definition, setDefinition = identity } = {}) {
         const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
         // shortcut isU8a as used in SCALE decoding
@@ -141,16 +151,11 @@ export class Enum {
         }
     }
     static with(Types) {
-        var _a;
         let definition;
         // eslint-disable-next-line no-return-assign
         const setDefinition = (d) => definition = d;
-        return _a = class extends Enum {
-                constructor(registry, value, index) {
-                    super(registry, Types, value, index, { definition, setDefinition });
-                }
-            },
-            (() => {
+        return class extends Enum {
+            static {
                 const keys = Array.isArray(Types)
                     ? Types
                     : Object.keys(Types);
@@ -162,15 +167,18 @@ export class Enum {
                     asKeys[i] = `as${name}`;
                     isKeys[i] = `is${name}`;
                 }
-                objectProperties(_a.prototype, isKeys, (_, i, self) => self.type === keys[i]);
-                objectProperties(_a.prototype, asKeys, (k, i, self) => {
+                objectProperties(this.prototype, isKeys, (_, i, self) => self.type === keys[i]);
+                objectProperties(this.prototype, asKeys, (k, i, self) => {
                     if (self.type !== keys[i]) {
                         throw new Error(`Cannot convert '${self.type}' via ${k}`);
                     }
                     return self.value;
                 });
-            })(),
-            _a;
+            }
+            constructor(registry, value, index) {
+                super(registry, Types, value, index, { definition, setDefinition });
+            }
+        };
     }
     /**
      * @description The length of the value when encoded as a Uint8Array

package/base/Null.js

@@ -5,10 +5,13 @@ import { isNull } from '@polkadot/util';
  * Implements a type that does not contain anything (apart from `null`)
  */
 export class Null {
+    encodedLength = 0;
+    isEmpty = true;
+    registry;
+    createdAtHash;
+    initialU8aLength = 0;
+    isStorageFallback;
     constructor(registry) {
-        this.encodedLength = 0;
-        this.isEmpty = true;
-        this.initialU8aLength = 0;
         this.registry = registry;
     }
     /**

package/base/Option.js

@@ -28,7 +28,7 @@ function decodeOption(registry, Type, value) {
         return new Type(registry, value.value);
     }
     else if (isNull(value) || isUndefined(value) || value === '0x' || value instanceof None) {
-        // anyhting empty we pass as-is
+        // anything empty we pass as-is
         return new None(registry);
     }
     else if (isU8a(value)) {
@@ -49,6 +49,12 @@ function decodeOption(registry, Type, value) {
  * with a value if/as required/found.
  */
 export class Option {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__Type;
+    __internal__raw;
     constructor(registry, typeName, value, { definition, setDefinition = identity } = {}) {
         const Type = definition || setDefinition(typeToConstructor(registry, typeName));
         const decoded = isU8a(value) && value.length && !isCodec(value)

package/base/Tuple.d.ts

@@ -1,9 +1,7 @@
 import type { AnyTupleValue, Codec, CodecClass, DefinitionSetter, Inspect, ITuple, Registry } from '../types/index.js';
 import { AbstractArray } from '../abstract/Array.js';
 type TupleType = (CodecClass | string);
-type TupleTypes = TupleType[] | {
-    [index: string]: CodecClass | string;
-};
+type TupleTypes = TupleType[] | Record<string, CodecClass | string>;
 type Definition = [CodecClass[], string[]];
 /**
  * @name Tuple

package/base/Tuple.js

@@ -37,6 +37,7 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 export class Tuple extends AbstractArray {
+    __internal__Types;
     constructor(registry, Types, value, { definition, setDefinition = identity } = {}) {
         const Classes = definition || setDefinition(Array.isArray(Types)
             ? [typesToConstructors(registry, Types), []]

package/base/Vec.js

@@ -53,6 +53,7 @@ export function decodeVec(registry, result, value, startAt, Type) {
  * specific encoding/decoding on top of the base type.
  */
 export class Vec extends AbstractArray {
+    __internal__Type;
     constructor(registry, Type, value = [], { definition, setDefinition = identity } = {}) {
         const [decodeFrom, length, startAt] = decodeVecLength(value);
         super(registry, length);

package/base/VecFixed.js

@@ -8,6 +8,7 @@ import { decodeVec } from './Vec.js';
  * This manages codec arrays of a fixed length
  */
 export class VecFixed extends AbstractArray {
+    __internal__Type;
     constructor(registry, Type, length, value = [], { definition, setDefinition = identity } = {}) {
         super(registry, length);
         this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));

package/cjs/abstract/Array.js

@@ -11,6 +11,10 @@ const compareArray_js_1 = require("../utils/compareArray.js");
  * @noInheritDoc
  */
 class AbstractArray extends Array {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
     /**
      * @description This ensures that operators such as clice, filter, map, etc. return
      * new Array instances (without this we need to apply overrides)

package/cjs/abstract/Base.js

@@ -6,6 +6,11 @@ exports.AbstractBase = void 0;
  * @description A type extends the Base class, when it holds a value
  */
 class AbstractBase {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__raw;
     constructor(registry, value, initialU8aLength) {
         this.initialU8aLength = initialU8aLength;
         this.__internal__raw = value;

package/cjs/abstract/Int.js

@@ -61,6 +61,13 @@ function decodeAbstractInt(value, isNegative) {
  * @noInheritDoc
  */
 class AbstractInt extends util_1.BN {
+    registry;
+    encodedLength;
+    isUnsigned;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__bitLength;
     constructor(registry, value = 0, bitLength = exports.DEFAULT_UINT_BITS, isSigned = false) {
         // 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:

package/cjs/abstract/Object.js

@@ -6,6 +6,11 @@ exports.AbstractObject = void 0;
  * @description A type extends the Base class, when it holds a value
  */
 class AbstractObject {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    $;
     constructor(registry, value, initialU8aLength) {
         this.$ = value;
         this.initialU8aLength = initialU8aLength;

package/cjs/base/Compact.js

@@ -30,6 +30,12 @@ function decodeCompact(registry, Type, value) {
  * a number and making the compact representation thereof
  */
 class Compact {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__Type;
+    __internal__raw;
     constructor(registry, Type, value = 0, { definition, setDefinition = util_1.identity } = {}) {
         this.registry = registry;
         this.__internal__Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));

package/cjs/base/DoNotConstruct.js

@@ -7,6 +7,10 @@ exports.DoNotConstruct = void 0;
  * An unknown type that fails on construction with the type info
  */
 class DoNotConstruct {
+    registry;
+    createdAtHash;
+    isStorageFallback;
+    __internal__neverError;
     constructor(registry, typeName = 'DoNotConstruct') {
         this.registry = registry;
         this.__internal__neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);

package/cjs/base/Enum.js

@@ -50,7 +50,7 @@ function extractDef(registry, _def) {
 }
 function getEntryType(def, checkIdx) {
     const values = Object.values(def);
-    for (let i = 0; i < values.length; i++) {
+    for (let i = 0, count = values.length; i < count; i++) {
         const { Type, index } = values[i];
         if (index === checkIdx) {
             return Type;
@@ -126,6 +126,16 @@ function decodeEnum(registry, def, value, index) {
  * an extension to enum where the value type is determined by the actual index.
  */
 class Enum {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__def;
+    __internal__entryIndex;
+    __internal__indexes;
+    __internal__isBasic;
+    __internal__isIndexed;
+    __internal__raw;
     constructor(registry, Types, value, index, { definition, setDefinition = util_1.identity } = {}) {
         const { def, isBasic, isIndexed } = definition || setDefinition(extractDef(registry, Types));
         // shortcut isU8a as used in SCALE decoding
@@ -144,16 +154,11 @@ class Enum {
         }
     }
     static with(Types) {
-        var _a;
         let definition;
         // eslint-disable-next-line no-return-assign
         const setDefinition = (d) => definition = d;
-        return _a = class extends Enum {
-                constructor(registry, value, index) {
-                    super(registry, Types, value, index, { definition, setDefinition });
-                }
-            },
-            (() => {
+        return class extends Enum {
+            static {
                 const keys = Array.isArray(Types)
                     ? Types
                     : Object.keys(Types);
@@ -165,15 +170,18 @@ class Enum {
                     asKeys[i] = `as${name}`;
                     isKeys[i] = `is${name}`;
                 }
-                (0, util_1.objectProperties)(_a.prototype, isKeys, (_, i, self) => self.type === keys[i]);
-                (0, util_1.objectProperties)(_a.prototype, asKeys, (k, i, self) => {
+                (0, util_1.objectProperties)(this.prototype, isKeys, (_, i, self) => self.type === keys[i]);
+                (0, util_1.objectProperties)(this.prototype, asKeys, (k, i, self) => {
                     if (self.type !== keys[i]) {
                         throw new Error(`Cannot convert '${self.type}' via ${k}`);
                     }
                     return self.value;
                 });
-            })(),
-            _a;
+            }
+            constructor(registry, value, index) {
+                super(registry, Types, value, index, { definition, setDefinition });
+            }
+        };
     }
     /**
      * @description The length of the value when encoded as a Uint8Array

package/cjs/base/Null.js

@@ -8,10 +8,13 @@ const util_1 = require("@polkadot/util");
  * Implements a type that does not contain anything (apart from `null`)
  */
 class Null {
+    encodedLength = 0;
+    isEmpty = true;
+    registry;
+    createdAtHash;
+    initialU8aLength = 0;
+    isStorageFallback;
     constructor(registry) {
-        this.encodedLength = 0;
-        this.isEmpty = true;
-        this.initialU8aLength = 0;
         this.registry = registry;
     }
     /**

package/cjs/base/Option.js

@@ -31,7 +31,7 @@ function decodeOption(registry, Type, value) {
         return new Type(registry, value.value);
     }
     else if ((0, util_1.isNull)(value) || (0, util_1.isUndefined)(value) || value === '0x' || value instanceof None) {
-        // anyhting empty we pass as-is
+        // anything empty we pass as-is
         return new None(registry);
     }
     else if ((0, util_1.isU8a)(value)) {
@@ -52,6 +52,12 @@ function decodeOption(registry, Type, value) {
  * with a value if/as required/found.
  */
 class Option {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__Type;
+    __internal__raw;
     constructor(registry, typeName, value, { definition, setDefinition = util_1.identity } = {}) {
         const Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, typeName));
         const decoded = (0, util_1.isU8a)(value) && value.length && !(0, util_1.isCodec)(value)

package/cjs/base/Tuple.js

@@ -40,6 +40,7 @@ function decodeTuple(registry, result, value, Classes) {
  * own type. It extends the base JS `Array` object.
  */
 class Tuple extends Array_js_1.AbstractArray {
+    __internal__Types;
     constructor(registry, Types, value, { definition, setDefinition = util_1.identity } = {}) {
         const Classes = definition || setDefinition(Array.isArray(Types)
             ? [(0, index_js_1.typesToConstructors)(registry, Types), []]

package/cjs/base/Vec.js

@@ -57,6 +57,7 @@ exports.decodeVec = decodeVec;
  * specific encoding/decoding on top of the base type.
  */
 class Vec extends Array_js_1.AbstractArray {
+    __internal__Type;
     constructor(registry, Type, value = [], { definition, setDefinition = util_1.identity } = {}) {
         const [decodeFrom, length, startAt] = decodeVecLength(value);
         super(registry, length);

package/cjs/base/VecFixed.js

@@ -11,6 +11,7 @@ const Vec_js_1 = require("./Vec.js");
  * This manages codec arrays of a fixed length
  */
 class VecFixed extends Array_js_1.AbstractArray {
+    __internal__Type;
     constructor(registry, Type, length, value = [], { definition, setDefinition = util_1.identity } = {}) {
         super(registry, length);
         this.__internal__Type = definition || setDefinition((0, index_js_1.typeToConstructor)(registry, Type));

package/cjs/extended/BTreeSet.js

@@ -57,6 +57,11 @@ function decodeSet(registry, valType, value) {
     throw new Error('BTreeSet: cannot decode type');
 }
 class BTreeSet extends Set {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__ValClass;
     constructor(registry, valType, rawValue) {
         const [ValClass, values, decodedLength] = decodeSet(registry, valType, rawValue);
         super((0, index_js_1.sortSet)(values));

package/cjs/extended/BitVec.js

@@ -5,7 +5,7 @@ const util_1 = require("@polkadot/util");
 const Raw_js_1 = require("../native/Raw.js");
 /** @internal */
 function decodeBitVecU8a(value) {
-    if (!value || !value.length) {
+    if (!value?.length) {
         return [0, new Uint8Array()];
     }
     // handle all other Uint8Array inputs, these do have a length prefix which is the number of bits encoded
@@ -31,6 +31,8 @@ function decodeBitVec(value) {
  * and a normal Bytes would be that the length prefix indicates the number of bits encoded, not the bytes
  */
 class BitVec extends Raw_js_1.Raw {
+    __internal__decodedLength;
+    __internal__isMsb;
     // In lieu of having the Msb/Lsb identifiers passed through, we default to assuming
     // we are dealing with Lsb, which is the default (as of writing) BitVec format used
     // in the Polkadot code (this only affects the toHuman displays)

package/cjs/extended/Map.js

@@ -76,6 +76,13 @@ function decodeMap(registry, keyType, valType, value) {
     throw new Error('Map: cannot decode type');
 }
 class CodecMap extends Map {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__KeyClass;
+    __internal__ValClass;
+    __internal__type;
     constructor(registry, keyType, valType, rawValue, type = 'HashMap') {
         const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
         super(type === 'BTreeMap' ? (0, index_js_1.sortMap)(decoded) : decoded);

package/cjs/extended/OptionBool.js

@@ -28,7 +28,7 @@ class OptionBool extends Option_js_1.Option {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        return 1;
+        return 1 | 0;
     }
     /**
      * @description Checks if the value is an empty value (always false)

package/cjs/extended/Range.js

@@ -8,6 +8,7 @@ const Tuple_js_1 = require("../base/Tuple.js");
  * Rust `Range<T>` representation
  */
 class Range extends Tuple_js_1.Tuple {
+    __internal__rangeName;
     constructor(registry, Type, value, { rangeName = 'Range' } = {}) {
         super(registry, [Type, Type], value);
         this.__internal__rangeName = rangeName;

package/cjs/extended/WrapperKeepOpaque.js

@@ -24,6 +24,9 @@ function decodeRaw(registry, typeName, value) {
     return [Type, instance, (0, util_1.compactAddLength)(instance.toU8a())];
 }
 class WrapperKeepOpaque extends Bytes_js_1.Bytes {
+    __internal__Type;
+    __internal__decoded;
+    __internal__opaqueName;
     constructor(registry, typeName, value, { opaqueName = 'WrapperKeepOpaque' } = {}) {
         const [Type, decoded, u8a] = decodeRaw(registry, typeName, value);
         super(registry, u8a);

package/cjs/native/Bool.js

@@ -9,20 +9,23 @@ const util_1 = require("@polkadot/util");
  * @noInheritDoc
  */
 class bool extends Boolean {
+    registry;
+    createdAtHash;
+    initialU8aLength = 1;
+    isStorageFallback;
     constructor(registry, value = false) {
         super((0, util_1.isU8a)(value)
             ? value[0] === 1
             : value instanceof Boolean
                 ? value.valueOf()
                 : !!value);
-        this.initialU8aLength = 1;
         this.registry = registry;
     }
     /**
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        return 1;
+        return 1 | 0;
     }
     /**
      * @description returns a hash of the contents

package/cjs/native/Date.js

@@ -27,9 +27,12 @@ function decodeDate(value) {
  * @noInheritDoc
  */
 class CodecDate extends Date {
+    registry;
+    createdAtHash;
+    initialU8aLength = BITLENGTH / 8;
+    isStorageFallback;
     constructor(registry, value = 0) {
         super(decodeDate(value));
-        this.initialU8aLength = BITLENGTH / 8;
         this.registry = registry;
     }
     /**

package/cjs/native/Float.js

@@ -11,6 +11,12 @@ const util_1 = require("@polkadot/util");
  * in some eth_* RPCs
  */
 class Float extends Number {
+    encodedLength;
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__bitLength;
     constructor(registry, value, { bitLength = 32 } = {}) {
         super((0, util_1.isU8a)(value) || (0, util_1.isHex)(value)
             ? value.length === 0

package/cjs/native/Json.js

@@ -16,6 +16,10 @@ function decodeJson(value) {
  * @noInheritDoc
  */
 class Json extends Map {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
     constructor(registry, value) {
         const decoded = decodeJson(value);
         super(decoded);
@@ -26,7 +30,7 @@ class Json extends Map {
      * @description Always 0, never encodes as a Uint8Array
      */
     get encodedLength() {
-        return 0;
+        return 0 | 0;
     }
     /**
      * @description returns a hash of the contents

package/cjs/native/Raw.js

@@ -12,6 +12,10 @@ const util_1 = require("@polkadot/util");
  * @noInheritDoc
  */
 class Raw extends Uint8Array {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
     /**
      * @description This ensures that operators such as clice, filter, map, etc. return
      * new Array instances (without this we need to apply overrides)