web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@polkadot/types/extrinsic/Extrinsic.js

@@ -0,0 +1,299 @@
+'use strict';
+
+var Extrinsic = require('./v4/Extrinsic.js');
+var constants = require('./constants.js');
+var Base = require('../../types-codec/abstract/Base.js');
+var property = require('../../util/object/property.js');
+var concat = require('../../util/u8a/concat.js');
+var toU8a = require('../../util/compact/toU8a.js');
+var toHex = require('../../util/u8a/toHex.js');
+var spread = require('../../util/object/spread.js');
+var addLength = require('../../util/compact/addLength.js');
+var u8a = require('../../util/is/u8a.js');
+var hex = require('../../util/is/hex.js');
+var toU8a$1 = require('../../util/u8a/toU8a.js');
+var fromU8a = require('../../util/compact/fromU8a.js');
+
+const VERSIONS = ['ExtrinsicUnknown',
+// v0 is unknown
+'ExtrinsicUnknown', 'ExtrinsicUnknown', 'ExtrinsicUnknown', 'ExtrinsicV4'];
+/** @internal */
+function newFromValue(registry, value, version) {
+  if (value instanceof GenericExtrinsic) {
+    return value.unwrap();
+  }
+  const isSigned = (version & constants.BIT_SIGNED) === constants.BIT_SIGNED;
+  const type = VERSIONS[version & constants.UNMASK_VERSION] || VERSIONS[0];
+  // we cast here since the VERSION definition is incredibly broad - we don't have a
+  // slice for "only add extrinsic types", and more string definitions become unwieldy
+  return registry.createTypeUnsafe(type, [value, {
+    isSigned,
+    version
+  }]);
+}
+/** @internal */
+function decodeExtrinsic(registry, value) {
+  let version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.DEFAULT_VERSION;
+  if (u8a.isU8a(value) || Array.isArray(value) || hex.isHex(value)) {
+    return decodeU8a(registry, toU8a$1.u8aToU8a(value), version);
+  } else if (value instanceof registry.createClassUnsafe('Call')) {
+    return newFromValue(registry, {
+      method: value
+    }, version);
+  }
+  return newFromValue(registry, value, version);
+}
+/** @internal */
+function decodeU8a(registry, value, version) {
+  if (!value.length) {
+    return newFromValue(registry, new Uint8Array(), version);
+  }
+  const [offset, length] = fromU8a.compactFromU8a(value);
+  const total = offset + length.toNumber();
+  if (total > value.length) {
+    throw new Error(`Extrinsic: length less than remainder, expected at least ${total}, found ${value.length}`);
+  }
+  const data = value.subarray(offset, total);
+  return newFromValue(registry, data.subarray(1), data[0]);
+}
+class ExtrinsicBase extends Base.AbstractBase {
+  constructor(registry, value, initialU8aLength) {
+    super(registry, value, initialU8aLength);
+    const signKeys = Object.keys(registry.getSignedExtensionTypes());
+    const getter = key => this.inner.signature[key];
+    // This is on the abstract class, ensuring that hasOwnProperty operates
+    // correctly, i.e. it needs to be on the base class exposing it
+    for (let i = 0, count = signKeys.length; i < count; i++) {
+      property.objectProperty(this, signKeys[i], getter);
+    }
+  }
+  /**
+   * @description The arguments passed to for the call, exposes args so it is compatible with [[Call]]
+   */
+  get args() {
+    return this.method.args;
+  }
+  /**
+   * @description The argument definitions, compatible with [[Call]]
+   */
+  get argsDef() {
+    return this.method.argsDef;
+  }
+  /**
+   * @description The actual `[sectionIndex, methodIndex]` as used in the Call
+   */
+  get callIndex() {
+    return this.method.callIndex;
+  }
+  /**
+   * @description The actual data for the Call
+   */
+  get data() {
+    return this.method.data;
+  }
+  /**
+   * @description The era for this extrinsic
+   */
+  get era() {
+    return this.inner.signature.era;
+  }
+  /**
+   * @description The length of the value when encoded as a Uint8Array
+   */
+  get encodedLength() {
+    return this.toU8a().length;
+  }
+  /**
+   * @description `true` id the extrinsic is signed
+   */
+  get isSigned() {
+    return this.inner.signature.isSigned;
+  }
+  /**
+   * @description The length of the actual data, excluding prefix
+   */
+  get length() {
+    return this.toU8a(true).length;
+  }
+  /**
+   * @description The [[FunctionMetadataLatest]] that describes the extrinsic
+   */
+  get meta() {
+    return this.method.meta;
+  }
+  /**
+   * @description The [[Call]] this extrinsic wraps
+   */
+  get method() {
+    return this.inner.method;
+  }
+  /**
+   * @description The nonce for this extrinsic
+   */
+  get nonce() {
+    return this.inner.signature.nonce;
+  }
+  /**
+   * @description The actual [[EcdsaSignature]], [[Ed25519Signature]] or [[Sr25519Signature]]
+   */
+  get signature() {
+    return this.inner.signature.signature;
+  }
+  /**
+   * @description The [[Address]] that signed
+   */
+  get signer() {
+    return this.inner.signature.signer;
+  }
+  /**
+   * @description Forwards compat
+   */
+  get tip() {
+    return this.inner.signature.tip;
+  }
+  /**
+   * @description Forward compat
+   */
+  get assetId() {
+    return this.inner.signature.assetId;
+  }
+  /**
+   * @description Returns the raw transaction version (not flagged with signing information)
+  */
+  get type() {
+    return this.inner.version;
+  }
+  get inner() {
+    return this.unwrap();
+  }
+  /**
+   * @description Returns the encoded version flag
+  */
+  get version() {
+    return this.type | (this.isSigned ? constants.BIT_SIGNED : constants.BIT_UNSIGNED);
+  }
+  /**
+   * @description Checks if the source matches this in type
+   */
+  is(other) {
+    return this.method.is(other);
+  }
+  unwrap() {
+    return super.unwrap();
+  }
+}
+/**
+ * @name GenericExtrinsic
+ * @description
+ * Representation of an Extrinsic in the system. It contains the actual call,
+ * (optional) signature and encodes with an actual length prefix
+ *
+ * {@link https://github.com/paritytech/wiki/blob/master/Extrinsic.md#the-extrinsic-format-for-node}.
+ *
+ * Can be:
+ * - signed, to create a transaction
+ * - left as is, to create an inherent
+ */
+class GenericExtrinsic extends ExtrinsicBase {
+  __internal__hashCache;
+  static LATEST_EXTRINSIC_VERSION = (() => Extrinsic.EXTRINSIC_VERSION)();
+  constructor(registry, value) {
+    let {
+      version
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    super(registry, decodeExtrinsic(registry, value, version));
+  }
+  /**
+   * @description returns a hash of the contents
+   */
+  get hash() {
+    if (!this.__internal__hashCache) {
+      this.__internal__hashCache = super.hash;
+    }
+    return this.__internal__hashCache;
+  }
+  /**
+   * @description Injects an already-generated signature into the extrinsic
+   */
+  addSignature(signer, signature, payload) {
+    this.inner.addSignature(signer, signature, payload);
+    this.__internal__hashCache = undefined;
+    return this;
+  }
+  /**
+   * @description Returns a breakdown of the hex encoding for this Codec
+   */
+  inspect() {
+    const encoded = concat.u8aConcat(...this.toU8aInner());
+    return {
+      inner: this.isSigned ? this.inner.inspect().inner : this.inner.method.inspect().inner,
+      outer: [toU8a.compactToU8a(encoded.length), new Uint8Array([this.version])]
+    };
+  }
+  /**
+   * @description Sign the extrinsic with a specific keypair
+   */
+  sign(account, options) {
+    this.inner.sign(account, options);
+    this.__internal__hashCache = undefined;
+    return this;
+  }
+  /**
+   * @describe Adds a fake signature to the extrinsic
+   */
+  signFake(signer, options) {
+    this.inner.signFake(signer, options);
+    this.__internal__hashCache = undefined;
+    return this;
+  }
+  /**
+   * @description Returns a hex string representation of the value
+   */
+  toHex(isBare) {
+    return toHex.u8aToHex(this.toU8a(isBare));
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  toHuman(isExpanded, disableAscii) {
+    return spread.objectSpread({}, {
+      isSigned: this.isSigned,
+      method: this.method.toHuman(isExpanded, disableAscii)
+    }, this.isSigned ? {
+      assetId: this.assetId.toHuman(isExpanded, disableAscii),
+      era: this.era.toHuman(isExpanded, disableAscii),
+      nonce: this.nonce.toHuman(isExpanded, disableAscii),
+      signature: this.signature.toHex(),
+      signer: this.signer.toHuman(isExpanded, disableAscii),
+      tip: this.tip.toHuman(isExpanded, disableAscii)
+    } : null);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  toJSON() {
+    return this.toHex();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    return 'Extrinsic';
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the SCALE specifications
+   * @param isBare true when the value is not length-prefixed
+   */
+  toU8a(isBare) {
+    const encoded = concat.u8aConcat(...this.toU8aInner());
+    return isBare ? encoded : addLength.compactAddLength(encoded);
+  }
+  toU8aInner() {
+    // we do not apply bare to the internal values, rather this only determines out length addition,
+    // where we strip all lengths this creates an extrinsic that cannot be decoded
+    return [new Uint8Array([this.version]), this.inner.toU8a()];
+  }
+}
+
+exports.LATEST_EXTRINSIC_VERSION = Extrinsic.EXTRINSIC_VERSION;
+exports.GenericExtrinsic = GenericExtrinsic;

package/dist/cjs/node_modules/@polkadot/types/extrinsic/ExtrinsicEra.js

@@ -0,0 +1,248 @@
+'use strict';
+
+var constants = require('./constants.js');
+var Raw = require('../../types-codec/native/Raw.js');
+var U64 = require('../../types-codec/primitive/U64.js');
+var Enum = require('../../types-codec/base/Enum.js');
+var Tuple = require('../../types-codec/base/Tuple.js');
+var formatNumber = require('../../util/format/formatNumber.js');
+var toBn = require('../../util/bn/toBn.js');
+var u8a = require('../../util/is/u8a.js');
+var hex = require('../../util/is/hex.js');
+var toU8a = require('../../util/hex/toU8a.js');
+var object = require('../../util/is/object.js');
+var toU8a$1 = require('../../util/u8a/toU8a.js');
+var toBn$1 = require('../../util/u8a/toBn.js');
+
+function getTrailingZeros(period) {
+  const binary = period.toString(2);
+  let index = 0;
+  while (binary[binary.length - 1 - index] === '0') {
+    index++;
+  }
+  return index;
+}
+/** @internal */
+function decodeMortalEra(registry, value) {
+  if (u8a.isU8a(value) || hex.isHex(value) || Array.isArray(value)) {
+    return decodeMortalU8a(registry, toU8a$1.u8aToU8a(value));
+  } else if (!value) {
+    return [new U64.u64(registry), new U64.u64(registry)];
+  } else if (object.isObject(value)) {
+    return decodeMortalObject(registry, value);
+  }
+  throw new Error('Invalid data passed to Mortal era');
+}
+/** @internal */
+function decodeMortalObject(registry, value) {
+  const {
+    current,
+    period
+  } = value;
+  let calPeriod = Math.pow(2, Math.ceil(Math.log2(period)));
+  calPeriod = Math.min(Math.max(calPeriod, 4), 1 << 16);
+  const phase = current % calPeriod;
+  const quantizeFactor = Math.max(calPeriod >> 12, 1);
+  const quantizedPhase = phase / quantizeFactor * quantizeFactor;
+  return [new U64.u64(registry, calPeriod), new U64.u64(registry, quantizedPhase)];
+}
+/** @internal */
+function decodeMortalU8a(registry, value) {
+  if (value.length === 0) {
+    return [new U64.u64(registry), new U64.u64(registry)];
+  }
+  const first = toBn$1.u8aToBn(value.subarray(0, 1)).toNumber();
+  const second = toBn$1.u8aToBn(value.subarray(1, 2)).toNumber();
+  const encoded = first + (second << 8);
+  const period = 2 << encoded % (1 << 4);
+  const quantizeFactor = Math.max(period >> 12, 1);
+  const phase = (encoded >> 4) * quantizeFactor;
+  if (period < 4 || phase >= period) {
+    throw new Error('Invalid data passed to Mortal era');
+  }
+  return [new U64.u64(registry, period), new U64.u64(registry, phase)];
+}
+/** @internal */
+function decodeExtrinsicEra() {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Uint8Array();
+  if (u8a.isU8a(value)) {
+    return !value.length || value[0] === 0 ? new Uint8Array([0]) : new Uint8Array([1, value[0], value[1]]);
+  } else if (!value) {
+    return new Uint8Array([0]);
+  } else if (value instanceof GenericExtrinsicEra) {
+    return decodeExtrinsicEra(value.toU8a());
+  } else if (hex.isHex(value)) {
+    return decodeExtrinsicEra(toU8a.hexToU8a(value));
+  } else if (object.isObject(value)) {
+    const entries = Object.entries(value).map(_ref => {
+      let [k, v] = _ref;
+      return [k.toLowerCase(), v];
+    });
+    const mortal = entries.find(_ref2 => {
+      let [k] = _ref2;
+      return k.toLowerCase() === 'mortalera';
+    });
+    const immortal = entries.find(_ref3 => {
+      let [k] = _ref3;
+      return k.toLowerCase() === 'immortalera';
+    });
+    // this is to de-serialize from JSON
+    return mortal ? {
+      MortalEra: mortal[1]
+    } : immortal ? {
+      ImmortalEra: immortal[1]
+    } : {
+      MortalEra: value
+    };
+  }
+  throw new Error('Invalid data passed to Era');
+}
+/**
+ * @name ImmortalEra
+ * @description
+ * The ImmortalEra for an extrinsic
+ */
+class ImmortalEra extends Raw.Raw {
+  constructor(registry, _value) {
+    // For immortals, we always provide the known value (i.e. treated as a
+    // constant no matter how it is constructed - it is a fixed structure)
+    super(registry, constants.IMMORTAL_ERA);
+  }
+}
+/**
+ * @name MortalEra
+ * @description
+ * The MortalEra for an extrinsic, indicating period and phase
+ */
+class MortalEra extends Tuple.Tuple {
+  constructor(registry, value) {
+    super(registry, {
+      period: U64.u64,
+      phase: U64.u64
+    }, decodeMortalEra(registry, value));
+  }
+  /**
+   * @description Encoded length for mortals occupy 2 bytes, different from the actual Tuple since it is encoded. This is a shortcut fro `toU8a().length`
+   */
+  get encodedLength() {
+    return 2 | 0;
+  }
+  /**
+   * @description The period of this Mortal wraps as a [[U64]]
+   */
+  get period() {
+    return this[0];
+  }
+  /**
+   * @description The phase of this Mortal wraps as a [[U64]]
+   */
+  get phase() {
+    return this[1];
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  toHuman() {
+    return {
+      period: formatNumber.formatNumber(this.period),
+      phase: formatNumber.formatNumber(this.phase)
+    };
+  }
+  /**
+   * @description Returns a JSON representation of the actual value
+   */
+  toJSON() {
+    return this.toHex();
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the parity-codec specifications
+   * @param isBare true when the value has none of the type-specific prefixes (internal)
+   * Period and phase are encoded:
+   *   - The period of validity from the block hash found in the signing material.
+   *   - The phase in the period that this transaction's lifetime begins (and, importantly,
+   *     implies which block hash is included in the signature material). If the `period` is
+   *     greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that
+   *     `period` is.
+   */
+  toU8a(_isBare) {
+    const period = this.period.toNumber();
+    const encoded = Math.min(15, Math.max(1, getTrailingZeros(period) - 1)) + (this.phase.toNumber() / Math.max(period >> 12, 1) << 4);
+    return new Uint8Array([encoded & 0xff, encoded >> 8]);
+  }
+  /**
+   * @description Get the block number of the start of the era whose properties this object describes that `current` belongs to.
+   */
+  birth(current) {
+    const phase = this.phase.toNumber();
+    const period = this.period.toNumber();
+    // FIXME No toNumber() here
+    return ~~((Math.max(toBn.bnToBn(current).toNumber(), phase) - phase) / period) * period + phase;
+  }
+  /**
+   * @description Get the block number of the first block at which the era has ended.
+   */
+  death(current) {
+    // FIXME No toNumber() here
+    return this.birth(current) + this.period.toNumber();
+  }
+}
+/**
+ * @name GenericExtrinsicEra
+ * @description
+ * The era for an extrinsic, indicating either a mortal or immortal extrinsic
+ */
+class GenericExtrinsicEra extends Enum.Enum {
+  constructor(registry, value) {
+    super(registry, {
+      ImmortalEra,
+      MortalEra
+    }, decodeExtrinsicEra(value));
+  }
+  /**
+   * @description Override the encoded length method
+   */
+  get encodedLength() {
+    return this.isImmortalEra ? this.asImmortalEra.encodedLength : this.asMortalEra.encodedLength;
+  }
+  /**
+   * @description Returns the item as a [[ImmortalEra]]
+   */
+  get asImmortalEra() {
+    if (!this.isImmortalEra) {
+      throw new Error(`Cannot convert '${this.type}' via asImmortalEra`);
+    }
+    return this.inner;
+  }
+  /**
+   * @description Returns the item as a [[MortalEra]]
+   */
+  get asMortalEra() {
+    if (!this.isMortalEra) {
+      throw new Error(`Cannot convert '${this.type}' via asMortalEra`);
+    }
+    return this.inner;
+  }
+  /**
+   * @description `true` if Immortal
+   */
+  get isImmortalEra() {
+    return this.index === 0;
+  }
+  /**
+   * @description `true` if Mortal
+   */
+  get isMortalEra() {
+    return this.index > 0;
+  }
+  /**
+   * @description Encodes the value as a Uint8Array as per the parity-codec specifications
+   * @param isBare true when the value has none of the type-specific prefixes (internal)
+   */
+  toU8a(isBare) {
+    return this.isMortalEra ? this.asMortalEra.toU8a(isBare) : this.asImmortalEra.toU8a(isBare);
+  }
+}
+
+exports.GenericExtrinsicEra = GenericExtrinsicEra;
+exports.ImmortalEra = ImmortalEra;
+exports.MortalEra = MortalEra;

package/dist/cjs/node_modules/@polkadot/types/extrinsic/ExtrinsicPayload.js

@@ -0,0 +1,145 @@
+'use strict';
+
+var constants = require('./constants.js');
+var Base = require('../../types-codec/abstract/Base.js');
+var toHex = require('../../util/u8a/toHex.js');
+
+const VERSIONS = ['ExtrinsicPayloadUnknown',
+// v0 is unknown
+'ExtrinsicPayloadUnknown', 'ExtrinsicPayloadUnknown', 'ExtrinsicPayloadUnknown', 'ExtrinsicPayloadV4'];
+/** @internal */
+function decodeExtrinsicPayload(registry, value) {
+  let version = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.DEFAULT_VERSION;
+  if (value instanceof GenericExtrinsicPayload) {
+    return value.unwrap();
+  }
+  return registry.createTypeUnsafe(VERSIONS[version] || VERSIONS[0], [value, {
+    version
+  }]);
+}
+/**
+ * @name GenericExtrinsicPayload
+ * @description
+ * A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based
+ * on the contents included
+ */
+class GenericExtrinsicPayload extends Base.AbstractBase {
+  constructor(registry, value) {
+    let {
+      version
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    super(registry, decodeExtrinsicPayload(registry, value, version));
+  }
+  /**
+   * @description The block [[BlockHash]] the signature applies to (mortal/immortal)
+   */
+  get blockHash() {
+    return this.inner.blockHash;
+  }
+  /**
+   * @description The [[ExtrinsicEra]]
+   */
+  get era() {
+    return this.inner.era;
+  }
+  /**
+   * @description The genesis block [[BlockHash]] the signature applies to
+   */
+  get genesisHash() {
+    // NOTE only v3+
+    return this.inner.genesisHash || this.registry.createTypeUnsafe('Hash', []);
+  }
+  /**
+   * @description The [[Bytes]] contained in the payload
+   */
+  get method() {
+    return this.inner.method;
+  }
+  /**
+   * @description The [[Index]]
+   */
+  get nonce() {
+    return this.inner.nonce;
+  }
+  /**
+   * @description The specVersion as a [[u32]] for this payload
+   */
+  get specVersion() {
+    // NOTE only v3+
+    return this.inner.specVersion || this.registry.createTypeUnsafe('u32', []);
+  }
+  /**
+   * @description The [[Balance]]
+   */
+  get tip() {
+    // NOTE from v2+
+    return this.inner.tip || this.registry.createTypeUnsafe('Compact<Balance>', []);
+  }
+  /**
+   * @description The transaction version as a [[u32]] for this payload
+   */
+  get transactionVersion() {
+    // NOTE only v4+
+    return this.inner.transactionVersion || this.registry.createTypeUnsafe('u32', []);
+  }
+  /**
+   * @description The (optional) asset id as a [[u32]] or [[MultiLocation]] for this payload
+   */
+  get assetId() {
+    return this.inner.assetId;
+  }
+  /**
+   * @description Compares the value of the input to see if there is a match
+   */
+  eq(other) {
+    return this.inner.eq(other);
+  }
+  /**
+   * @description Sign the payload with the keypair
+   */
+  sign(signerPair) {
+    const signature = this.inner.sign(signerPair);
+    // This is extensible, so we could quite readily extend to send back extra
+    // information, such as for instance the payload, i.e. `payload: this.toHex()`
+    // For the case here we sign via the extrinsic, we ignore the return, so generally
+    // this is applicable for external signing
+    return {
+      signature: toHex.u8aToHex(signature)
+    };
+  }
+  /**
+   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
+   */
+  toHuman(isExtended, disableAscii) {
+    return this.inner.toHuman(isExtended, disableAscii);
+  }
+  /**
+   * @description Converts the Object to JSON, typically used for RPC transfers
+   */
+  toJSON() {
+    return this.toHex();
+  }
+  /**
+   * @description Returns the base runtime type name for this instance
+   */
+  toRawType() {
+    return 'ExtrinsicPayload';
+  }
+  /**
+   * @description Returns the string representation of the value
+   */
+  toString() {
+    return this.toHex();
+  }
+  /**
+   * @description Returns a serialized u8a form
+   */
+  toU8a(isBare) {
+    // call our parent, with only the method stripped
+    return super.toU8a(isBare ? {
+      method: true
+    } : false);
+  }
+}
+
+exports.GenericExtrinsicPayload = GenericExtrinsicPayload;

package/dist/cjs/node_modules/@polkadot/types/extrinsic/ExtrinsicPayloadUnknown.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var Struct = require('../../types-codec/native/Struct.js');
+
+/**
+ * @name GenericExtrinsicPayloadUnknown
+ * @description
+ * A default handler for payloads where the version is not known (default throw)
+ */
+class GenericExtrinsicPayloadUnknown extends Struct.Struct {
+  constructor(registry, _value) {
+    let {
+      version = 0
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    super(registry, {});
+    throw new Error(`Unsupported extrinsic payload version ${version}`);
+  }
+}
+
+exports.GenericExtrinsicPayloadUnknown = GenericExtrinsicPayloadUnknown;