@airgap/substrate 0.13.45-beta.3 → 0.13.45-beta.4

package/v0/protocol/SubstrateDelegateProtocol.js

@@ -1,321 +1,566 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 (_) 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 __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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubstrateDelegateProtocol = void 0;
-const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-const assert_1 = require("@airgap/coinlib-core/utils/assert");
-const SubstratePayee_1 = require("./common/data/staking/SubstratePayee");
-const SubstrateStakingActionType_1 = require("./common/data/staking/SubstrateStakingActionType");
-const SubstrateTransaction_1 = require("./common/data/transaction/SubstrateTransaction");
-const SubstrateProtocol_1 = require("./SubstrateProtocol");
-class SubstrateDelegateProtocol extends SubstrateProtocol_1.SubstrateProtocol {
-    async getDefaultDelegatee() {
-        if (this.defaultValidator) {
-            return this.defaultValidator;
-        }
-        const validators = await this.options.nodeClient.getValidators();
-        return validators ? validators[0].asString() : '';
-    }
-    async getCurrentDelegateesForPublicKey(publicKey) {
-        return this.options.accountController.getCurrentValidators(publicKey);
-    }
-    async getCurrentDelegateesForAddress(address) {
-        return this.options.accountController.getCurrentValidators(address);
-    }
-    async getDelegateeDetails(address) {
-        const validatorDetails = await this.options.accountController.getValidatorDetails(address);
-        return {
-            name: validatorDetails.name || '',
-            status: validatorDetails.status || '',
-            address
-        };
-    }
-    async isPublicKeyDelegating(publicKey) {
-        return this.options.accountController.isDelegating(publicKey);
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var assert_1 = require("@airgap/coinlib-core/utils/assert");
+var SubstratePayee_1 = require("./common/data/staking/SubstratePayee");
+var SubstrateStakingActionType_1 = require("./common/data/staking/SubstrateStakingActionType");
+var SubstrateTransaction_1 = require("./common/data/transaction/SubstrateTransaction");
+var SubstrateProtocol_1 = require("./SubstrateProtocol");
+var SubstrateDelegateProtocol = /** @class */ (function (_super) {
+    __extends(SubstrateDelegateProtocol, _super);
+    function SubstrateDelegateProtocol() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    async isAddressDelegating(address) {
-        return this.options.accountController.isDelegating(address);
-    }
-    async getDelegatorDetailsFromPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getDelegatorDetailsFromAddress(address.address);
-    }
-    async getDelegatorDetailsFromAddress(address) {
-        return this.options.accountController.getNominatorDetails(address);
-    }
-    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getDelegationDetailsFromAddress(address.address, delegatees);
-    }
-    async getDelegationDetailsFromAddress(address, delegatees) {
-        const [nominatorDetails, validatorsDetails] = await Promise.all([
-            this.options.accountController.getNominatorDetails(address, delegatees),
-            Promise.all(delegatees.map((validator) => this.options.accountController.getValidatorDetails(validator)))
-        ]);
-        nominatorDetails.rewards =
-            nominatorDetails.delegatees.length > 0 && nominatorDetails.stakingDetails
-                ? nominatorDetails.stakingDetails.rewards.map((reward) => ({
-                    index: reward.eraIndex,
-                    amount: reward.amount,
-                    timestamp: reward.timestamp
-                }))
-                : [];
-        return {
-            delegator: nominatorDetails,
-            delegatees: validatorsDetails
-        };
-    }
-    // tslint:disable-next-line: cyclomatic-complexity
-    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
-        if (!data) {
-            data = {};
-        }
-        switch (type) {
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.BOND_NOMINATE:
-                (0, assert_1.assertFields)(`${type} action`, data, 'targets', 'value', 'payee');
-                return this.prepareNomination(publicKey, data.tip || 0, data.targets, data.controller || publicKey, data.value, data.payee);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.REBOND_NOMINATE:
-                (0, assert_1.assertFields)(`${type} action`, data, 'targets', 'value');
-                return this.prepareRebondNominate(publicKey, data.tip || 0, data.targets, data.value);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.NOMINATE:
-                (0, assert_1.assertFields)(`${type} action`, data, 'targets');
-                return this.prepareNomination(publicKey, data.tip || 0, data.targets);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.CANCEL_NOMINATION:
-                return this.prepareScheduleUndelegate(publicKey, data.tip || 0, data.value);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.CHANGE_NOMINATION:
-                (0, assert_1.assertFields)(`${type} action`, data, 'targets');
-                return this.prepareChangeValidator(publicKey, data.tip || 0, data.targets);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.UNBOND:
-                (0, assert_1.assertFields)(`${type} action`, data, 'value');
-                return this.prepareUnbond(publicKey, data.tip || 0, data.value);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.REBOND:
-                (0, assert_1.assertFields)(`${type} action`, data, 'value');
-                return this.prepareRebond(publicKey, data.tip || 0, data.value);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.BOND_EXTRA:
-                (0, assert_1.assertFields)(`${type} action`, data, 'value');
-                return this.prepareBondExtra(publicKey, data.tip || 0, data.value);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.REBOND_EXTRA:
-                (0, assert_1.assertFields)(`${type} action`, data, 'value');
-                return this.prepareRebondExtra(publicKey, data.tip || 0, data.value);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.WITHDRAW_UNBONDED:
-                return this.prepareWithdrawUnbonded(publicKey, data.tip || 0);
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.CHANGE_REWARD_DESTINATION:
-                return Promise.reject('Unsupported delegator action.');
-            case SubstrateStakingActionType_1.SubstrateStakingActionType.CHANGE_CONTROLLER:
-                return Promise.reject('Unsupported delegator action.');
-            default:
-                return Promise.reject('Unsupported delegator action.');
-        }
-    }
-    async prepareNomination(publicKey, tip, targets, controller, value, payee) {
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, false, false);
-        const available = new bignumber_1.default(transferableBalance).minus(value || 0);
-        const bondFirst = controller !== undefined && value !== undefined && payee !== undefined;
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, available, [
-            ...(bondFirst
-                ? [
-                    {
-                        type: SubstrateTransaction_1.SubstrateTransactionType.BOND,
-                        tip,
-                        args: {
-                            controller,
-                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value),
-                            payee: typeof payee === 'string' ? SubstratePayee_1.SubstratePayee[payee] : payee
+    SubstrateDelegateProtocol.prototype.getDefaultDelegatee = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var validators;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.defaultValidator) {
+                            return [2 /*return*/, this.defaultValidator];
                         }
-                    }
-                ]
-                : []),
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
-                tip,
-                args: {
-                    targets: typeof targets === 'string' ? [targets] : targets
+                        return [4 /*yield*/, this.options.nodeClient.getValidators()];
+                    case 1:
+                        validators = _a.sent();
+                        return [2 /*return*/, validators ? validators[0].asString() : ''];
                 }
-            }
-        ]);
-        return [{ encoded }];
-    }
-    async prepareRebondNominate(publicKey, tip, targets, value) {
-        const [transferableBalance, lockedBalance] = await Promise.all([
-            this.options.accountController.getTransferableBalance(publicKey, false, false),
-            this.options.accountController.getUnlockingBalance(publicKey)
-        ]);
-        const toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
-        const configs = [];
-        if (toDelegate.gt(lockedBalance)) {
-            configs.push({
-                type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
-                tip,
-                args: {
-                    value: lockedBalance
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getCurrentDelegateesForPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getCurrentValidators(publicKey)];
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getCurrentDelegateesForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getCurrentValidators(address)];
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getDelegateeDetails = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validatorDetails;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getValidatorDetails(address)];
+                    case 1:
+                        validatorDetails = _a.sent();
+                        return [2 /*return*/, {
+                                name: validatorDetails.name || '',
+                                status: validatorDetails.status || '',
+                                address: address
+                            }];
+                }
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.isPublicKeyDelegating = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.isDelegating(publicKey)];
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.isAddressDelegating = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.isDelegating(address)];
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getDelegatorDetailsFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getDelegatorDetailsFromAddress(address.address)];
                 }
-            }, {
-                type: SubstrateTransaction_1.SubstrateTransactionType.BOND_EXTRA,
-                tip,
-                args: {
-                    value: toDelegate.minus(lockedBalance)
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getDelegatorDetailsFromAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getNominatorDetails(address)];
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getDelegationDetailsFromPublicKey = function (publicKey, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getDelegationDetailsFromAddress(address.address, delegatees)];
                 }
             });
-        }
-        else {
-            configs.push({
-                type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
-                tip,
-                args: {
-                    value: toDelegate
+        });
+    };
+    SubstrateDelegateProtocol.prototype.getDelegationDetailsFromAddress = function (address, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, nominatorDetails, validatorsDetails;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getNominatorDetails(address, delegatees),
+                            Promise.all(delegatees.map(function (validator) { return _this.options.accountController.getValidatorDetails(validator); }))
+                        ])];
+                    case 1:
+                        _a = _b.sent(), nominatorDetails = _a[0], validatorsDetails = _a[1];
+                        nominatorDetails.rewards =
+                            nominatorDetails.delegatees.length > 0 && nominatorDetails.stakingDetails
+                                ? nominatorDetails.stakingDetails.rewards.map(function (reward) { return ({
+                                    index: reward.eraIndex,
+                                    amount: reward.amount,
+                                    timestamp: reward.timestamp
+                                }); })
+                                : [];
+                        return [2 /*return*/, {
+                                delegator: nominatorDetails,
+                                delegatees: validatorsDetails
+                            }];
                 }
             });
-        }
-        configs.push({
-            type: SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
-            tip,
-            args: {
-                targets: typeof targets === 'string' ? [targets] : targets
-            }
         });
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, configs);
-        return [{ encoded }];
-    }
-    async prepareScheduleUndelegate(publicKey, tip, value) {
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, false, false);
-        const keepController = value === undefined;
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION,
-                tip,
-                args: {}
-            },
-            ...(keepController
-                ? []
-                : [
-                    {
-                        type: SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
-                        tip,
-                        args: {
-                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+    };
+    // tslint:disable-next-line: cyclomatic-complexity
+    SubstrateDelegateProtocol.prototype.prepareDelegatorActionFromPublicKey = function (publicKey, type, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!data) {
+                    data = {};
+                }
+                switch (type) {
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.BOND_NOMINATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets', 'value', 'payee');
+                        return [2 /*return*/, this.prepareNomination(publicKey, data.tip || 0, data.targets, data.controller || publicKey, data.value, data.payee)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.REBOND_NOMINATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets', 'value');
+                        return [2 /*return*/, this.prepareRebondNominate(publicKey, data.tip || 0, data.targets, data.value)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.NOMINATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets');
+                        return [2 /*return*/, this.prepareNomination(publicKey, data.tip || 0, data.targets)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.CANCEL_NOMINATION:
+                        return [2 /*return*/, this.prepareScheduleUndelegate(publicKey, data.tip || 0, data.value)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.CHANGE_NOMINATION:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets');
+                        return [2 /*return*/, this.prepareChangeValidator(publicKey, data.tip || 0, data.targets)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.UNBOND:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
+                        return [2 /*return*/, this.prepareUnbond(publicKey, data.tip || 0, data.value)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.REBOND:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
+                        return [2 /*return*/, this.prepareRebond(publicKey, data.tip || 0, data.value)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.BOND_EXTRA:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
+                        return [2 /*return*/, this.prepareBondExtra(publicKey, data.tip || 0, data.value)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.REBOND_EXTRA:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
+                        return [2 /*return*/, this.prepareRebondExtra(publicKey, data.tip || 0, data.value)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.WITHDRAW_UNBONDED:
+                        return [2 /*return*/, this.prepareWithdrawUnbonded(publicKey, data.tip || 0)];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.CHANGE_REWARD_DESTINATION:
+                        return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+                    case SubstrateStakingActionType_1.SubstrateStakingActionType.CHANGE_CONTROLLER:
+                        return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+                    default:
+                        return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareNomination = function (publicKey, tip, targets, controller, value, payee) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferableBalance, available, bondFirst, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, false, false)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        available = new bignumber_1.default(transferableBalance).minus(value || 0);
+                        bondFirst = controller !== undefined && value !== undefined && payee !== undefined;
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, available, __spreadArray(__spreadArray([], (bondFirst
+                                ? [
+                                    {
+                                        type: SubstrateTransaction_1.SubstrateTransactionType.BOND,
+                                        tip: tip,
+                                        args: {
+                                            controller: controller,
+                                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value),
+                                            payee: typeof payee === 'string' ? SubstratePayee_1.SubstratePayee[payee] : payee
+                                        }
+                                    }
+                                ]
+                                : []), true), [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                                    tip: tip,
+                                    args: {
+                                        targets: typeof targets === 'string' ? [targets] : targets
+                                    }
+                                }
+                            ], false))];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareRebondNominate = function (publicKey, tip, targets, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, transferableBalance, lockedBalance, toDelegate, configs, encoded;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getTransferableBalance(publicKey, false, false),
+                            this.options.accountController.getUnlockingBalance(publicKey)
+                        ])];
+                    case 1:
+                        _a = _b.sent(), transferableBalance = _a[0], lockedBalance = _a[1];
+                        toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
+                        configs = [];
+                        if (toDelegate.gt(lockedBalance)) {
+                            configs.push({
+                                type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                                tip: tip,
+                                args: {
+                                    value: lockedBalance
+                                }
+                            }, {
+                                type: SubstrateTransaction_1.SubstrateTransactionType.BOND_EXTRA,
+                                tip: tip,
+                                args: {
+                                    value: toDelegate.minus(lockedBalance)
+                                }
+                            });
                         }
-                    }
-                ])
-        ]);
-        return [{ encoded }];
-    }
-    async prepareChangeValidator(publicKey, tip, targets) {
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, false, false);
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
-                tip,
-                args: {
-                    targets: typeof targets === 'string' ? [targets] : targets
+                        else {
+                            configs.push({
+                                type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                                tip: tip,
+                                args: {
+                                    value: toDelegate
+                                }
+                            });
+                        }
+                        configs.push({
+                            type: SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                            tip: tip,
+                            args: {
+                                targets: typeof targets === 'string' ? [targets] : targets
+                            }
+                        });
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, configs)];
+                    case 2:
+                        encoded = _b.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
                 }
-            }
-        ]);
-        return [{ encoded }];
-    }
-    async prepareUnbond(publicKey, tip, value) {
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, false, false);
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
-                tip,
-                args: {
-                    value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareScheduleUndelegate = function (publicKey, tip, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferableBalance, keepController, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, false, false)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        keepController = value === undefined;
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, __spreadArray([
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.CANCEL_NOMINATION,
+                                    tip: tip,
+                                    args: {}
+                                }
+                            ], (keepController
+                                ? []
+                                : [
+                                    {
+                                        type: SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                                        tip: tip,
+                                        args: {
+                                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+                                        }
+                                    }
+                                ]), true))];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
                 }
-            }
-        ]);
-        return [{ encoded }];
-    }
-    async prepareRebond(publicKey, tip, value) {
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, false, false);
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
-                tip,
-                args: {
-                    value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareChangeValidator = function (publicKey, tip, targets) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferableBalance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, false, false)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.NOMINATE,
+                                    tip: tip,
+                                    args: {
+                                        targets: typeof targets === 'string' ? [targets] : targets
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
                 }
-            }
-        ]);
-        return [{ encoded }];
-    }
-    async prepareBondExtra(publicKey, tip, value) {
-        const transferableBalance = await this.options.accountController.getTransferableBalance(publicKey, false, false);
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.BOND_EXTRA,
-                tip,
-                args: {
-                    value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareUnbond = function (publicKey, tip, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferableBalance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, false, false)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.UNBOND,
+                                    tip: tip,
+                                    args: {
+                                        value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
                 }
-            }
-        ]);
-        return [{ encoded }];
-    }
-    async prepareRebondExtra(publicKey, tip, value) {
-        const [transferableBalance, lockedBalance] = await Promise.all([
-            this.options.accountController.getTransferableBalance(publicKey, false, false),
-            this.options.accountController.getUnlockingBalance(publicKey)
-        ]);
-        const toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
-        const configs = toDelegate.gt(lockedBalance)
-            ? [
-                {
-                    type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
-                    tip,
-                    args: {
-                        value: lockedBalance
-                    }
-                },
-                {
-                    type: SubstrateTransaction_1.SubstrateTransactionType.BOND_EXTRA,
-                    tip,
-                    args: {
-                        value: toDelegate.minus(lockedBalance)
-                    }
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareRebond = function (publicKey, tip, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferableBalance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, false, false)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                                    tip: tip,
+                                    args: {
+                                        value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
                 }
-            ]
-            : [
-                {
-                    type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
-                    tip,
-                    args: {
-                        value: toDelegate
-                    }
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareBondExtra = function (publicKey, tip, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transferableBalance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getTransferableBalance(publicKey, false, false)];
+                    case 1:
+                        transferableBalance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.BOND_EXTRA,
+                                    tip: tip,
+                                    args: {
+                                        value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
                 }
-            ];
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, configs);
-        return [{ encoded }];
-    }
-    async prepareWithdrawUnbonded(publicKey, tip) {
-        const [transferableBalance, slashingSpansNumber] = await Promise.all([
-            this.options.accountController.getTransferableBalance(publicKey, false, false),
-            this.options.accountController.getSlashingSpansNumber(publicKey)
-        ]);
-        const encoded = await this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
-            {
-                type: SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
-                tip,
-                args: { slashingSpansNumber }
-            }
-        ]);
-        return [{ encoded }];
-    }
-    async estimateMaxDelegationValueFromAddress(address) {
-        const results = await Promise.all([
-            this.options.accountController.getTransferableBalance(address, false, false),
-            this.getFutureRequiredTransactions(address, 'delegate')
-        ]);
-        const transferableBalance = results[0];
-        const futureTransactions = results[1];
-        const feeEstimate = await this.options.transactionController.estimateTransactionFees(address, futureTransactions);
-        if (!feeEstimate) {
-            return Promise.reject('Could not estimate max value.');
-        }
-        const maxValue = transferableBalance.minus(feeEstimate);
-        return (maxValue.gte(0) ? maxValue : new bignumber_1.default(0)).toString(10);
-    }
-}
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareRebondExtra = function (publicKey, tip, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, transferableBalance, lockedBalance, toDelegate, configs, encoded;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getTransferableBalance(publicKey, false, false),
+                            this.options.accountController.getUnlockingBalance(publicKey)
+                        ])];
+                    case 1:
+                        _a = _b.sent(), transferableBalance = _a[0], lockedBalance = _a[1];
+                        toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
+                        configs = toDelegate.gt(lockedBalance)
+                            ? [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                                    tip: tip,
+                                    args: {
+                                        value: lockedBalance
+                                    }
+                                },
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.BOND_EXTRA,
+                                    tip: tip,
+                                    args: {
+                                        value: toDelegate.minus(lockedBalance)
+                                    }
+                                }
+                            ]
+                            : [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.REBOND,
+                                    tip: tip,
+                                    args: {
+                                        value: toDelegate
+                                    }
+                                }
+                            ];
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, configs)];
+                    case 2:
+                        encoded = _b.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.prepareWithdrawUnbonded = function (publicKey, tip) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, transferableBalance, slashingSpansNumber, encoded;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getTransferableBalance(publicKey, false, false),
+                            this.options.accountController.getSlashingSpansNumber(publicKey)
+                        ])];
+                    case 1:
+                        _a = _b.sent(), transferableBalance = _a[0], slashingSpansNumber = _a[1];
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, transferableBalance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.WITHDRAW_UNBONDED,
+                                    tip: tip,
+                                    args: { slashingSpansNumber: slashingSpansNumber }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _b.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    SubstrateDelegateProtocol.prototype.estimateMaxDelegationValueFromAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, transferableBalance, futureTransactions, feeEstimate, maxValue;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getTransferableBalance(address, false, false),
+                            this.getFutureRequiredTransactions(address, 'delegate')
+                        ])];
+                    case 1:
+                        results = _a.sent();
+                        transferableBalance = results[0];
+                        futureTransactions = results[1];
+                        return [4 /*yield*/, this.options.transactionController.estimateTransactionFees(address, futureTransactions)];
+                    case 2:
+                        feeEstimate = _a.sent();
+                        if (!feeEstimate) {
+                            return [2 /*return*/, Promise.reject('Could not estimate max value.')];
+                        }
+                        maxValue = transferableBalance.minus(feeEstimate);
+                        return [2 /*return*/, (maxValue.gte(0) ? maxValue : new bignumber_1.default(0)).toString(10)];
+                }
+            });
+        });
+    };
+    return SubstrateDelegateProtocol;
+}(SubstrateProtocol_1.SubstrateProtocol));
 exports.SubstrateDelegateProtocol = SubstrateDelegateProtocol;
 //# sourceMappingURL=SubstrateDelegateProtocol.js.map