@polkadot/types-codec 9.5.2 → 9.6.2

package/abstract/Array.js

@@ -1,7 +1,9 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { compactToU8a, u8aConcatStrict, u8aToHex } from '@polkadot/util';
 import { compareArray } from "../utils/compareArray.js";
+
 /**
  * @name AbstractArray
  * @description
@@ -9,7 +11,6 @@ import { compareArray } from "../utils/compareArray.js";
  * specific encoding/decoding on top of the base type.
  * @noInheritDoc
  */
-
 export class AbstractArray extends Array {
   /**
    * @description This ensures that operators such as clice, filter, map, etc. return
@@ -18,177 +19,147 @@ export class AbstractArray extends Array {
   static get [Symbol.species]() {
     return Array;
   }
-
   constructor(registry, length) {
     super(length);
     this.registry = registry;
   }
+
   /**
    * @description The length of the value when encoded as a Uint8Array
    */
-
-
   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++) {
       total += this[i].encodedLength;
     }
-
     return total;
   }
+
   /**
    * @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.length === 0;
   }
+
   /**
    * @description The length of the value
    */
-
-
   get length() {
     // only included here since we ignore inherited docs
     return super.length;
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return compareArray(this, other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return {
       inner: this.inspectInner(),
       outer: [compactToU8a(this.length)]
     };
   }
-
   inspectInner() {
     const inner = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       inner[i] = this[i].inspect();
     }
-
     return inner;
   }
+
   /**
    * @description Converts the Object to an standard JavaScript Array
    */
-
-
   toArray() {
     return Array.from(this);
   }
+
   /**
    * @description Returns a hex string representation of the value
    */
-
-
   toHex() {
     return u8aToHex(this.toU8a());
   }
+
   /**
    * @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++) {
       result[i] = this[i] && this[i].toHuman(isExtended);
     }
-
     return result;
   }
+
   /**
    * @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++) {
       // 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();
     }
-
     return result;
   }
+
   /**
    * @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++) {
       result[i] = this[i] && this[i].toPrimitive();
     }
-
     return result;
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
 
-
   /**
    * @description Returns the string representation of the value
    */
   toString() {
     const result = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       result[i] = this[i].toString();
     }
-
     return `[${result.join(', ')}]`;
   }
+
   /**
    * @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) {
     const encoded = this.toU8aInner();
     return isBare ? u8aConcatStrict(encoded) : u8aConcatStrict([compactToU8a(this.length), ...encoded]);
   }
-
   toU8aInner(isBare) {
     const encoded = new Array(this.length);
-
     for (let i = 0; i < this.length; i++) {
       encoded[i] = this[i].toU8a(isBare);
     }
-
     return encoded;
   }
-
 }

package/abstract/Base.js

@@ -7,116 +7,100 @@
  */
 export class AbstractBase {
   #raw;
-
   constructor(registry, value, initialU8aLength) {
     this.#raw = value;
     this.initialU8aLength = initialU8aLength;
     this.registry = registry;
   }
+
   /**
    * @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());
   }
-
   get inner() {
     return this.#raw;
   }
+
   /**
    * @description Checks if the value is an empty value
    */
-
-
   get isEmpty() {
     return this.#raw.isEmpty;
   }
+
   /**
    * @description Compares the value of the input to see if there is a match
    */
-
-
   eq(other) {
     return this.#raw.eq(other);
   }
+
   /**
    * @description Returns a breakdown of the hex encoding for this Codec
    */
-
-
   inspect() {
     return this.#raw.inspect();
   }
+
   /**
    * @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 Converts the value in a best-fit primitive form
    */
-
-
   toPrimitive() {
     return this.#raw.toPrimitive();
   }
+
   /**
    * @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)
    */
-
-
   toU8a(isBare) {
     return this.#raw.toU8a(isBare);
   }
+
   /**
    * @description Returns the base runtime type name for this instance
    */
-
-
   toRawType() {
     return 'Base';
   }
-
   unwrap() {
     return this.#raw;
   }
-
 }

package/abstract/BigInt.js

@@ -1,7 +1,9 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
-import { BigInt } from '@polkadot/x-bigint'; // @ts-expect-error not extensible, we make it extensible here
 
+import { BigInt } from '@polkadot/x-bigint';
+
+// @ts-expect-error not extensible, we make it extensible here
 export class AbstractBigInt extends BigInt {
   // @ts-expect-error super() not required, the self magic does that
   constructor(value) {
@@ -9,5 +11,4 @@ export class AbstractBigInt extends BigInt {
     Object.setPrototypeOf(self, AbstractBigInt.prototype);
     return self;
   }
-
 }

package/abstract/Int.js

@@ -1,25 +1,24 @@
 // Copyright 2017-2022 @polkadot/types-codec authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
 import { BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isFunction, isHex, isNumber, isObject, 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
+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
 const MAX_NUMBER_BITS = 52;
 const MUL_P = new BN(10000);
 const FORMATTERS = [['Perquintill', BN_QUINTILL], ['Perbill', BN_BILLION], ['Permill', BN_MILLION], ['Percent', BN_HUNDRED]];
-
 function toPercentage(value, divisor) {
   return `${(value.mul(MUL_P).div(divisor).toNumber() / 100).toFixed(2)}%`;
 }
-/** @internal */
-
 
+/** @internal */
 function decodeAbstractInt(value, isNegative) {
   if (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 (isString(value)) {
     if (isHex(value, -1, true)) {
@@ -28,11 +27,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 (isBn(value)) {
     return value.toString();
@@ -41,37 +38,31 @@ 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 (!isString(inner) && !isNumber(inner)) {
       throw new Error('Unable to construct from object with non-string/non-number value');
     }
-
     return decodeAbstractInt(inner, isNegative);
   }
-
   return bnToBn(value).toString();
 }
+
 /**
  * @name AbstractInt
  * @ignore
  * @noInheritDoc
  */
-
-
 export class AbstractInt extends BN {
   #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:
     // https://github.com/indutny/bn.js/issues/206
-    super( // shortcut isU8a as used in SCALE decoding
+    super(
+    // shortcut isU8a as used in SCALE decoding
     isU8a(value) ? bitLength <= 48 ? u8aToNumber(value.subarray(0, bitLength / 8), {
       isNegative: isSigned
     }) : u8aToBn(value.subarray(0, bitLength / 8), {
@@ -84,43 +75,38 @@ export class AbstractInt extends 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
@@ -129,46 +115,41 @@ export class AbstractInt extends BN {
       isNegative: !this.isUnsigned
     }) : 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(isLe = false) {
     // For display/JSON, this is BE, for compare, use isLe
     return bnToHex(this, {
@@ -177,17 +158,16 @@ export class AbstractInt extends 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
       : formatBalance(this, {
         decimals: this.registry.chainDecimals[0],
@@ -195,15 +175,13 @@ export class AbstractInt extends BN {
         withUnit: this.registry.chainTokens[0]
       });
     }
-
     const [, divisor] = FORMATTERS.find(([type]) => type === rawType) || [];
     return divisor ? toPercentage(this, divisor) : formatNumber(this);
   }
+
   /**
    * @description Converts the Object to JSON, typically used for RPC transfers
    */
-
-
   toJSON(onlyHex = false) {
     // FIXME this return type should by string | number, however BN returns string
     // Options here are
@@ -211,42 +189,38 @@ export class AbstractInt extends 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 bnToU8a(this, {
       bitLength: this.bitLength(),
@@ -254,5 +228,4 @@ export class AbstractInt extends BN {
       isNegative: !this.isUnsigned
     });
   }
-
 }

package/abstract/index.js

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