@polkadot/types-codec 10.10.1 → 10.11.2

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.js

@@ -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.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

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

@@ -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/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,13 +9,16 @@ 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;
     }
     /**

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);

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)

package/cjs/native/Set.js

@@ -69,42 +69,33 @@ function decodeSet(setValues, value = 0, bitLength) {
  * a bitwise representation of the values.
  */
 class CodecSet extends Set {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__allowed;
+    __internal__byteLength;
     constructor(registry, setValues, value, bitLength = 8) {
         super(decodeSet(setValues, value, bitLength));
-        /**
-         * @description adds a value to the Set (extended to allow for validity checking)
-         */
-        this.add = (key) => {
-            // ^^^ add = () property done to assign this instance's this, otherwise Set.add creates "some" chaos
-            // we have the isUndefined(this._setValues) in here as well, add is used internally
-            // in the Set constructor (so it is undefined at this point, and should allow)
-            if (this.__internal__allowed && (0, util_1.isUndefined)(this.__internal__allowed[key])) {
-                throw new Error(`Set: Invalid key '${key}' on add`);
-            }
-            super.add(key);
-            return this;
-        };
         this.registry = registry;
         this.__internal__allowed = setValues;
         this.__internal__byteLength = bitLength / 8;
     }
     static with(values, bitLength) {
-        var _a;
-        return _a = class extends CodecSet {
-                constructor(registry, value) {
-                    super(registry, values, value, bitLength);
-                }
-            },
-            (() => {
+        return class extends CodecSet {
+            static {
                 const keys = Object.keys(values);
                 const count = keys.length;
                 const isKeys = new Array(count);
                 for (let i = 0; i < count; i++) {
                     isKeys[i] = `is${(0, util_1.stringPascalCase)(keys[i])}`;
                 }
-                (0, util_1.objectProperties)(_a.prototype, isKeys, (_, i, self) => self.strings.includes(keys[i]));
-            })(),
-            _a;
+                (0, util_1.objectProperties)(this.prototype, isKeys, (_, i, self) => self.strings.includes(keys[i]));
+            }
+            constructor(registry, value) {
+                super(registry, values, value, bitLength);
+            }
+        };
     }
     /**
      * @description The length of the value when encoded as a Uint8Array
@@ -136,6 +127,19 @@ class CodecSet extends Set {
     get valueEncoded() {
         return encodeSet(this.__internal__allowed, this.strings);
     }
+    /**
+     * @description adds a value to the Set (extended to allow for validity checking)
+     */
+    add = (key) => {
+        // ^^^ add = () property done to assign this instance's this, otherwise Set.add creates "some" chaos
+        // we have the isUndefined(this._setValues) in here as well, add is used internally
+        // in the Set constructor (so it is undefined at this point, and should allow)
+        if (this.__internal__allowed && (0, util_1.isUndefined)(this.__internal__allowed[key])) {
+            throw new Error(`Set: Invalid key '${key}' on add`);
+        }
+        super.add(key);
+        return this;
+    };
     /**
      * @description Compares the value of the input to see if there is a match
      */

package/cjs/native/Struct.js

@@ -75,6 +75,12 @@ function decodeStructFromObject(registry, [Types, keys], value, jsonMap) {
  * @noInheritDoc
  */
 class Struct extends Map {
+    registry;
+    createdAtHash;
+    initialU8aLength;
+    isStorageFallback;
+    __internal__jsonMap;
+    __internal__Types;
     constructor(registry, Types, value, jsonMap = new Map(), { definition, setDefinition = noopSetDefinition } = {}) {
         const typeMap = definition || setDefinition((0, index_js_1.mapToTypeMap)(registry, Types));
         const [decoded, decodedLength] = (0, util_1.isU8a)(value) || (0, util_1.isHex)(value)
@@ -89,20 +95,18 @@ class Struct extends Map {
         this.__internal__Types = typeMap;
     }
     static with(Types, jsonMap) {
-        var _a;
         let definition;
         // eslint-disable-next-line no-return-assign
         const setDefinition = (d) => definition = d;
-        return _a = class extends Struct {
-                constructor(registry, value) {
-                    super(registry, Types, value, jsonMap, { definition, setDefinition });
-                }
-            },
-            (() => {
+        return class extends Struct {
+            static {
                 const keys = Object.keys(Types);
-                (0, util_1.objectProperties)(_a.prototype, keys, (k, _, self) => self.get(k));
-            })(),
-            _a;
+                (0, util_1.objectProperties)(this.prototype, keys, (k, _, self) => self.get(k));
+            }
+            constructor(registry, value) {
+                super(registry, Types, value, jsonMap, { definition, setDefinition });
+            }
+        };
     }
     /**
      * @description The available keys for this struct