@polkadot/types-codec 9.5.2 → 9.6.2

package/cjs/abstract/Int.js

@@ -4,31 +4,28 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DEFAULT_UINT_BITS = exports.AbstractInt = void 0;
-
 var _util = require("@polkadot/util");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-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
 
+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
 exports.DEFAULT_UINT_BITS = DEFAULT_UINT_BITS;
 const MAX_NUMBER_BITS = 52;
 const MUL_P = new _util.BN(10000);
 const FORMATTERS = [['Perquintill', _util.BN_QUINTILL], ['Perbill', _util.BN_BILLION], ['Permill', _util.BN_MILLION], ['Percent', _util.BN_HUNDRED]];
-
 function toPercentage(value, divisor) {
   return `${(value.mul(MUL_P).div(divisor).toNumber() / 100).toFixed(2)}%`;
 }
-/** @internal */
-
 
+/** @internal */
 function decodeAbstractInt(value, isNegative) {
   if ((0, _util.isNumber)(value)) {
     if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
       throw new Error('Number needs to be an integer <= Number.MAX_SAFE_INTEGER, i.e. 2 ^ 53 - 1');
     }
-
     return value;
   } else if ((0, _util.isString)(value)) {
     if ((0, _util.isHex)(value, -1, true)) {
@@ -37,11 +34,9 @@ function decodeAbstractInt(value, isNegative) {
         isNegative
       }).toString();
     }
-
     if (value.includes('.') || value.includes(',') || value.includes('e')) {
       throw new Error('String should not contain decimal points or scientific notation');
     }
-
     return value;
   } else if ((0, _util.isBn)(value)) {
     return value.toString();
@@ -50,32 +45,25 @@ function decodeAbstractInt(value, isNegative) {
     // single key objects can be treated equivalently to numbers, assuming they meet the
     // specific requirements. (This is useful in Weights 1.5 where Objects are compact)
     const keys = Object.keys(value);
-
     if (keys.length !== 1) {
       throw new Error('Unable to construct number from multi-key object');
     }
-
     const inner = value[keys[0]];
-
     if (!(0, _util.isString)(inner) && !(0, _util.isNumber)(inner)) {
       throw new Error('Unable to construct from object with non-string/non-number value');
     }
-
     return decodeAbstractInt(inner, isNegative);
   }
-
   return (0, _util.bnToBn)(value).toString();
 }
+
 /**
  * @name AbstractInt
  * @ignore
  * @noInheritDoc
  */
-
-
 class AbstractInt extends _util.BN {
   #bitLength;
-
   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;
@@ -83,7 +71,8 @@ class AbstractInt extends _util.BN {
     // 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
+    super(
+    // shortcut isU8a as used in SCALE decoding
     (0, _util.isU8a)(value) ? bitLength <= 48 ? (0, _util.u8aToNumber)(value.subarray(0, bitLength / 8), {
       isNegative: isSigned
     }) : (0, _util.u8aToBn)(value.subarray(0, bitLength / 8), {
@@ -96,43 +85,38 @@ class AbstractInt extends _util.BN {
     this.isUnsigned = !isSigned;
     const isNegative = this.isNeg();
     const maxBits = bitLength - (isSigned && !isNegative ? 1 : 0);
-
     if (isNegative && !isSigned) {
       throw new Error(`${this.toRawType()}: Negative number passed to unsigned type`);
     } else if (super.bitLength() > maxBits) {
       throw new Error(`${this.toRawType()}: Input too large. Found input with ${super.bitLength()} bits, expected ${maxBits}`);
     }
   }
+
   /**
    * @description returns a hash of the contents
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
   /**
    * @description Checks if the value is a zero value (align elsewhere)
    */
-
-
   get isEmpty() {
     return this.isZero();
   }
+
   /**
    * @description Returns the number of bits in the value
    */
-
-
   bitLength() {
     return this.#bitLength;
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-
   eq(other) {
     // Here we are actually overriding the built-in .eq to take care of both
     // number and BN inputs (no `.eqn` needed) - numbers will be converted
@@ -141,46 +125,41 @@ class AbstractInt extends _util.BN {
       isNegative: !this.isUnsigned
     }) : (0, _util.bnToBn)(other));
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       outer: [this.toU8a()]
     };
   }
+
   /**
    * @description True if this value is the max of the type
    */
-
-
   isMax() {
     const u8a = this.toU8a().filter(b => b === 0xff);
     return u8a.length === this.#bitLength / 8;
   }
+
   /**
    * @description Returns a BigInt representation of the number
    */
-
-
   toBigInt() {
     return BigInt(this.toString());
   }
+
   /**
    * @description Returns the BN representation of the number. (Compatibility)
    */
-
-
   toBn() {
     return this;
   }
+
   /**
    * @description Returns a hex string representation of the value
    */
-
-
   toHex() {
     let isLe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     // For display/JSON, this is BE, for compare, use isLe
@@ -190,17 +169,16 @@ class AbstractInt extends _util.BN {
       isNegative: !this.isUnsigned
     });
   }
+
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-
   toHuman(isExpanded) {
     const rawType = this.toRawType();
-
     if (rawType === 'Balance') {
-      return this.isMax() ? 'everything' // FIXME In the case of multiples we need some way of detecting which instance this belongs
+      return this.isMax() ? 'everything'
+      // FIXME In the case of multiples we need some way of detecting which instance this belongs
       // to. as it stands we will always format (incorrectly) against the first token defined
       : (0, _util.formatBalance)(this, {
         decimals: this.registry.chainDecimals[0],
@@ -208,18 +186,16 @@ class AbstractInt extends _util.BN {
         withUnit: this.registry.chainTokens[0]
       });
     }
-
     const [, divisor] = FORMATTERS.find(_ref => {
       let [type] = _ref;
       return type === rawType;
     }) || [];
     return divisor ? toPercentage(this, divisor) : (0, _util.formatNumber)(this);
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     let onlyHex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     // FIXME this return type should by string | number, however BN returns string
@@ -228,42 +204,38 @@ class AbstractInt extends _util.BN {
     //   - this.#bitLength - the type bits (this should be used, however contracts RPC is problematic)
     return onlyHex || super.bitLength() > MAX_NUMBER_BITS ? this.toHex() : this.toNumber();
   }
+
   /**
    * @description Returns the value in a primitive form, either number when <= 52 bits, or string otherwise
    */
-
-
   toPrimitive() {
     return super.bitLength() > MAX_NUMBER_BITS ? this.toString() : this.toNumber();
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     // NOTE In the case of balances, which have a special meaning on the UI
     // and can be interpreted differently, return a specific value for it so
     // underlying it always matches (no matter which length it actually is)
     return this instanceof this.registry.createClassUnsafe('Balance') ? 'Balance' : `${this.isUnsigned ? 'u' : 'i'}${this.bitLength()}`;
   }
+
   /**
    * @description Returns the string representation of the value
    * @param base The base to use for the conversion
    */
-
-
   toString(base) {
     // only included here since we do not inherit docs
     return super.toString(base);
   }
+
   /**
    * @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)
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-
   toU8a(isBare) {
     return (0, _util.bnToU8a)(this, {
       bitLength: this.bitLength(),
@@ -271,7 +243,5 @@ class AbstractInt extends _util.BN {
       isNegative: !this.isUnsigned
     });
   }
-
 }
-
 exports.AbstractInt = AbstractInt;

package/cjs/abstract/index.js

@@ -21,9 +21,6 @@ Object.defineProperty(exports, "AbstractInt", {
     return _Int.AbstractInt;
   }
 });
-
 var _Array = require("./Array");
-
 var _Base = require("./Base");
-
 var _Int = require("./Int");

package/cjs/base/Compact.js

@@ -4,17 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Compact = void 0;
-
 var _util = require("@polkadot/util");
-
 var _utils = require("../utils");
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 function noopSetDefinition(d) {
   return d;
 }
-
 function decodeCompact(registry, Type, value) {
   if ((0, _util.isU8a)(value)) {
     const [decodedLength, bn] = (value[0] & 0b11) < 0b11 ? (0, _util.compactFromU8aLim)(value) : (0, _util.compactFromU8a)(value);
@@ -25,9 +22,9 @@ function decodeCompact(registry, Type, value) {
   } else if (value instanceof Type) {
     return [value, 0];
   }
-
   return [new Type(registry, value), 0];
 }
+
 /**
  * @name Compact
  * @description
@@ -36,12 +33,9 @@ function decodeCompact(registry, Type, value) {
  * used by other types to add length-prefixed encoding, or in the case of wrapped types, taking
  * a number and making the compact representation thereof
  */
-
-
 class Compact {
   #Type;
   #raw;
-
   constructor(registry, Type) {
     let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
     let {
@@ -54,12 +48,11 @@ class Compact {
     this.initialU8aLength = decodedLength;
     this.#raw = raw;
   }
-
   static with(Type) {
-    let definition; // eslint-disable-next-line no-return-assign
+    let definition;
 
+    // eslint-disable-next-line no-return-assign
     const setDefinition = d => definition = d;
-
     return class extends Compact {
       constructor(registry, value) {
         super(registry, Type, value, {
@@ -67,150 +60,130 @@ class Compact {
           setDefinition
         });
       }
-
     };
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     return this.toU8a().length;
   }
+
   /**
    * @description returns a hash of the contents
    */
-
-
   get hash() {
     return this.registry.hash(this.toU8a());
   }
+
   /**
    * @description Checks if the value is an empty value
    */
-
-
   get isEmpty() {
     return this.#raw.isEmpty;
   }
+
   /**
    * @description Returns the number of bits in the value
    */
-
-
   bitLength() {
     return this.#raw.bitLength();
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return this.#raw.eq(other instanceof Compact ? other.#raw : other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       outer: [this.toU8a()]
     };
   }
+
   /**
    * @description Returns a BigInt representation of the number
    */
-
-
   toBigInt() {
     return this.#raw.toBigInt();
   }
+
   /**
    * @description Returns the BN representation of the number
    */
-
-
   toBn() {
     return this.#raw.toBn();
   }
+
   /**
    * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
    */
-
-
   toHex(isLe) {
     return this.#raw.toHex(isLe);
   }
+
   /**
    * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
    */
-
-
   toHuman(isExtended) {
     return this.#raw.toHuman(isExtended);
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON() {
     return this.#raw.toJSON();
   }
+
   /**
    * @description Returns the number representation for the value
    */
-
-
   toNumber() {
     return this.#raw.toNumber();
   }
+
   /**
    * @description Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     return this.#raw.toPrimitive();
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return `Compact<${this.registry.getClassName(this.#Type) || this.#raw.toRawType()}>`;
   }
+
   /**
    * @description Returns the string representation of the value
    */
-
-
   toString() {
     return this.#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)
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-
   toU8a(isBare) {
     return (0, _util.compactToU8a)(this.#raw.toBn());
   }
+
   /**
    * @description Returns the embedded [[UInt]] or [[Moment]] value
    */
-
-
   unwrap() {
     return this.#raw;
   }
-
 }
-
 exports.Compact = Compact;

package/cjs/base/DoNotConstruct.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.DoNotConstruct = void 0;
-
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -15,83 +14,66 @@ exports.DoNotConstruct = void 0;
  */
 class DoNotConstruct {
   #neverError;
-
   constructor(registry) {
     let typeName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'DoNotConstruct';
     this.registry = registry;
     this.#neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
     throw this.#neverError;
   }
-
   static with(typeName) {
     return class extends DoNotConstruct {
       constructor(registry) {
         super(registry, typeName);
       }
-
     };
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   get encodedLength() {
     throw this.#neverError;
   }
+
   /**
    * @description returns a hash of the contents
    */
-
-
   get hash() {
     throw this.#neverError;
   }
+
   /**
    * @description Checks if the value is an empty value (always true)
    */
-
-
   get isEmpty() {
     throw this.#neverError;
   }
-
   eq() {
     throw this.#neverError;
   }
-
   inspect() {
     throw this.#neverError;
   }
-
   toHex() {
     throw this.#neverError;
   }
-
   toHuman() {
     throw this.#neverError;
   }
-
   toJSON() {
     throw this.#neverError;
   }
-
   toPrimitive() {
     throw this.#neverError;
   }
-
   toRawType() {
     throw this.#neverError;
   }
-
   toString() {
     throw this.#neverError;
   }
-
   toU8a() {
     throw this.#neverError;
   }
-
 }
-
 exports.DoNotConstruct = DoNotConstruct;