@polkadot/types-codec 6.12.2-2

package/abstract/AbstractInt.cjs

@@ -0,0 +1,254 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_UINT_BITS = exports.AbstractInt = void 0;
+
+var _classPrivateFieldLooseBase2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseBase"));
+
+var _classPrivateFieldLooseKey2 = _interopRequireDefault(require("@babel/runtime/helpers/classPrivateFieldLooseKey"));
+
+var _util = require("@polkadot/util");
+
+// Copyright 2017-2021 @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
+
+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 */
+
+
+function decodeAbstractInt(value, bitLength, isNegative) {
+  if ((0, _util.isU8a)(value)) {
+    return (0, _util.u8aToBn)(value.subarray(0, bitLength / 8), {
+      isLe: true,
+      isNegative
+    }).toString();
+  } else if ((0, _util.isBn)(value)) {
+    return value.toString();
+  } else if ((0, _util.isHex)(value, -1, true)) {
+    return (0, _util.hexToBn)(value, {
+      isLe: false,
+      isNegative
+    }).toString();
+  }
+
+  return (0, _util.bnToBn)(value).toString();
+}
+/**
+ * @name AbstractInt
+ * @ignore
+ * @noInheritDoc
+ */
+
+
+var _bitLength = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("bitLength");
+
+var _isSigned = /*#__PURE__*/(0, _classPrivateFieldLooseKey2.default)("isSigned");
+
+class AbstractInt extends _util.BN {
+  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;
+    let isSigned = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    // Construct via a string, 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
+    (0, _util.isU8a)(value) ? (0, _util.u8aToBn)(value.subarray(0, bitLength / 8), {
+      isLe: true,
+      isNegative: isSigned
+    }).toString() : decodeAbstractInt(value, bitLength, isSigned));
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.encodedLength = void 0;
+    Object.defineProperty(this, _bitLength, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _isSigned, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    (0, _classPrivateFieldLooseBase2.default)(this, _bitLength)[_bitLength] = bitLength;
+    this.encodedLength = (0, _classPrivateFieldLooseBase2.default)(this, _bitLength)[_bitLength] / 8;
+    (0, _classPrivateFieldLooseBase2.default)(this, _isSigned)[_isSigned] = isSigned;
+    const isPositive = this.gte(_util.BN_ZERO);
+    const maxBits = bitLength - (isSigned && isPositive ? 1 : 0);
+    (0, _util.assert)(isSigned || isPositive, () => `${this.toRawType()}: Negative number passed to unsigned type`);
+    (0, _util.assert)(super.bitLength() <= maxBits, () => `${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 Checks if the value is an unsigned type
+   */
+
+
+  get isUnsigned() {
+    return !(0, _classPrivateFieldLooseBase2.default)(this, _isSigned)[_isSigned];
+  }
+  /**
+   * @description Returns the number of bits in the value
+   */
+
+
+  bitLength() {
+    return (0, _classPrivateFieldLooseBase2.default)(this, _bitLength)[_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
+    return super.eq((0, _util.isHex)(other) ? (0, _util.hexToBn)(other.toString(), {
+      isLe: false,
+      isNegative: (0, _classPrivateFieldLooseBase2.default)(this, _isSigned)[_isSigned]
+    }) : (0, _util.bnToBn)(other));
+  }
+  /**
+   * @description True if this value is the max of the type
+   */
+
+
+  isMax() {
+    const u8a = this.toU8a().filter(b => b === 0xff);
+    return u8a.length === (0, _classPrivateFieldLooseBase2.default)(this, _bitLength)[_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
+    return (0, _util.bnToHex)(this, {
+      bitLength: this.bitLength(),
+      isLe,
+      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
+      // to. as it stands we will always format (incorrectly) against the first token defined
+      : (0, _util.formatBalance)(this, {
+        decimals: this.registry.chainDecimals[0],
+        withSi: true,
+        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
+    // 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 ? this.toHex() : 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(),
+      isLe: true,
+      isNegative: !this.isUnsigned
+    });
+  }
+
+}
+
+exports.AbstractInt = AbstractInt;

package/abstract/AbstractInt.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="bn.js" />
+import type { HexString } from '@polkadot/util/types';
+import type { AnyNumber, CodecRegistry, INumber, IU8a, UIntBitLength } from '../types';
+import { BN } from '@polkadot/util';
+export declare const DEFAULT_UINT_BITS = 64;
+/**
+ * @name AbstractInt
+ * @ignore
+ * @noInheritDoc
+ */
+export declare abstract class AbstractInt extends BN implements INumber {
+    #private;
+    readonly registry: CodecRegistry;
+    createdAtHash?: IU8a;
+    readonly encodedLength: number;
+    constructor(registry: CodecRegistry, value?: AnyNumber, bitLength?: UIntBitLength, isSigned?: boolean);
+    /**
+     * @description returns a hash of the contents
+     */
+    get hash(): IU8a;
+    /**
+     * @description Checks if the value is a zero value (align elsewhere)
+     */
+    get isEmpty(): boolean;
+    /**
+     * @description Checks if the value is an unsigned type
+     */
+    get isUnsigned(): boolean;
+    /**
+     * @description Returns the number of bits in the value
+     */
+    bitLength(): number;
+    /**
+     * @description Compares the value of the input to see if there is a match
+     */
+    eq(other?: unknown): boolean;
+    /**
+     * @description True if this value is the max of the type
+     */
+    isMax(): boolean;
+    /**
+     * @description Returns a BigInt representation of the number
+     */
+    toBigInt(): bigint;
+    /**
+     * @description Returns the BN representation of the number. (Compatibility)
+     */
+    toBn(): BN;
+    /**
+     * @description Returns a hex string representation of the value
+     */
+    toHex(isLe?: boolean): HexString;
+    /**
+     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+     */
+    toHuman(isExpanded?: boolean): string;
+    /**
+     * @description Converts the Object to JSON, typically used for RPC transfers
+     */
+    toJSON(onlyHex?: boolean): any;
+    /**
+     * @description Returns the base runtime type name for this instance
+     */
+    toRawType(): string;
+    /**
+     * @description Returns the string representation of the value
+     * @param base The base to use for the conversion
+     */
+    toString(base?: number): string;
+    /**
+     * @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?: boolean): Uint8Array;
+}

package/abstract/AbstractInt.js

@@ -0,0 +1,231 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert, BN, BN_BILLION, BN_HUNDRED, BN_MILLION, BN_QUINTILL, BN_ZERO, bnToBn, bnToHex, bnToU8a, formatBalance, formatNumber, hexToBn, isBn, isHex, isU8a, u8aToBn } 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
+
+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 */
+
+
+function decodeAbstractInt(value, bitLength, isNegative) {
+  if (isU8a(value)) {
+    return u8aToBn(value.subarray(0, bitLength / 8), {
+      isLe: true,
+      isNegative
+    }).toString();
+  } else if (isBn(value)) {
+    return value.toString();
+  } else if (isHex(value, -1, true)) {
+    return hexToBn(value, {
+      isLe: false,
+      isNegative
+    }).toString();
+  }
+
+  return bnToBn(value).toString();
+}
+/**
+ * @name AbstractInt
+ * @ignore
+ * @noInheritDoc
+ */
+
+
+var _bitLength = /*#__PURE__*/_classPrivateFieldLooseKey("bitLength");
+
+var _isSigned = /*#__PURE__*/_classPrivateFieldLooseKey("isSigned");
+
+export class AbstractInt extends BN {
+  constructor(registry, value = 0, bitLength = DEFAULT_UINT_BITS, isSigned = false) {
+    // Construct via a string, 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
+    isU8a(value) ? u8aToBn(value.subarray(0, bitLength / 8), {
+      isLe: true,
+      isNegative: isSigned
+    }).toString() : decodeAbstractInt(value, bitLength, isSigned));
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.encodedLength = void 0;
+    Object.defineProperty(this, _bitLength, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _isSigned, {
+      writable: true,
+      value: void 0
+    });
+    this.registry = registry;
+    _classPrivateFieldLooseBase(this, _bitLength)[_bitLength] = bitLength;
+    this.encodedLength = _classPrivateFieldLooseBase(this, _bitLength)[_bitLength] / 8;
+    _classPrivateFieldLooseBase(this, _isSigned)[_isSigned] = isSigned;
+    const isPositive = this.gte(BN_ZERO);
+    const maxBits = bitLength - (isSigned && isPositive ? 1 : 0);
+    assert(isSigned || isPositive, () => `${this.toRawType()}: Negative number passed to unsigned type`);
+    assert(super.bitLength() <= maxBits, () => `${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 Checks if the value is an unsigned type
+   */
+
+
+  get isUnsigned() {
+    return !_classPrivateFieldLooseBase(this, _isSigned)[_isSigned];
+  }
+  /**
+   * @description Returns the number of bits in the value
+   */
+
+
+  bitLength() {
+    return _classPrivateFieldLooseBase(this, _bitLength)[_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
+    return super.eq(isHex(other) ? hexToBn(other.toString(), {
+      isLe: false,
+      isNegative: _classPrivateFieldLooseBase(this, _isSigned)[_isSigned]
+    }) : bnToBn(other));
+  }
+  /**
+   * @description True if this value is the max of the type
+   */
+
+
+  isMax() {
+    const u8a = this.toU8a().filter(b => b === 0xff);
+    return u8a.length === _classPrivateFieldLooseBase(this, _bitLength)[_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, {
+      bitLength: this.bitLength(),
+      isLe,
+      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
+      // to. as it stands we will always format (incorrectly) against the first token defined
+      : formatBalance(this, {
+        decimals: this.registry.chainDecimals[0],
+        withSi: true,
+        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
+    //   - 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 ? this.toHex() : 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(),
+      isLe: true,
+      isNegative: !this.isUnsigned
+    });
+  }
+
+}

package/abstract/index.cjs

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AbstractArray", {
+  enumerable: true,
+  get: function () {
+    return _AbstractArray.AbstractArray;
+  }
+});
+Object.defineProperty(exports, "AbstractInt", {
+  enumerable: true,
+  get: function () {
+    return _AbstractInt.AbstractInt;
+  }
+});
+
+var _AbstractArray = require("./AbstractArray.cjs");
+
+var _AbstractInt = require("./AbstractInt.cjs");

package/abstract/index.d.ts

@@ -0,0 +1,2 @@
+export { AbstractArray } from './AbstractArray';
+export { AbstractInt } from './AbstractInt';

package/abstract/index.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { AbstractArray } from "./AbstractArray.js";
+export { AbstractInt } from "./AbstractInt.js";

package/base/Base.cjs

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Base = void 0;
+
+// Copyright 2017-2021 @polkadot/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name Base
+ * @description A type extends the Base class, when it holds a value
+ */
+class Base {
+  constructor(registry, value, initialU8aLength) {
+    this.registry = void 0;
+    this.createdAtHash = void 0;
+    this.initialU8aLength = void 0;
+    this._raw = void 0;
+    this.registry = registry;
+    this._raw = value;
+    this.initialU8aLength = initialU8aLength;
+  }
+  /**
+   * @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 Compares the value of the input to see if there is a match
+   */
+
+
+  eq(other) {
+    return this._raw.eq(other);
+  }
+  /**
+   * @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 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';
+  }
+
+}
+
+exports.Base = Base;