@ledgerhq/coin-polkadot 0.0.2

package/lib/api/websocket.js

@@ -0,0 +1,759 @@
+"use strict";
+/*
+THIS FILE IS UNUSED AND PROVIDED AS EXAMPLE FOR USING POLKADOT'S WEBSOCKET API DIRECTLY
+
+POLKADOT.JS API VERSION 2.5.1
+*/
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getRegistry = exports.getStakingProgress = exports.getValidators = exports.fetchIdentities = exports.fetchRewardPoints = exports.paymentInfo = exports.submitExtrinsic = exports.getTransactionParams = exports.getNominations = exports.getStakingInfo = exports.getBalances = exports.getAccount = exports.verifyValidatorAddresses = exports.isControllerAddress = exports.isNewAccount = exports.isElectionClosed = exports.disconnect = void 0;
+/* eslint-disable */
+/* istanbul ignore file */
+var uniq_1 = __importDefault(require("lodash/uniq"));
+var compact_1 = __importDefault(require("lodash/compact"));
+var bignumber_js_1 = require("bignumber.js");
+var env_1 = require("@ledgerhq/coin-framework/env");
+//@ts-expect-error
+var api_1 = require("@polkadot/api");
+var util_1 = require("@polkadot/util");
+var VALIDATOR_COMISSION_RATIO = 1000000000;
+var getWsUrl = function () { return (0, env_1.getEnv)("API_POLKADOT_NODE"); };
+var WEBSOCKET_DEBOUNCE_DELAY = 30000;
+var api;
+var pendingQueries = [];
+var apiDisconnectTimeout;
+/**
+ * Connects to Substrate Node, executes calls then disconnects
+ *
+ * @param {*} execute - the calls to execute on api
+ */
+function withApi(execute) {
+    return __awaiter(this, void 0, void 0, function () {
+        var err_1, wsProvider, query, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!api) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, api.isReadyOrError];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _a.sent();
+                    // definitely not connected...
+                    api = null;
+                    pendingQueries = [];
+                    return [3 /*break*/, 4];
+                case 4:
+                    if (!!api) return [3 /*break*/, 6];
+                    wsProvider = new api_1.WsProvider(getWsUrl(), 
+                    /* autoConnectMs = */
+                    false);
+                    wsProvider.connect();
+                    return [4 /*yield*/, new api_1.ApiPromise({
+                            provider: wsProvider
+                        }).isReadyOrError];
+                case 5:
+                    api = _a.sent();
+                    _a.label = 6;
+                case 6:
+                    cancelDebouncedDisconnect();
+                    _a.label = 7;
+                case 7:
+                    _a.trys.push([7, , 9, 10]);
+                    query = execute(api);
+                    pendingQueries.push(query["catch"](function (err) { return err; }));
+                    return [4 /*yield*/, query];
+                case 8:
+                    res = _a.sent();
+                    return [2 /*return*/, res];
+                case 9:
+                    debouncedDisconnect();
+                    return [7 /*endfinally*/];
+                case 10: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Disconnects Websocket API client after all pending queries are flushed.
+ */
+var disconnect = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var disconnecting, pending_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                cancelDebouncedDisconnect();
+                if (!api) return [3 /*break*/, 3];
+                disconnecting = api;
+                pending_1 = pendingQueries;
+                api = undefined;
+                pendingQueries = [];
+                return [4 /*yield*/, Promise.all(pending_1)];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/, disconnecting.disconnect()];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+exports.disconnect = disconnect;
+var cancelDebouncedDisconnect = function () {
+    if (apiDisconnectTimeout) {
+        clearTimeout(apiDisconnectTimeout);
+        apiDisconnectTimeout = null;
+    }
+};
+/**
+ * Disconnects Websocket client after a delay.
+ */
+var debouncedDisconnect = function () {
+    cancelDebouncedDisconnect();
+    apiDisconnectTimeout = setTimeout(exports.disconnect, WEBSOCKET_DEBOUNCE_DELAY);
+};
+/**
+ * Returns true if ElectionStatus is Close. If ElectionStatus is Open, some features must be disabled.
+ */
+var isElectionClosed = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var status, res;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.query.staking.eraElectionStatus()];
+                        case 1:
+                            status = _a.sent();
+                            res = status.isClose;
+                            return [2 /*return*/, !!res];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.isElectionClosed = isElectionClosed;
+/**
+ * Returns true if the address is a new account with no balance
+ *
+ * @param {*} addr
+ */
+var isNewAccount = function (address) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var _a, nonce, free;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, api.query.system.account(address)];
+                        case 1:
+                            _a = _b.sent(), nonce = _a.nonce, free = _a.data.free;
+                            return [2 /*return*/, (new bignumber_js_1.BigNumber(0).isEqualTo(nonce) && new bignumber_js_1.BigNumber(0).isEqualTo(free))];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.isNewAccount = isNewAccount;
+/**
+ * Returns true if the address is a new account with no balance
+ *
+ * @param {*} addr
+ */
+var isControllerAddress = function (address) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var ledgetOpt;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.query.staking.ledger(address)];
+                        case 1:
+                            ledgetOpt = _a.sent();
+                            return [2 /*return*/, ledgetOpt.isSome];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.isControllerAddress = isControllerAddress;
+/**
+ * Get all validators addresses to check for validity.
+ */
+var getValidatorsStashesAddresses = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var list;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.derive.staking.stashes()];
+                        case 1:
+                            list = _a.sent();
+                            return [2 /*return*/, list.map(function (v) { return v.toString(); })];
+                    }
+                });
+            }); })];
+    });
+}); };
+/**
+ * Returns all addresses that are not validators
+ */
+var verifyValidatorAddresses = function (validators) { return __awaiter(void 0, void 0, void 0, function () {
+    var allValidators;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getValidatorsStashesAddresses()];
+            case 1:
+                allValidators = _a.sent();
+                return [2 /*return*/, validators.filter(function (v) { return !allValidators.includes(v); })];
+        }
+    });
+}); };
+exports.verifyValidatorAddresses = verifyValidatorAddresses;
+/**
+ * Get all account-related data
+ *
+ * @param {*} addr
+ */
+var getAccount = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function () { return __awaiter(void 0, void 0, void 0, function () {
+                var balances, stakingInfo, nominations;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, (0, exports.getBalances)(addr)];
+                        case 1:
+                            balances = _a.sent();
+                            return [4 /*yield*/, (0, exports.getStakingInfo)(addr)];
+                        case 2:
+                            stakingInfo = _a.sent();
+                            return [4 /*yield*/, (0, exports.getNominations)(addr)];
+                        case 3:
+                            nominations = _a.sent();
+                            return [2 /*return*/, __assign(__assign(__assign({}, balances), stakingInfo), { nominations: nominations })];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.getAccount = getAccount;
+/**
+ * Returns all the balances for an account
+ *
+ * @param {*} addr - the account address
+ */
+var getBalances = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var _a, finalizedHash, balances, number;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, Promise.all([
+                                api.rpc.chain.getFinalizedHead(),
+                                api.derive.balances.all(addr),
+                            ])];
+                        case 1:
+                            _a = __read.apply(void 0, [_b.sent(), 2]), finalizedHash = _a[0], balances = _a[1];
+                            return [4 /*yield*/, api.rpc.chain.getHeader(finalizedHash)];
+                        case 2:
+                            number = (_b.sent()).number;
+                            return [2 /*return*/, {
+                                    blockHeight: number.toNumber(),
+                                    balance: new bignumber_js_1.BigNumber(balances.freeBalance),
+                                    spendableBalance: new bignumber_js_1.BigNumber(balances.availableBalance),
+                                    nonce: balances.accountNonce.toNumber(),
+                                    lockedBalance: new bignumber_js_1.BigNumber(balances.lockedBalance)
+                                }];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.getBalances = getBalances;
+/**
+ * Returns all staking-related data for an account
+ *
+ * @param {*} addr
+ */
+var getStakingInfo = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var _a, controlledLedgerOpt, bonded, stash, controller, _b, activeOpt, ledgerOpt, now, _c, index, start, activeEraIndex, activeEraStart, blockTime, epochDuration, eraLength, ledger, unlockings, unlocked, unlockingBalance, unlockedBalance;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0: return [4 /*yield*/, Promise.all([
+                                api.query.staking.ledger(addr),
+                                api.query.staking.bonded(addr),
+                            ])];
+                        case 1:
+                            _a = __read.apply(void 0, [_d.sent(), 2]), controlledLedgerOpt = _a[0], bonded = _a[1];
+                            stash = controlledLedgerOpt.isSome
+                                ? controlledLedgerOpt.unwrap().stash.toString()
+                                : null;
+                            controller = bonded.isSome ? bonded.unwrap().toString() : null;
+                            // If account is not a stash, no need to fetch corresponding ledger
+                            if (!controller) {
+                                return [2 /*return*/, {
+                                        controller: null,
+                                        stash: stash || null,
+                                        unlockedBalance: new bignumber_js_1.BigNumber(0),
+                                        unlockingBalance: new bignumber_js_1.BigNumber(0),
+                                        unlockings: []
+                                    }];
+                            }
+                            return [4 /*yield*/, Promise.all([
+                                    api.query.staking.activeEra(),
+                                    api.query.staking.ledger(controller),
+                                ])];
+                        case 2:
+                            _b = __read.apply(void 0, [_d.sent(), 2]), activeOpt = _b[0], ledgerOpt = _b[1];
+                            now = new Date();
+                            _c = activeOpt.unwrapOrDefault(), index = _c.index, start = _c.start;
+                            activeEraIndex = index.toNumber();
+                            activeEraStart = start.unwrap().toNumber();
+                            blockTime = api.consts.babe.expectedBlockTime;
+                            epochDuration = api.consts.babe.epochDuration;
+                            eraLength = api.consts.staking.sessionsPerEra // 6 sessions
+                                .mul(epochDuration)
+                                .mul(blockTime)
+                                .toNumber();
+                            ledger = ledgerOpt.isSome ? ledgerOpt.unwrap() : null;
+                            unlockings = ledger
+                                ? ledger.unlocking.map(function (lock) { return ({
+                                    amount: new bignumber_js_1.BigNumber(lock.value),
+                                    completionDate: new Date(activeEraStart + (lock.era - activeEraIndex) * eraLength)
+                                }); })
+                                : [];
+                            unlocked = unlockings.filter(function (lock) { return lock.completionDate <= now; });
+                            unlockingBalance = unlockings.reduce(function (sum, lock) { return sum.plus(lock.amount); }, new bignumber_js_1.BigNumber(0));
+                            unlockedBalance = unlocked.reduce(function (sum, lock) { return sum.plus(lock.amount); }, new bignumber_js_1.BigNumber(0));
+                            return [2 /*return*/, {
+                                    controller: controller,
+                                    stash: stash,
+                                    unlockedBalance: unlockedBalance,
+                                    unlockingBalance: unlockingBalance,
+                                    unlockings: unlockings
+                                }];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.getStakingInfo = getStakingInfo;
+/**
+ * Returns nominations for an account including validator address, status and associated stake.
+ *
+ * @param {*} addr
+ */
+var getNominations = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var _a, activeEra, nominationsOpt, targets, _b, exposures, stashes, allStashes;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0: return [4 /*yield*/, Promise.all([
+                                api.derive.session.indexes(),
+                                api.query.staking.nominators(addr),
+                            ])];
+                        case 1:
+                            _a = __read.apply(void 0, [_c.sent(), 2]), activeEra = _a[0].activeEra, nominationsOpt = _a[1];
+                            if (nominationsOpt.isNone)
+                                return [2 /*return*/, []];
+                            targets = nominationsOpt.unwrap().targets;
+                            return [4 /*yield*/, Promise.all([
+                                    api.query.staking.erasStakers.multi(targets.map(function (target) { return [activeEra, target]; })),
+                                    api.derive.staking.stashes(),
+                                ])];
+                        case 2:
+                            _b = __read.apply(void 0, [_c.sent(), 2]), exposures = _b[0], stashes = _b[1];
+                            allStashes = stashes.map(function (stash) { return stash.toString(); });
+                            return [2 /*return*/, targets.map(function (target, index) {
+                                    var exposure = exposures[index];
+                                    var individualExposure = exposure.others.find(function (o) { return o.who.toString() === addr; });
+                                    var value = individualExposure
+                                        ? new bignumber_js_1.BigNumber(individualExposure.value)
+                                        : new bignumber_js_1.BigNumber(0);
+                                    var status = exposure.others.length
+                                        ? individualExposure
+                                            ? "active"
+                                            : "inactive"
+                                        : allStashes.includes(target.toString())
+                                            ? "waiting"
+                                            : null;
+                                    return {
+                                        address: target.toString(),
+                                        value: value,
+                                        status: status
+                                    };
+                                })];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.getNominations = getNominations;
+/**
+ * Returns all the params from the chain to build an extrinsic (a transaction on Substrate)
+ */
+var getTransactionParams = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var chainName, blockHash, genesisHash, number, _a, specName, specVersion, transactionVersion;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, api.rpc.system.chain()];
+                        case 1:
+                            chainName = _b.sent();
+                            return [4 /*yield*/, api.rpc.chain.getFinalizedHead()];
+                        case 2:
+                            blockHash = _b.sent();
+                            return [4 /*yield*/, api.rpc.chain.getBlockHash(0)];
+                        case 3:
+                            genesisHash = _b.sent();
+                            return [4 /*yield*/, api.rpc.chain.getHeader(blockHash)];
+                        case 4:
+                            number = (_b.sent()).number;
+                            return [4 /*yield*/, api.rpc.state.getRuntimeVersion(blockHash)];
+                        case 5:
+                            _a = _b.sent(), specName = _a.specName, specVersion = _a.specVersion, transactionVersion = _a.transactionVersion;
+                            return [2 /*return*/, {
+                                    blockHash: blockHash,
+                                    blockNumber: number,
+                                    genesisHash: genesisHash,
+                                    chainName: chainName.toString(),
+                                    specName: specName.toString(),
+                                    specVersion: specVersion,
+                                    transactionVersion: transactionVersion
+                                }];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.getTransactionParams = getTransactionParams;
+/**
+ * Broadcast the transaction to the substrate node
+ *
+ * @param {string} extrinsic - the encoded extrinsic to send
+ */
+var submitExtrinsic = function (extrinsic) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var tx, hash;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            tx = api.tx(extrinsic);
+                            return [4 /*yield*/, api.rpc.author.submitExtrinsic(tx)];
+                        case 1:
+                            hash = _a.sent();
+                            return [2 /*return*/, hash];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.submitExtrinsic = submitExtrinsic;
+/**
+ * Retrieve the transaction fees and weights
+ * Note: fees on Substrate are not set by the signer, but directly by the blockchain runtime.
+ *
+ * @param {string} extrinsic - the encoded extrinsic to send with a fake signing
+ */
+var paymentInfo = function (extrinsic) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var info;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.rpc.payment.queryInfo(extrinsic)];
+                        case 1:
+                            info = _a.sent();
+                            return [2 /*return*/, info];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.paymentInfo = paymentInfo;
+/**
+ * Fetch all reward points for validators for current era
+ *
+ * @returns Map<String, BigNumber>
+ */
+var fetchRewardPoints = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var activeOpt, activeEra, individual, rewards;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, api.query.staking.activeEra()];
+                        case 1:
+                            activeOpt = _a.sent();
+                            activeEra = activeOpt.unwrapOrDefault().index;
+                            return [4 /*yield*/, api.query.staking.erasRewardPoints(activeEra)];
+                        case 2:
+                            individual = (_a.sent()).individual;
+                            rewards = new Map(__spreadArray([], __read(individual.entries()), false).map(function (_a) {
+                                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                                return [
+                                    k.toString(),
+                                    new bignumber_js_1.BigNumber(v.toString()),
+                                ];
+                            }));
+                            return [2 /*return*/, rewards];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.fetchRewardPoints = fetchRewardPoints;
+/**
+ * @source https://github.com/polkadot-js/api/blob/master/packages/api-derive/src/accounts/info.ts
+ */
+function dataAsString(data) {
+    return data.isRaw
+        ? (0, util_1.u8aToString)(data.asRaw.toU8a(true)).trim()
+        : data.isNone
+            ? ""
+            : data.toHex();
+}
+/**
+ * Fetch identity name of multiple addresses.
+ * Get parent identity if any, and concatenate parent name with child name.
+ *
+ * @param {string[]} addresses
+ */
+var fetchIdentities = function (addresses) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var superOfOpts, withParent, parentAddresses, _a, identities, parentIdentities, map;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, api.query.identity.superOf.multi(addresses)];
+                        case 1:
+                            superOfOpts = _b.sent();
+                            withParent = superOfOpts.map(function (superOfOpt) {
+                                return (superOfOpt === null || superOfOpt === void 0 ? void 0 : superOfOpt.isSome) ? superOfOpt === null || superOfOpt === void 0 ? void 0 : superOfOpt.unwrap() : undefined;
+                            });
+                            parentAddresses = (0, uniq_1["default"])((0, compact_1["default"])(withParent.map(function (superOf) { return superOf && superOf[0].toString(); })));
+                            return [4 /*yield*/, Promise.all([
+                                    api.query.identity.identityOf.multi(addresses),
+                                    api.query.identity.identityOf.multi(parentAddresses),
+                                ])];
+                        case 2:
+                            _a = __read.apply(void 0, [_b.sent(), 2]), identities = _a[0], parentIdentities = _a[1];
+                            map = new Map(addresses.map(function (addr, index) {
+                                var indexOfParent = withParent[index]
+                                    ? parentAddresses.indexOf(withParent[index][0].toString())
+                                    : -1;
+                                var identityOpt = indexOfParent > -1
+                                    ? parentIdentities[indexOfParent]
+                                    : identities[index];
+                                if (identityOpt.isNone) {
+                                    return [addr, ""];
+                                }
+                                var display = identityOpt.unwrap().info.display;
+                                var name = withParent[index]
+                                    ? "".concat(dataAsString(display), " / ").concat(dataAsString(withParent[index][1]))
+                                    : dataAsString(display);
+                                return [addr, name];
+                            }));
+                            return [2 /*return*/, map];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.fetchIdentities = fetchIdentities;
+/**
+ * Transforms each validator into an internal Validator type.
+ * @param {*} rewards - map of addres sand corresponding reward
+ * @param {*} identities - map of address and corresponding identity
+ * @param {*} elected - list of elected validator addresses
+ * @param {*} maxNominators - constant for oversubscribed validators
+ * @param {*} validator - the validator details to transform.
+ */
+var mapValidator = function (rewards, identities, elected, maxNominators, validator) {
+    var address = validator.accountId.toString();
+    return {
+        address: address,
+        identity: identities.get(address) || "",
+        nominatorsCount: validator.exposure.others.length,
+        rewardPoints: rewards.get(address) || null,
+        commission: new bignumber_js_1.BigNumber(validator.validatorPrefs.commission).dividedBy(VALIDATOR_COMISSION_RATIO),
+        totalBonded: new bignumber_js_1.BigNumber(validator.exposure.total),
+        selfBonded: new bignumber_js_1.BigNumber(validator.exposure.own),
+        isElected: elected.includes(address),
+        isOversubscribed: validator.exposure.others.length >= maxNominators
+    };
+};
+/**
+ * List all validators for the current era, and their exposure, and identity.
+ */
+var getValidators = function (stashes) {
+    if (stashes === void 0) { stashes = "elected"; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                    var _a, allStashes, elected, stashIds, allIds, electedIds, waitingIds, _b, validators, rewards, identities;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0: return [4 /*yield*/, Promise.all([
+                                    api.derive.staking.stashes(),
+                                    api.query.session.validators(),
+                                ])];
+                            case 1:
+                                _a = __read.apply(void 0, [_c.sent(), 2]), allStashes = _a[0], elected = _a[1];
+                                allIds = allStashes.map(function (s) { return s.toString(); });
+                                electedIds = elected.map(function (s) { return s.toString(); });
+                                if (Array.isArray(stashes)) {
+                                    stashIds = allIds.filter(function (s) { return stashes.includes(s); });
+                                }
+                                else if (stashes === "elected") {
+                                    stashIds = electedIds;
+                                }
+                                else {
+                                    waitingIds = allIds.filter(function (v) { return !electedIds.includes(v); });
+                                    if (stashes === "waiting") {
+                                        stashIds = waitingIds;
+                                    }
+                                    else {
+                                        // Keep elected in first positions
+                                        stashIds = __spreadArray(__spreadArray([], __read(electedIds), false), __read(waitingIds), false);
+                                    }
+                                }
+                                return [4 /*yield*/, Promise.all([
+                                        api.derive.staking.accounts(stashIds),
+                                        (0, exports.fetchRewardPoints)(),
+                                        (0, exports.fetchIdentities)(stashIds),
+                                    ])];
+                            case 2:
+                                _b = __read.apply(void 0, [_c.sent(), 3]), validators = _b[0], rewards = _b[1], identities = _b[2];
+                                return [2 /*return*/, validators.map(mapValidator.bind(null, rewards, identities, electedIds, api.consts.staking.maxNominatorRewardedPerValidator))];
+                        }
+                    });
+                }); })];
+        });
+    });
+};
+exports.getValidators = getValidators;
+/**
+ * Get Active Era progress
+ */
+var getStakingProgress = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                var _a, activeEraOpt, status, activeEra;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, Promise.all([
+                                api.query.staking.activeEra(),
+                                api.query.staking.eraElectionStatus(),
+                            ])];
+                        case 1:
+                            _a = __read.apply(void 0, [_b.sent(), 2]), activeEraOpt = _a[0], status = _a[1];
+                            activeEra = activeEraOpt.unwrapOrDefault().index;
+                            return [2 /*return*/, {
+                                    activeEra: activeEra.toNumber(),
+                                    electionClosed: !!status.isClose
+                                }];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.getStakingProgress = getStakingProgress;
+/**
+ * Return TypeRegistry and decorated extrinsics from client
+ */
+var getRegistry = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, withApi(function (api) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, {
+                            registry: api.registry,
+                            extrinsics: api.tx
+                        }];
+                });
+            }); })];
+    });
+}); };
+exports.getRegistry = getRegistry;
+//# sourceMappingURL=websocket.js.map