@ledgerhq/coin-polkadot 0.0.2

package/lib/api/sidecar.js

@@ -0,0 +1,844 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.getTransactionMaterialWithMetadata = exports.getConstants = exports.getRegistry = exports.getStakingProgress = exports.getValidators = exports.paymentInfo = exports.submitExtrinsic = exports.getTransactionParams = exports.getNominations = exports.getStakingInfo = exports.getAccount = exports.verifyValidatorAddresses = exports.isControllerAddress = exports.isNewAccount = exports.isElectionClosed = exports.disconnect = exports.getMinimumBondBalance = void 0;
+var bignumber_js_1 = require("bignumber.js");
+var querystring_1 = __importDefault(require("querystring"));
+var types_1 = require("@polkadot/types");
+var types_known_1 = require("@polkadot/types-known");
+var metadata_1 = require("@polkadot/types/metadata");
+var decorate_1 = require("@polkadot/types/metadata/decorate");
+var cache_1 = require("@ledgerhq/coin-framework/cache");
+var env_1 = require("@ledgerhq/coin-framework/env");
+var network_1 = __importDefault(require("@ledgerhq/coin-framework/network"));
+/**
+ * Get indexer base url.
+ *
+ * @returns {string}
+ */
+var getBaseSidecarUrl = function () { return (0, env_1.getEnv)("API_POLKADOT_SIDECAR"); };
+/**
+ * Returns the full indexer url for en route endpoint.
+ *
+ * @param {*} route
+ *
+ * @returns {string}
+ */
+var getSidecarUrl = function (route) { return "".concat(getBaseSidecarUrl()).concat(route || ""); };
+var VALIDATOR_COMISSION_RATIO = 1000000000;
+var ELECTION_STATUS_OPTIMISTIC_THRESHOLD = (0, env_1.getEnv)("POLKADOT_ELECTION_STATUS_THRESHOLD") || 25;
+// blocks = 2 minutes 30
+/**
+ * Fetch Balance from the api.
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {SidecarAccountBalanceInfo}
+ */
+var fetchBalanceInfo = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/accounts/".concat(addr, "/balance-info"))
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+/**
+ * Fetch the stash address associated to an account.
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {string}
+ */
+var fetchStashAddr = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/pallets/staking/storage/ledger?keys[]=".concat(addr, "&key1=").concat(addr))
+                })];
+            case 1:
+                data = (_c.sent()).data;
+                return [2 /*return*/, (_b = (_a = data.value) === null || _a === void 0 ? void 0 : _a.stash) !== null && _b !== void 0 ? _b : null];
+        }
+    });
+}); };
+/**
+ * Fetch the controller address associated to an account.
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {string}
+ */
+var fetchControllerAddr = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/pallets/staking/storage/bonded?keys[]=".concat(addr, "&key1=").concat(addr))
+                })];
+            case 1:
+                data = (_b.sent()).data;
+                return [2 /*return*/, (_a = data.value) !== null && _a !== void 0 ? _a : null];
+        }
+    });
+}); };
+/**
+ * Fetch the staking info for an account.
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {SidecarStakingInfo}
+ */
+var fetchStakingInfo = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/accounts/".concat(addr, "/staking-info"))
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+/**
+ * Returns the list of nominations for an account, with status and associated stake if relevant.
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {SidecarNominations}
+ */
+var fetchNominations = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/accounts/".concat(addr, "/nominations"))
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+/**
+ * Returns the blockchain's runtime constants.
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {Object}
+ */
+var fetchConstants = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/runtime/constants")
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data.consts];
+        }
+    });
+}); };
+/**
+ * Returns the activeEra info
+ *
+ * @async
+ *
+ * @returns {SidecarPalletStorageItem}
+ */
+var fetchActiveEra = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/pallets/staking/storage/activeEra")
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+/**
+ * Fetch the minimum value allowed for a bond
+ *
+ * @async
+ * @param {string} addr
+ *
+ * @returns {string}
+ */
+var getMinimumBondBalance = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/pallets/staking/storage/minNominatorBond")
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, (data.value && new bignumber_js_1.BigNumber(data.value)) || new bignumber_js_1.BigNumber(0)];
+        }
+    });
+}); };
+exports.getMinimumBondBalance = getMinimumBondBalance;
+/**
+ * Fetch a list of validators with some info and indentity.
+ * It fetches the list providing a status (all, elected, waiting) and/or a list of
+ * addresses (comma-separated or as multiple query params).
+ *
+ * @async
+ * @param {string} status
+ * @param {string[]} addresses
+ *
+ * @returns {SidecarValidators}
+ */
+var fetchValidators = function (status, addresses) {
+    if (status === void 0) { status = "all"; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var params, data;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = {};
+                    if (status) {
+                        params = __assign(__assign({}, params), { status: status });
+                    }
+                    if (addresses && addresses.length) {
+                        params = __assign(__assign({}, params), { addresses: addresses.join(",") });
+                    }
+                    return [4 /*yield*/, (0, network_1["default"])({
+                            method: "GET",
+                            url: getSidecarUrl("/validators?".concat(querystring_1["default"].stringify(params)))
+                        })];
+                case 1:
+                    data = (_a.sent()).data;
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+};
+/**
+ * Fetch the progress info concerning staking.
+ *
+ * @async
+ *
+ * @returns {SidecarPalletStakingProgress}
+ */
+var fetchStakingProgress = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/pallets/staking/progress")
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+/**
+ * Fetch the transaction params needed to sign a transaction
+ *
+ * @async
+ *
+ * @returns {SidecarTransactionMaterial}
+ */
+var fetchTransactionMaterial = function (
+// By default we don't want any metadata.
+withMetadata) {
+    if (withMetadata === void 0) { withMetadata = false; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var params, data;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    params = withMetadata ? "?metadata=scale" : "?noMeta=true";
+                    return [4 /*yield*/, (0, network_1["default"])({
+                            method: "GET",
+                            url: getSidecarUrl("/transaction/material".concat(params))
+                        })];
+                case 1:
+                    data = (_a.sent()).data;
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+};
+/**
+ * Fetch the blockchain specs
+ *
+ * @async
+ *
+ * @returns {SidecarRuntimeSpec}
+ */
+var fetchChainSpec = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "GET",
+                    url: getSidecarUrl("/runtime/spec")
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+// Not relevant when not using websocket
+var disconnect = function () { };
+exports.disconnect = disconnect;
+/**
+ * Returns true if ElectionStatus is Close.
+ * If ElectionStatus is Open, some features must be disabled.
+ *
+ * @async
+ *
+ * @returns {boolean}
+ */
+var isElectionClosed = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var progress;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, fetchStakingProgress()];
+            case 1:
+                progress = _c.sent();
+                return [2 /*return*/, !((_b = (_a = progress.electionStatus) === null || _a === void 0 ? void 0 : _a.status) === null || _b === void 0 ? void 0 : _b.Open)];
+        }
+    });
+}); };
+exports.isElectionClosed = isElectionClosed;
+/**
+ * Returns true if the address is a new account with no balance.
+ *
+ * @async
+ * @param {*} addr
+ *
+ * @returns {boolean}
+ */
+var isNewAccount = function (addr) { 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*/, fetchBalanceInfo(addr)];
+            case 1:
+                _a = _b.sent(), nonce = _a.nonce, free = _a.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 controller, i.e. it is associated to a stash.
+ *
+ * @async
+ * @param {*} addr
+ *
+ * @returns {boolean}
+ */
+var isControllerAddress = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var stash;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fetchStashAddr(addr)];
+            case 1:
+                stash = _a.sent();
+                return [2 /*return*/, !!stash];
+        }
+    });
+}); };
+exports.isControllerAddress = isControllerAddress;
+/**
+ * Returns all addresses that are not validators.
+ *
+ * @async
+ * @param {string[]} - address to verify
+ *
+ * @returns {string[]} - addresses that are not validators
+ */
+var verifyValidatorAddresses = function (validators) { return __awaiter(void 0, void 0, void 0, function () {
+    var existingValidators, existingIds;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fetchValidators("all", validators)];
+            case 1:
+                existingValidators = _a.sent();
+                existingIds = existingValidators.map(function (v) { return v.accountId; });
+                return [2 /*return*/, validators.filter(function (v) { return !existingIds.includes(v); })];
+        }
+    });
+}); };
+exports.verifyValidatorAddresses = verifyValidatorAddresses;
+/**
+ * Get all account-related data
+ *
+ * @async
+ * @param {*} addr
+ */
+var getAccount = function (addr) { 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*/, 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
+ *
+ * @async
+ * @param {*} addr - the account address
+ */
+var getBalances = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var balanceInfo, totalLocked, balance, spendableBalance;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, fetchBalanceInfo(addr)];
+            case 1:
+                balanceInfo = _b.sent();
+                totalLocked = balanceInfo.locks.reduce(function (total, lock) {
+                    var amount = new bignumber_js_1.BigNumber(lock.amount);
+                    if (amount.gt(total)) {
+                        return amount;
+                    }
+                    return total;
+                }, new bignumber_js_1.BigNumber(0));
+                balance = new bignumber_js_1.BigNumber(balanceInfo.free);
+                spendableBalance = totalLocked.gt(balance)
+                    ? new bignumber_js_1.BigNumber(0)
+                    : balance.minus(totalLocked);
+                return [2 /*return*/, {
+                        blockHeight: ((_a = balanceInfo.at) === null || _a === void 0 ? void 0 : _a.height) ? Number(balanceInfo.at.height) : null,
+                        balance: balance,
+                        spendableBalance: spendableBalance,
+                        nonce: Number(balanceInfo.nonce),
+                        lockedBalance: new bignumber_js_1.BigNumber(balanceInfo.miscFrozen)
+                    }];
+        }
+    });
+}); };
+/**
+ * Returns all staking-related data for an account
+ *
+ * @async
+ * @param {*} addr
+ */
+var getStakingInfo = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, stash, controller, _b, stakingInfo, activeEra, consts, activeEraIndex, activeEraStart, blockTime, epochDuration, sessionsPerEra, eraLength, unlockings, now, unlocked, unlockingBalance, unlockedBalance, numSlashingSpans;
+    var _c, _d, _e, _f, _g, _h;
+    return __generator(this, function (_j) {
+        switch (_j.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    fetchStashAddr(addr),
+                    fetchControllerAddr(addr),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_j.sent(), 2]), stash = _a[0], controller = _a[1];
+                // If account is not a stash, no need to fetch staking-info (it would return an error)
+                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([
+                        fetchStakingInfo(addr),
+                        fetchActiveEra(),
+                        (0, exports.getConstants)(),
+                    ])];
+            case 2:
+                _b = __read.apply(void 0, [_j.sent(), 3]), stakingInfo = _b[0], activeEra = _b[1], consts = _b[2];
+                activeEraIndex = Number(((_c = activeEra.value) === null || _c === void 0 ? void 0 : _c.index) || 0);
+                activeEraStart = Number(((_d = activeEra.value) === null || _d === void 0 ? void 0 : _d.start) || 0);
+                blockTime = new bignumber_js_1.BigNumber(((_e = consts === null || consts === void 0 ? void 0 : consts.babe) === null || _e === void 0 ? void 0 : _e.expectedBlockTime) || 6000);
+                epochDuration = new bignumber_js_1.BigNumber(((_f = consts === null || consts === void 0 ? void 0 : consts.babe) === null || _f === void 0 ? void 0 : _f.epochDuration) || 2400);
+                sessionsPerEra = new bignumber_js_1.BigNumber(((_g = consts === null || consts === void 0 ? void 0 : consts.staking) === null || _g === void 0 ? void 0 : _g.sessionsPerEra) || 6);
+                eraLength = sessionsPerEra
+                    .multipliedBy(epochDuration)
+                    .multipliedBy(blockTime)
+                    .toNumber();
+                unlockings = (stakingInfo === null || stakingInfo === void 0 ? void 0 : stakingInfo.staking.unlocking)
+                    ? (_h = stakingInfo === null || stakingInfo === void 0 ? void 0 : stakingInfo.staking) === null || _h === void 0 ? void 0 : _h.unlocking.map(function (lock) { return ({
+                        amount: new bignumber_js_1.BigNumber(lock.value),
+                        completionDate: new Date(activeEraStart + (Number(lock.era) - activeEraIndex) * eraLength)
+                    }); })
+                    : [];
+                now = new Date();
+                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));
+                numSlashingSpans = Number((stakingInfo === null || stakingInfo === void 0 ? void 0 : stakingInfo.numSlashingSpans) || 0);
+                return [2 /*return*/, {
+                        controller: controller || null,
+                        stash: stash || null,
+                        unlockedBalance: unlockedBalance,
+                        unlockingBalance: unlockingBalance,
+                        unlockings: unlockings,
+                        numSlashingSpans: numSlashingSpans
+                    }];
+        }
+    });
+}); };
+exports.getStakingInfo = getStakingInfo;
+/**
+ * Returns nominations for an account including validator address, status and associated stake.
+ *
+ * @async
+ * @param {*} addr
+ *
+ * @returns {PolkadotNomination[}
+ */
+var getNominations = function (addr) { return __awaiter(void 0, void 0, void 0, function () {
+    var nominations;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fetchNominations(addr)];
+            case 1:
+                nominations = _a.sent();
+                if (!nominations)
+                    return [2 /*return*/, []];
+                return [2 /*return*/, nominations.targets.map(function (nomination) { return ({
+                        address: nomination.address,
+                        value: new bignumber_js_1.BigNumber(nomination.value || 0),
+                        status: nomination.status
+                    }); })];
+        }
+    });
+}); };
+exports.getNominations = getNominations;
+/**
+ * Returns all the params from the chain to build an extrinsic (a transaction on Substrate)
+ *
+ * @async
+ */
+var getTransactionParams = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var material;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fetchTransactionMaterial()];
+            case 1:
+                material = _a.sent();
+                return [2 /*return*/, {
+                        blockHash: material.at.hash,
+                        blockNumber: material.at.height,
+                        chainName: material.chainName,
+                        genesisHash: material.genesisHash,
+                        specName: material.specName,
+                        transactionVersion: material.txVersion,
+                        specVersion: material.specVersion
+                    }];
+        }
+    });
+}); };
+exports.getTransactionParams = getTransactionParams;
+/**
+ * Broadcast the transaction to the substrate node
+ *
+ * @async
+ * @param {string} extrinsic - the encoded extrinsic to send
+ *
+ * @returns {string>} - the broadcasted transaction's hah
+ */
+var submitExtrinsic = function (extrinsic) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "POST",
+                    url: getSidecarUrl("/transaction"),
+                    data: {
+                        tx: extrinsic
+                    }
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data.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.
+ *
+ * @async
+ * @param {string} extrinsic - the encoded extrinsic to send with a fake signing
+ *
+ * @returns {SidecarPaymentInfo}
+ */
+var paymentInfo = function (extrinsic) { return __awaiter(void 0, void 0, void 0, function () {
+    var data;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, network_1["default"])({
+                    method: "POST",
+                    url: getSidecarUrl("/transaction/fee-estimate"),
+                    data: {
+                        tx: extrinsic
+                    }
+                })];
+            case 1:
+                data = (_a.sent()).data;
+                return [2 /*return*/, data];
+        }
+    });
+}); };
+exports.paymentInfo = paymentInfo;
+/**
+ * List all validators for the current era, and their exposure, and identity.
+ *
+ * @async
+ * @param {string | string[]} stashes - stashes or validator status
+ *
+ * @returns {PolkadotValidator[]}
+ */
+var getValidators = function (stashes) {
+    if (stashes === void 0) { stashes = "elected"; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var validators;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!Array.isArray(stashes)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fetchValidators("all", stashes)];
+                case 1:
+                    validators = _a.sent();
+                    return [3 /*break*/, 4];
+                case 2: return [4 /*yield*/, fetchValidators(stashes)];
+                case 3:
+                    validators = _a.sent();
+                    _a.label = 4;
+                case 4: return [2 /*return*/, validators.map(function (v) { return ({
+                        address: v.accountId,
+                        identity: v.identity
+                            ? [v.identity.displayParent, v.identity.display]
+                                .filter(Boolean)
+                                .join(" - ")
+                                .trim()
+                            : "",
+                        nominatorsCount: Number(v.nominatorsCount),
+                        rewardPoints: v.rewardsPoints ? new bignumber_js_1.BigNumber(v.rewardsPoints) : null,
+                        commission: new bignumber_js_1.BigNumber(v.commission).dividedBy(VALIDATOR_COMISSION_RATIO),
+                        totalBonded: new bignumber_js_1.BigNumber(v.total),
+                        selfBonded: new bignumber_js_1.BigNumber(v.own),
+                        isElected: v.isElected,
+                        isOversubscribed: v.isOversubscribed
+                    }); })];
+            }
+        });
+    });
+};
+exports.getValidators = getValidators;
+/**
+ * Get Active Era progress
+ *
+ * @async
+ *
+ * @returns {PolkadotStakingProgress}
+ */
+var getStakingProgress = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, progress, consts, activeEra, currentBlock, toggleEstimate, electionClosed, optimisticElectionClosed;
+    var _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    fetchStakingProgress(),
+                    (0, exports.getConstants)(),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_e.sent(), 2]), progress = _a[0], consts = _a[1];
+                activeEra = Number(progress.activeEra);
+                currentBlock = Number(progress.at.height);
+                toggleEstimate = Number((_b = progress.electionStatus) === null || _b === void 0 ? void 0 : _b.toggleEstimate);
+                electionClosed = !((_d = (_c = progress.electionStatus) === null || _c === void 0 ? void 0 : _c.status) === null || _d === void 0 ? void 0 : _d.Open);
+                optimisticElectionClosed = electionClosed &&
+                    activeEra &&
+                    currentBlock &&
+                    toggleEstimate &&
+                    currentBlock >= toggleEstimate - ELECTION_STATUS_OPTIMISTIC_THRESHOLD
+                    ? false
+                    : electionClosed;
+                return [2 /*return*/, {
+                        activeEra: activeEra,
+                        electionClosed: optimisticElectionClosed,
+                        maxNominatorRewardedPerValidator: Number(consts.staking.maxNominatorRewardedPerValidator) || 128,
+                        bondingDuration: Number(consts.staking.bondingDuration) || 28
+                    }];
+        }
+    });
+}); };
+exports.getStakingProgress = getStakingProgress;
+/**
+ * Create a new Registry for creating Polkadot.JS types (or any Substrate)
+ *
+ * @async
+ *
+ * @returns {Object} - { registry, extrinsics }
+ */
+var getRegistry = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, material, spec, registry, metadata, extrinsics;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    (0, exports.getTransactionMaterialWithMetadata)(),
+                    fetchChainSpec(),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_b.sent(), 2]), material = _a[0], spec = _a[1];
+                registry = new types_1.TypeRegistry();
+                metadata = new metadata_1.Metadata(registry, material.metadata);
+                // Register types specific to chain/runtimeVersion
+                registry.register((0, types_known_1.getSpecTypes)(registry, material.chainName, material.specName, Number(material.specVersion)));
+                // Register the chain properties for this registry
+                registry.setChainProperties(registry.createType("ChainProperties", {
+                    ss58Format: Number(spec.properties.ss58Format),
+                    tokenDecimals: Number(spec.properties.tokenDecimals),
+                    tokenSymbol: spec.properties.tokenSymbol
+                }));
+                registry.setMetadata(metadata);
+                extrinsics = (0, decorate_1.expandMetadata)(registry, metadata).tx;
+                return [2 /*return*/, {
+                        registry: registry,
+                        extrinsics: extrinsics
+                    }];
+        }
+    });
+}); };
+exports.getRegistry = getRegistry;
+/*
+ * CACHED REQUESTS
+ * NOTE: we don't use the cache from family's `cache.js` to avoid cyclic imports.
+ */
+/**
+ * Cache the fetchConstants to avoid too many calls
+ *
+ * @async
+ *
+ * @returns {Promise<Object>} consts
+ */
+exports.getConstants = (0, cache_1.makeLRUCache)(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    return [2 /*return*/, fetchConstants()];
+}); }); }, function () { return "polkadot"; }, {
+    max: 1,
+    ttl: 60 * 60 * 1000
+});
+/**
+ * Cache the fetchTransactionMaterial(true) to avoid too many calls
+ *
+ * @async
+ *
+ * @returns {Promise<Object>} consts
+ */
+exports.getTransactionMaterialWithMetadata = (0, cache_1.makeLRUCache)(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    return [2 /*return*/, fetchTransactionMaterial(true)];
+}); }); }, function () { return "polkadot"; }, {
+    ttl: 60 * 60 * 1000
+});
+//# sourceMappingURL=sidecar.js.map