web-dc-api 0.0.60 → 0.0.62

package/dist/cjs/node_modules/@polkadot/api/base/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var Getters = require('./Getters.js');
+var string = require('../../util/is/string.js');
+var spread = require('../../util/object/spread.js');
+var toHex = require('../../util/u8a/toHex.js');
+var toU8a = require('../../util/u8a/toU8a.js');
+
+class ApiBase extends Getters.Getters {
+  /**
+   * @description Create an instance of the class
+   *
+   * @param options Options object to create API instance or a Provider instance
+   *
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * import Api from '@polkadot/api/promise';
+   *
+   * const api = new Api().isReady();
+   *
+   * api.rpc.subscribeNewHeads((header) => {
+   *   console.log(`new block #${header.number.toNumber()}`);
+   * });
+   * ```
+   */
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let type = arguments.length > 1 ? arguments[1] : undefined;
+    let decorateMethod = arguments.length > 2 ? arguments[2] : undefined;
+    super(options, type, decorateMethod);
+  }
+  /**
+   * @description Connect from the underlying provider, halting all network traffic
+   */
+  connect() {
+    return this._rpcCore.connect();
+  }
+  /**
+   * @description Disconnect from the underlying provider, halting all network traffic
+   */
+  disconnect() {
+    this._unsubscribe();
+    return this._rpcCore.disconnect();
+  }
+  /**
+   * @description Set an external signer which will be used to sign extrinsic when account passed in is not KeyringPair
+   */
+  setSigner(signer) {
+    this._rx.signer = signer;
+  }
+  /**
+   * @description Signs a raw signer payload, string or Uint8Array
+   */
+  async sign(address, data) {
+    let {
+      signer
+    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    if (string.isString(address)) {
+      const _signer = signer || this._rx.signer;
+      if (!_signer?.signRaw) {
+        throw new Error('No signer exists with a signRaw interface. You possibly need to pass through an explicit keypair for the origin so it can be used for signing.');
+      }
+      return (await _signer.signRaw(spread.objectSpread({
+        type: 'bytes'
+      }, data, {
+        address
+      }))).signature;
+    }
+    return toHex.u8aToHex(address.sign(toU8a.u8aToU8a(data.data)));
+  }
+}
+
+exports.ApiBase = ApiBase;

package/dist/cjs/node_modules/@polkadot/api/packageInfo.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const packageInfo = {
+  name: '@polkadot/api',
+  path: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node_modules/@polkadot/api/packageInfo.js', document.baseURI).href)) }) && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node_modules/@polkadot/api/packageInfo.js', document.baseURI).href)) ? new URL((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node_modules/@polkadot/api/packageInfo.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('node_modules/@polkadot/api/packageInfo.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto',
+  version: '11.0.3'
+};
+
+exports.packageInfo = packageInfo;

package/dist/cjs/node_modules/@polkadot/api/promise/Api.js

@@ -0,0 +1,199 @@
+'use strict';
+
+var index = require('../base/index.js');
+var Combinator = require('./Combinator.js');
+var decorateMethod = require('./decorateMethod.js');
+var noop = require('../../util/noop.js');
+var spread = require('../../util/object/spread.js');
+
+/**
+ * # @polkadot/api/promise
+ *
+ * ## Overview
+ *
+ * @name ApiPromise
+ * @description
+ * ApiPromise is a standard JavaScript wrapper around the RPC and interfaces on the Polkadot network. As a full Promise-based, all interface calls return Promises, including the static `.create(...)`. Subscription calls utilise `(value) => {}` callbacks to pass through the latest values.
+ *
+ * The API is well suited to real-time applications where either the single-shot state is needed or use is to be made of the subscription-based features of Polkadot (and Substrate) clients.
+ *
+ * @see [[ApiRx]]
+ *
+ * ## Usage
+ *
+ * Making rpc calls -
+ * <BR>
+ *
+ * ```javascript
+ * import ApiPromise from '@polkadot/api/promise';
+ *
+ * // initialise via static create
+ * const api = await ApiPromise.create();
+ *
+ * // make a subscription to the network head
+ * api.rpc.chain.subscribeNewHeads((header) => {
+ *   console.log(`Chain is at #${header.number}`);
+ * });
+ * ```
+ * <BR>
+ *
+ * Subscribing to chain state -
+ * <BR>
+ *
+ * ```javascript
+ * import { ApiPromise, WsProvider } from '@polkadot/api';
+ *
+ * // initialise a provider with a specific endpoint
+ * const provider = new WsProvider('wss://example.com:9944')
+ *
+ * // initialise via isReady & new with specific provider
+ * const api = await new ApiPromise({ provider }).isReady;
+ *
+ * // retrieve the block target time
+ * const blockPeriod = await api.query.timestamp.blockPeriod().toNumber();
+ * let last = 0;
+ *
+ * // subscribe to the current block timestamp, updates automatically (callback provided)
+ * api.query.timestamp.now((timestamp) => {
+ *   const elapsed = last
+ *     ? `, ${timestamp.toNumber() - last}s since last`
+ *     : '';
+ *
+ *   last = timestamp.toNumber();
+ *   console.log(`timestamp ${timestamp}${elapsed} (${blockPeriod}s target)`);
+ * });
+ * ```
+ * <BR>
+ *
+ * Submitting a transaction -
+ * <BR>
+ *
+ * ```javascript
+ * import ApiPromise from '@polkadot/api/promise';
+ *
+ * ApiPromise.create().then((api) => {
+ *   const [nonce] = await api.query.system.account(keyring.alice.address);
+ *
+ *   api.tx.balances
+ *     // create transfer
+ *     transfer(keyring.bob.address, 12345)
+ *     // sign the transcation
+ *     .sign(keyring.alice, { nonce })
+ *     // send the transaction (optional status callback)
+ *     .send((status) => {
+ *       console.log(`current status ${status.type}`);
+ *     })
+ *     // retrieve the submitted extrinsic hash
+ *     .then((hash) => {
+ *       console.log(`submitted with hash ${hash}`);
+ *     });
+ * });
+ * ```
+ */
+class ApiPromise extends index.ApiBase {
+  __internal__isReadyPromise;
+  __internal__isReadyOrErrorPromise;
+  /**
+   * @description Creates an instance of the ApiPromise class
+   * @param options Options to create an instance. This can be either [[ApiOptions]] or
+   * an [[WsProvider]].
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * import Api from '@polkadot/api/promise';
+   *
+   * new Api().isReady.then((api) => {
+   *   api.rpc.subscribeNewHeads((header) => {
+   *     console.log(`new block #${header.number.toNumber()}`);
+   *   });
+   * });
+   * ```
+   */
+  constructor(options) {
+    super(options, 'promise', decorateMethod.toPromiseMethod);
+    this.__internal__isReadyPromise = new Promise(resolve => {
+      super.once('ready', () => resolve(this));
+    });
+    this.__internal__isReadyOrErrorPromise = new Promise((resolve, reject) => {
+      const tracker = decorateMethod.promiseTracker(resolve, reject);
+      super.once('ready', () => tracker.resolve(this));
+      super.once('error', error => tracker.reject(error));
+    });
+  }
+  /**
+   * @description Creates an ApiPromise instance using the supplied provider. Returns an Promise containing the actual Api instance.
+   * @param options options that is passed to the class contructor. Can be either [[ApiOptions]] or a
+   * provider (see the constructor arguments)
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * import Api from '@polkadot/api/promise';
+   *
+   * Api.create().then(async (api) => {
+   *   const timestamp = await api.query.timestamp.now();
+   *
+   *   console.log(`lastest block timestamp ${timestamp}`);
+   * });
+   * ```
+   */
+  static create(options) {
+    const instance = new ApiPromise(options);
+    if (options && options.throwOnConnect) {
+      return instance.isReadyOrError;
+    }
+    // Swallow any rejections on isReadyOrError
+    // (in Node 15.x this creates issues, when not being looked at)
+    instance.isReadyOrError.catch(noop.noop);
+    return instance.isReady;
+  }
+  /**
+   * @description Promise that resolves the first time we are connected and loaded
+   */
+  get isReady() {
+    return this.__internal__isReadyPromise;
+  }
+  /**
+   * @description Promise that resolves if we can connect, or reject if there is an error
+   */
+  get isReadyOrError() {
+    return this.__internal__isReadyOrErrorPromise;
+  }
+  /**
+   * @description Returns a clone of this ApiPromise instance (new underlying provider connection)
+   */
+  clone() {
+    return new ApiPromise(spread.objectSpread({}, this._options, {
+      source: this
+    }));
+  }
+  /**
+   * @description Creates a combinator that can be used to combine the latest results from multiple subscriptions
+   * @param fns An array of function to combine, each in the form of `(cb: (value: void)) => void`
+   * @param callback A callback that will return an Array of all the values this combinator has been applied to
+   * @example
+   * <BR>
+   *
+   * ```javascript
+   * const address = '5DTestUPts3kjeXSTMyerHihn1uwMfLj8vU8sqF7qYrFacT7';
+   *
+   * // combines values from balance & nonce as it updates
+   * api.combineLatest([
+   *   api.rpc.chain.subscribeNewHeads,
+   *   (cb) => api.query.system.account(address, cb)
+   * ], ([head, [balance, nonce]]) => {
+   *   console.log(`#${head.number}: You have ${balance.free} units, with ${nonce} transactions sent`);
+   * });
+   * ```
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async combineLatest(fns, callback) {
+    const combinator = new Combinator.Combinator(fns, callback);
+    return () => {
+      combinator.unsubscribe();
+    };
+  }
+}
+
+exports.ApiPromise = ApiPromise;

package/dist/cjs/node_modules/@polkadot/api/promise/Combinator.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var _function = require('../../util/is/function.js');
+var noop = require('../../util/noop.js');
+
+class Combinator {
+  __internal__allHasFired = false;
+  __internal__callback;
+  __internal__fired = [];
+  __internal__fns = [];
+  __internal__isActive = true;
+  __internal__results = [];
+  __internal__subscriptions = [];
+  constructor(fns, callback) {
+    this.__internal__callback = callback;
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises, @typescript-eslint/require-await
+    this.__internal__subscriptions = fns.map(async (input, index) => {
+      const [fn, ...args] = Array.isArray(input) ? input : [input];
+      this.__internal__fired.push(false);
+      this.__internal__fns.push(fn);
+      // Not quite 100% how to have a variable number at the front here
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return,@typescript-eslint/ban-types
+      return fn(...args, this._createCallback(index));
+    });
+  }
+  _allHasFired() {
+    this.__internal__allHasFired ||= this.__internal__fired.filter(hasFired => !hasFired).length === 0;
+    return this.__internal__allHasFired;
+  }
+  _createCallback(index) {
+    return value => {
+      this.__internal__fired[index] = true;
+      this.__internal__results[index] = value;
+      this._triggerUpdate();
+    };
+  }
+  _triggerUpdate() {
+    if (!this.__internal__isActive || !_function.isFunction(this.__internal__callback) || !this._allHasFired()) {
+      return;
+    }
+    try {
+      Promise.resolve(this.__internal__callback(this.__internal__results)).catch(noop.noop);
+    } catch {
+      // swallow, we don't want the handler to trip us up
+    }
+  }
+  unsubscribe() {
+    if (!this.__internal__isActive) {
+      return;
+    }
+    this.__internal__isActive = false;
+    Promise.all(this.__internal__subscriptions.map(async subscription => {
+      try {
+        const unsubscribe = await subscription;
+        if (_function.isFunction(unsubscribe)) {
+          unsubscribe();
+        }
+      } catch {
+        // ignore
+      }
+    })).catch(() => {
+      // ignore, already ignored above, should never throw
+    });
+  }
+}
+
+exports.Combinator = Combinator;

package/dist/cjs/node_modules/@polkadot/api/promise/decorateMethod.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var empty = require('../../../rxjs/dist/esm5/internal/observable/empty.js');
+var catchError = require('../../../rxjs/dist/esm5/internal/operators/catchError.js');
+var tap = require('../../../rxjs/dist/esm5/internal/operators/tap.js');
+var _function = require('../../util/is/function.js');
+var nextTick = require('../../util/nextTick.js');
+
+function promiseTracker(resolve, reject) {
+  let isCompleted = false;
+  return {
+    reject: error => {
+      if (!isCompleted) {
+        isCompleted = true;
+        reject(error);
+      }
+      return empty.EMPTY;
+    },
+    resolve: value => {
+      if (!isCompleted) {
+        isCompleted = true;
+        resolve(value);
+      }
+    }
+  };
+}
+function extractArgs(args, needsCallback) {
+  const actualArgs = args.slice();
+  // If the last arg is a function, we pop it, put it into callback.
+  // actualArgs will then hold the actual arguments to be passed to `method`
+  const callback = args.length && _function.isFunction(args[args.length - 1]) ? actualArgs.pop() : undefined;
+  // When we need a subscription, ensure that a valid callback is actually passed
+  if (needsCallback && !_function.isFunction(callback)) {
+    throw new Error('Expected a callback to be passed with subscriptions');
+  }
+  return [actualArgs, callback];
+}
+function decorateCall(method, args) {
+  return new Promise((resolve, reject) => {
+    // single result tracker - either reject with Error or resolve with Codec result
+    const tracker = promiseTracker(resolve, reject);
+    // encoding errors reject immediately, any result unsubscribes and resolves
+    const subscription = method(...args).pipe(catchError.catchError(error => tracker.reject(error))).subscribe(result => {
+      tracker.resolve(result);
+      nextTick.nextTick(() => subscription.unsubscribe());
+    });
+  });
+}
+function decorateSubscribe(method, args, resultCb) {
+  return new Promise((resolve, reject) => {
+    // either reject with error or resolve with unsubscribe callback
+    const tracker = promiseTracker(resolve, reject);
+    // errors reject immediately, the first result resolves with an unsubscribe promise, all results via callback
+    const subscription = method(...args).pipe(catchError.catchError(error => tracker.reject(error)), tap.tap(() => tracker.resolve(() => subscription.unsubscribe()))).subscribe(result => {
+      // queue result (back of queue to clear current)
+      nextTick.nextTick(() => resultCb(result));
+    });
+  });
+}
+/**
+ * @description Decorate method for ApiPromise, where the results are converted to the Promise equivalent
+ */
+function toPromiseMethod(method, options) {
+  const needsCallback = !!(options?.methodName && options.methodName.includes('subscribe'));
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    const [actualArgs, resultCb] = extractArgs(args, needsCallback);
+    return resultCb ? decorateSubscribe(method, actualArgs, resultCb) : decorateCall(options?.overrideNoSub || method, actualArgs);
+  };
+}
+
+exports.promiseTracker = promiseTracker;
+exports.toPromiseMethod = toPromiseMethod;

package/dist/cjs/node_modules/@polkadot/api/submittable/Result.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const recordIdentity = record => record;
+function filterAndApply(events, section, methods, onFound) {
+  return events.filter(_ref => {
+    let {
+      event
+    } = _ref;
+    return section === event.section && methods.includes(event.method);
+  }).map(record => onFound(record));
+}
+function getDispatchError(_ref2) {
+  let {
+    event: {
+      data: [dispatchError]
+    }
+  } = _ref2;
+  return dispatchError;
+}
+function getDispatchInfo(_ref3) {
+  let {
+    event: {
+      data,
+      method
+    }
+  } = _ref3;
+  return method === 'ExtrinsicSuccess' ? data[0] : data[1];
+}
+function extractError() {
+  let events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return filterAndApply(events, 'system', ['ExtrinsicFailed'], getDispatchError)[0];
+}
+function extractInfo() {
+  let events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return filterAndApply(events, 'system', ['ExtrinsicFailed', 'ExtrinsicSuccess'], getDispatchInfo)[0];
+}
+class SubmittableResult {
+  dispatchError;
+  dispatchInfo;
+  internalError;
+  events;
+  status;
+  txHash;
+  txIndex;
+  blockNumber;
+  constructor(_ref4) {
+    let {
+      blockNumber,
+      dispatchError,
+      dispatchInfo,
+      events,
+      internalError,
+      status,
+      txHash,
+      txIndex
+    } = _ref4;
+    this.dispatchError = dispatchError || extractError(events);
+    this.dispatchInfo = dispatchInfo || extractInfo(events);
+    this.events = events || [];
+    this.internalError = internalError;
+    this.status = status;
+    this.txHash = txHash;
+    this.txIndex = txIndex;
+    this.blockNumber = blockNumber;
+  }
+  get isCompleted() {
+    return this.isError || this.status.isInBlock || this.status.isFinalized;
+  }
+  get isError() {
+    return this.status.isDropped || this.status.isFinalityTimeout || this.status.isInvalid || this.status.isUsurped;
+  }
+  get isFinalized() {
+    return this.status.isFinalized;
+  }
+  get isInBlock() {
+    return this.status.isInBlock;
+  }
+  get isWarning() {
+    return this.status.isRetracted;
+  }
+  /**
+   * @description Filters EventRecords for the specified method & section (there could be multiple)
+   */
+  filterRecords(section, method) {
+    return filterAndApply(this.events, section, Array.isArray(method) ? method : [method], recordIdentity);
+  }
+  /**
+   * @description Finds an EventRecord for the specified method & section
+   */
+  findRecord(section, method) {
+    return this.filterRecords(section, method)[0];
+  }
+  /**
+   * @description Creates a human representation of the output
+   */
+  toHuman(isExtended) {
+    return {
+      dispatchError: this.dispatchError?.toHuman(),
+      dispatchInfo: this.dispatchInfo?.toHuman(),
+      events: this.events.map(e => e.toHuman(isExtended)),
+      internalError: this.internalError?.message.toString(),
+      status: this.status.toHuman(isExtended)
+    };
+  }
+}
+
+exports.SubmittableResult = SubmittableResult;