web-dc-api 0.0.60 → 0.0.62

package/dist/cjs/node_modules/@polkadot/types-codec/abstract/Int.js

@@ -0,0 +1,247 @@
+'use strict';
+
+var toNumber = require('../../util/u8a/toNumber.js');
+var toBn$2 = require('../../util/bn/toBn.js');
+var toHex = require('../../util/bn/toHex.js');
+var formatBalance = require('../../util/format/formatBalance.js');
+var consts = require('../../util/bn/consts.js');
+var formatNumber = require('../../util/format/formatNumber.js');
+var bn = require('../../../../_virtual/bn.js');
+var toBn = require('../../util/u8a/toBn.js');
+var u8a = require('../../util/is/u8a.js');
+var toBn$1 = require('../../util/hex/toBn.js');
+var hex = require('../../util/is/hex.js');
+var toU8a = require('../../util/bn/toU8a.js');
+var number = require('../../util/is/number.js');
+var string = require('../../util/is/string.js');
+var bn$1 = require('../../util/is/bn.js');
+var bigInt = require('../../util/is/bigInt.js');
+var object = require('../../util/is/object.js');
+var _function = require('../../util/is/function.js');
+
+const DEFAULT_UINT_BITS = 64;
+const MAX_NUMBER_BITS = 52;
+const MUL_P = new bn.default(10000);
+const FORMATTERS = [['Perquintill', consts.BN_QUINTILL], ['Perbill', consts.BN_BILLION], ['Permill', consts.BN_MILLION], ['Percent', consts.BN_HUNDRED]];
+function isToBn(value) {
+  return _function.isFunction(value.toBn);
+}
+function toPercentage(value, divisor) {
+  return `${(value.mul(MUL_P).div(divisor).toNumber() / 100).toFixed(2)}%`;
+}
+/** @internal */
+function decodeAbstractInt(value, isNegative) {
+  if (number.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 (string.isString(value)) {
+    if (hex.isHex(value, -1, true)) {
+      return toBn$1.hexToBn(value, {
+        isLe: false,
+        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 (bn$1.isBn(value) || bigInt.isBigInt(value)) {
+    return value.toString();
+  } else if (object.isObject(value)) {
+    if (isToBn(value)) {
+      return value.toBn().toString();
+    }
+    // Allow the construction from an object with a single top-level key. This means that
+    // 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');
+    }
+    return decodeAbstractInt(value[keys[0]], isNegative);
+  } else if (!value) {
+    return 0;
+  }
+  throw new Error(`Unable to create BN from unknown type ${typeof value}`);
+}
+/**
+ * @name AbstractInt
+ * @ignore
+ * @noInheritDoc
+ */
+class AbstractInt extends bn.default {
+  registry;
+  encodedLength;
+  isUnsigned;
+  createdAtHash;
+  initialU8aLength;
+  isStorageFallback;
+  __internal__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;
+    let isSigned = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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
+    u8a.isU8a(value) ? bitLength <= 48 ? toNumber.u8aToNumber(value.subarray(0, bitLength / 8), {
+      isNegative: isSigned
+    }) : toBn.u8aToBn(value.subarray(0, bitLength / 8), {
+      isLe: true,
+      isNegative: isSigned
+    }).toString() : decodeAbstractInt(value, isSigned));
+    this.registry = registry;
+    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);
+    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.__internal__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(hex.isHex(other) ? toBn$1.hexToBn(other.toString(), {
+      isLe: false,
+      isNegative: !this.isUnsigned
+    }) : toBn$2.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.__internal__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 toHex.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
+   */
+  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.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) : formatNumber.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, 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();
+  }
+  /**
+   * @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
+   */
+  toU8a(_isBare) {
+    return toU8a.bnToU8a(this, {
+      bitLength: this.bitLength(),
+      isLe: true,
+      isNegative: !this.isUnsigned
+    });
+  }
+}
+
+exports.AbstractInt = AbstractInt;
+exports.DEFAULT_UINT_BITS = DEFAULT_UINT_BITS;

package/dist/cjs/node_modules/@polkadot/types-codec/base/Compact.js

@@ -0,0 +1,167 @@
+'use strict';
+
+var noop = require('../../util/noop.js');
+var toConstructors = require('../utils/toConstructors.js');
+var fromU8a = require('../../util/compact/fromU8a.js');
+var toU8a = require('../../util/compact/toU8a.js');
+var u8a = require('../../util/is/u8a.js');
+
+function decodeCompact(registry, Type, value) {
+  if (u8a.isU8a(value)) {
+    const [decodedLength, bn] = (value[0] & 0b11) < 0b11 ? fromU8a.compactFromU8aLim(value) : fromU8a.compactFromU8a(value);
+    return [new Type(registry, bn), decodedLength];
+  } else if (value instanceof Compact) {
+    const raw = value.unwrap();
+    return raw instanceof Type ? [raw, 0] : [new Type(registry, raw), 0];
+  } else if (value instanceof Type) {
+    return [value, 0];
+  }
+  return [new Type(registry, value), 0];
+}
+/**
+ * @name Compact
+ * @description
+ * A compact length-encoding codec wrapper. It performs the same function as Length, however
+ * differs in that it uses a variable number of bytes to do the actual encoding. This is mostly
+ * 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 {
+  registry;
+  createdAtHash;
+  initialU8aLength;
+  isStorageFallback;
+  __internal__Type;
+  __internal__raw;
+  constructor(registry, Type) {
+    let value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let {
+      definition,
+      setDefinition = noop.identity
+    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    this.registry = registry;
+    this.__internal__Type = definition || setDefinition(toConstructors.typeToConstructor(registry, Type));
+    const [raw, decodedLength] = decodeCompact(registry, this.__internal__Type, value);
+    this.initialU8aLength = decodedLength;
+    this.__internal__raw = raw;
+  }
+  static with(Type) {
+    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, {
+          definition,
+          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.__internal__raw.isEmpty;
+  }
+  /**
+   * @description Returns the number of bits in the value
+   */
+  bitLength() {
+    return this.__internal__raw.bitLength();
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  eq(other) {
+    return this.__internal__raw.eq(other instanceof Compact ? other.__internal__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.__internal__raw.toBigInt();
+  }
+  /**
+   * @description Returns the BN representation of the number
+   */
+  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 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, disableAscii) {
+    return this.__internal__raw.toHuman(isExtended, disableAscii);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  toJSON() {
+    return this.__internal__raw.toJSON();
+  }
+  /**
+   * @description Returns the number representation for the value
+   */
+  toNumber() {
+    return this.__internal__raw.toNumber();
+  }
+  /**
+   * @description Converts the value in a best-fit primitive form
+   */
+  toPrimitive(disableAscii) {
+    return this.__internal__raw.toPrimitive(disableAscii);
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    return `Compact<${this.registry.getClassName(this.__internal__Type) || this.__internal__raw.toRawType()}>`;
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+  toString() {
+    return this.__internal__raw.toString();
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   */
+  toU8a(_isBare) {
+    return toU8a.compactToU8a(this.__internal__raw.toBn());
+  }
+  /**
+   * @description Returns the embedded [[UInt]] or [[Moment]] value
+   */
+  unwrap() {
+    return this.__internal__raw;
+  }
+}
+
+exports.Compact = Compact;

package/dist/cjs/node_modules/@polkadot/types-codec/base/DoNotConstruct.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * @name DoNotConstruct
+ * @description
+ * An unknown type that fails on construction with the type info
+ */
+class DoNotConstruct {
+  registry;
+  createdAtHash;
+  isStorageFallback;
+  __internal__neverError;
+  constructor(registry) {
+    let typeName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'DoNotConstruct';
+    this.registry = registry;
+    this.__internal__neverError = new Error(`DoNotConstruct: Cannot construct unknown type ${typeName}`);
+    throw this.__internal__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.__internal__neverError;
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+  get hash() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Checks if the value is an empty value (always true)
+   */
+  get isEmpty() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  eq() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  inspect() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toHex() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toHuman() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toJSON() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toPrimitive() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toRawType() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toString() {
+    throw this.__internal__neverError;
+  }
+  /**
+   * @description Unimplemented
+   */
+  toU8a() {
+    throw this.__internal__neverError;
+  }
+}
+
+exports.DoNotConstruct = DoNotConstruct;