@polkadot/types-codec 10.3.4 → 10.5.1

package/abstract/Array.js

@@ -25,8 +25,9 @@ export class AbstractArray extends Array {
     get encodedLength() {
         // We need to loop through all entries since they may have a variable length themselves,
         // e.g. when a Vec or Compact is contained withing, it has a variable length based on data
-        let total = compactToU8a(this.length).length;
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        let total = compactToU8a(count).length;
+        for (let i = 0; i < count; i++) {
             total += this[i].encodedLength;
         }
         return total;
@@ -70,8 +71,9 @@ export class AbstractArray extends Array {
      * @description Internal per-item inspection of internal values
      */
     inspectInner() {
-        const inner = new Array(this.length);
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        const inner = new Array(count);
+        for (let i = 0; i < count; i++) {
             inner[i] = this[i].inspect();
         }
         return inner;
@@ -92,8 +94,9 @@ export class AbstractArray extends Array {
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended) {
-        const result = new Array(this.length);
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
             result[i] = this[i] && this[i].toHuman(isExtended);
         }
         return result;
@@ -102,8 +105,9 @@ export class AbstractArray extends Array {
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        const result = new Array(this.length);
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
             // We actually log inside the U8a decoding and use JSON.stringify(...), which
             // means that the Vec may be partially populated (same applies to toHuman, same check)
             result[i] = this[i] && this[i].toJSON();
@@ -114,8 +118,9 @@ export class AbstractArray extends Array {
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        const result = new Array(this.length);
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
             result[i] = this[i] && this[i].toPrimitive();
         }
         return result;
@@ -124,8 +129,9 @@ export class AbstractArray extends Array {
      * @description Returns the string representation of the value
      */
     toString() {
-        const result = new Array(this.length);
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        const result = new Array(count);
+        for (let i = 0; i < count; i++) {
             result[i] = this[i].toString();
         }
         return `[${result.join(', ')}]`;
@@ -146,8 +152,9 @@ export class AbstractArray extends Array {
      * @param isBare true when the value has none of the type-specific prefixes (internal)
      */
     toU8aInner(isBare) {
-        const encoded = new Array(this.length);
-        for (let i = 0; i < this.length; i++) {
+        const count = this.length;
+        const encoded = new Array(count);
+        for (let i = 0; i < count; i++) {
             encoded[i] = this[i].toU8a(isBare);
         }
         return encoded;

package/abstract/Base.js

@@ -1,14 +1,11 @@
-var _AbstractBase_raw;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 /**
  * @name Base
  * @description A type extends the Base class, when it holds a value
  */
 export class AbstractBase {
     constructor(registry, value, initialU8aLength) {
-        _AbstractBase_raw.set(this, void 0);
         this.initialU8aLength = initialU8aLength;
-        __classPrivateFieldSet(this, _AbstractBase_raw, value, "f");
+        this.__internal__raw = value;
         this.registry = registry;
     }
     /**
@@ -27,74 +24,73 @@ export class AbstractBase {
      * @description returns the inner (wrapped value)
      */
     get inner() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f");
+        return this.__internal__raw;
     }
     /**
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").isEmpty;
+        return this.__internal__raw.isEmpty;
     }
     /**
      * @description Compares the value of the input to see if there is a match
      */
     eq(other) {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").eq(other);
+        return this.__internal__raw.eq(other);
     }
     /**
      * @description Returns a breakdown of the hex encoding for this Codec
      */
     inspect() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").inspect();
+        return this.__internal__raw.inspect();
     }
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */
     toHex(isLe) {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toHex(isLe);
+        return this.__internal__raw.toHex(isLe);
     }
     /**
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended) {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toHuman(isExtended);
+        return this.__internal__raw.toHuman(isExtended);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toJSON();
+        return this.__internal__raw.toJSON();
     }
     /**
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toPrimitive();
+        return this.__internal__raw.toPrimitive();
     }
     /**
      * @description Returns the string representation of the value
      */
     toString() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toString();
+        return this.__internal__raw.toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
      * @param isBare true when the value has none of the type-specific prefixes (internal)
      */
     toU8a(isBare) {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f").toU8a(isBare);
+        return this.__internal__raw.toU8a(isBare);
     }
     /**
      * @description Returns the inner wrapped value (equivalent to valueOf)
      */
     unwrap() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f");
+        return this.__internal__raw;
     }
     /**
      * @description Returns the inner wrapped value
      */
     valueOf() {
-        return __classPrivateFieldGet(this, _AbstractBase_raw, "f");
+        return this.__internal__raw;
     }
 }
-_AbstractBase_raw = new WeakMap();

package/abstract/Int.js

@@ -1,5 +1,3 @@
-var _AbstractInt_bitLength;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBigInt, isBn, isFunction, isHex, isNumber, isObject, isString, isU8a, u8aToBn, u8aToNumber } from '@polkadot/util';
 export const DEFAULT_UINT_BITS = 64;
 const MAX_NUMBER_BITS = 52;
@@ -71,11 +69,10 @@ export class AbstractInt extends BN {
                 ? u8aToNumber(value.subarray(0, bitLength / 8), { isNegative: isSigned })
                 : u8aToBn(value.subarray(0, bitLength / 8), { isLe: true, isNegative: isSigned }).toString()
             : decodeAbstractInt(value, isSigned));
-        _AbstractInt_bitLength.set(this, void 0);
         this.registry = registry;
-        __classPrivateFieldSet(this, _AbstractInt_bitLength, bitLength, "f");
-        this.encodedLength = __classPrivateFieldGet(this, _AbstractInt_bitLength, "f") / 8;
-        this.initialU8aLength = __classPrivateFieldGet(this, _AbstractInt_bitLength, "f") / 8;
+        this.__internal__bitLength = bitLength;
+        this.encodedLength = this.__internal__bitLength / 8;
+        this.initialU8aLength = this.__internal__bitLength / 8;
         this.isUnsigned = !isSigned;
         const isNegative = this.isNeg();
         const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
@@ -102,7 +99,7 @@ export class AbstractInt extends BN {
      * @description Returns the number of bits in the value
      */
     bitLength() {
-        return __classPrivateFieldGet(this, _AbstractInt_bitLength, "f");
+        return this.__internal__bitLength;
     }
     /**
      * @description Compares the value of the input to see if there is a match
@@ -128,7 +125,7 @@ export class AbstractInt extends BN {
      */
     isMax() {
         const u8a = this.toU8a().filter((b) => b === 0xff);
-        return u8a.length === (__classPrivateFieldGet(this, _AbstractInt_bitLength, "f") / 8);
+        return u8a.length === (this.__internal__bitLength / 8);
     }
     /**
      * @description Returns a BigInt representation of the number
@@ -176,9 +173,9 @@ export class AbstractInt extends BN {
     toJSON(onlyHex = false) {
         // FIXME this return type should by string | number, however BN returns string
         // Options here are
-        //   - super.bitLength() - the actual used bits
-        //   - this.#bitLength - the type bits (this should be used, however contracts RPC is problematic)
-        return onlyHex || (super.bitLength() > MAX_NUMBER_BITS)
+        //   - super.bitLength() - the actual used bits, use hex when close to MAX_SAFE_INTEGER
+        //   - this.__internal__bitLength - the max used bits, use hex when larger than native Rust type
+        return onlyHex || (this.__internal__bitLength > 128) || (super.bitLength() > MAX_NUMBER_BITS)
             ? this.toHex()
             : this.toNumber();
     }
@@ -220,4 +217,3 @@ export class AbstractInt extends BN {
         });
     }
 }
-_AbstractInt_bitLength = new WeakMap();

package/base/Compact.js

@@ -1,10 +1,5 @@
-var _Compact_Type, _Compact_raw;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
-import { compactFromU8a, compactFromU8aLim, compactToU8a, isU8a } from '@polkadot/util';
+import { compactFromU8a, compactFromU8aLim, compactToU8a, identity, isU8a } from '@polkadot/util';
 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
@@ -32,14 +27,12 @@ function decodeCompact(registry, Type, value) {
  * a number and making the compact representation thereof
  */
 export class Compact {
-    constructor(registry, Type, value = 0, { definition, setDefinition = noopSetDefinition } = {}) {
-        _Compact_Type.set(this, void 0);
-        _Compact_raw.set(this, void 0);
+    constructor(registry, Type, value = 0, { definition, setDefinition = identity } = {}) {
         this.registry = registry;
-        __classPrivateFieldSet(this, _Compact_Type, definition || setDefinition(typeToConstructor(registry, Type)), "f");
-        const [raw, decodedLength] = decodeCompact(registry, __classPrivateFieldGet(this, _Compact_Type, "f"), value);
+        this.__internal__Type = definition || setDefinition(typeToConstructor(registry, Type));
+        const [raw, decodedLength] = decodeCompact(registry, this.__internal__Type, value);
         this.initialU8aLength = decodedLength;
-        __classPrivateFieldSet(this, _Compact_raw, raw, "f");
+        this.__internal__raw = raw;
     }
     static with(Type) {
         let definition;
@@ -67,20 +60,20 @@ export class Compact {
      * @description Checks if the value is an empty value
      */
     get isEmpty() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").isEmpty;
+        return this.__internal__raw.isEmpty;
     }
     /**
      * @description Returns the number of bits in the value
      */
     bitLength() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").bitLength();
+        return this.__internal__raw.bitLength();
     }
     /**
      * @description Compares the value of the input to see if there is a match
      */
     eq(other) {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").eq(other instanceof Compact
-            ? __classPrivateFieldGet(other, _Compact_raw, "f")
+        return this.__internal__raw.eq(other instanceof Compact
+            ? other.__internal__raw
             : other);
     }
     /**
@@ -95,67 +88,66 @@ export class Compact {
      * @description Returns a BigInt representation of the number
      */
     toBigInt() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toBigInt();
+        return this.__internal__raw.toBigInt();
     }
     /**
      * @description Returns the BN representation of the number
      */
     toBn() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toBn();
+        return this.__internal__raw.toBn();
     }
     /**
      * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
      */
     toHex(isLe) {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toHex(isLe);
+        return this.__internal__raw.toHex(isLe);
     }
     /**
      * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
      */
     toHuman(isExtended) {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toHuman(isExtended);
+        return this.__internal__raw.toHuman(isExtended);
     }
     /**
      * @description Converts the Object to JSON, typically used for RPC transfers
      */
     toJSON() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toJSON();
+        return this.__internal__raw.toJSON();
     }
     /**
      * @description Returns the number representation for the value
      */
     toNumber() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toNumber();
+        return this.__internal__raw.toNumber();
     }
     /**
      * @description Converts the value in a best-fit primitive form
      */
     toPrimitive() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toPrimitive();
+        return this.__internal__raw.toPrimitive();
     }
     /**
      * @description Returns the base runtime type name for this instance
      */
     toRawType() {
-        return `Compact<${this.registry.getClassName(__classPrivateFieldGet(this, _Compact_Type, "f")) || __classPrivateFieldGet(this, _Compact_raw, "f").toRawType()}>`;
+        return `Compact<${this.registry.getClassName(this.__internal__Type) || this.__internal__raw.toRawType()}>`;
     }
     /**
      * @description Returns the string representation of the value
      */
     toString() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f").toString();
+        return this.__internal__raw.toString();
     }
     /**
      * @description Encodes the value as a Uint8Array as per the SCALE specifications
      */
     toU8a(_isBare) {
-        return compactToU8a(__classPrivateFieldGet(this, _Compact_raw, "f").toBn());
+        return compactToU8a(this.__internal__raw.toBn());
     }
     /**
      * @description Returns the embedded [[UInt]] or [[Moment]] value
      */
     unwrap() {
-        return __classPrivateFieldGet(this, _Compact_raw, "f");
+        return this.__internal__raw;
     }
 }
-_Compact_Type = new WeakMap(), _Compact_raw = new WeakMap();

package/base/DoNotConstruct.js

@@ -1,5 +1,3 @@
-var _DoNotConstruct_neverError;
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 /**
  * @name DoNotConstruct
  * @description
@@ -7,10 +5,9 @@ import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
  */
 export class DoNotConstruct {
     constructor(registry, typeName = 'DoNotConstruct') {
-        _DoNotConstruct_neverError.set(this, void 0);
         this.registry = registry;
-        __classPrivateFieldSet(this, _DoNotConstruct_neverError, new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`), "f");
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        this.__internal__neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
+        throw this.__internal__neverError;
     }
     static with(typeName) {
         return class extends DoNotConstruct {
@@ -23,73 +20,72 @@ export class DoNotConstruct {
      * @description The length of the value when encoded as a Uint8Array
      */
     get encodedLength() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description returns a hash of the contents
      */
     get hash() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Checks if the value is an empty value (always true)
      */
     get isEmpty() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     eq() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     inspect() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toHex() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toHuman() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toJSON() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toPrimitive() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toRawType() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toString() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
     /**
      * @description Unimplemented
      */
     toU8a() {
-        throw __classPrivateFieldGet(this, _DoNotConstruct_neverError, "f");
+        throw this.__internal__neverError;
     }
 }
-_DoNotConstruct_neverError = new WeakMap();