@airgap/moonbeam 0.13.11-beta.1 → 0.13.11-beta.2

package/v0/protocol/moonbeam/MoonbeamProtocol.js

@@ -0,0 +1,641 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoonbeamProtocol = void 0;
+var bignumber_1 = require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var assert_1 = require("@airgap/coinlib-core/utils/assert");
+var ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
+var SubstrateTransaction_1 = require("@airgap/substrate/v0/protocol/common/data/transaction/SubstrateTransaction");
+var MoonbeamAddress_1 = require("@airgap/substrate/v0/protocol/moonbeam/MoonbeamAddress");
+var SubstrateDelegateProtocol_1 = require("@airgap/substrate/v0/protocol/SubstrateDelegateProtocol");
+var MoonbeamStakingActionType_1 = require("./data/staking/MoonbeamStakingActionType");
+var MoonbeamProtocolOptions_1 = require("./MoonbeamProtocolOptions");
+var MoonbeamProtocol = /** @class */ (function (_super) {
+    __extends(MoonbeamProtocol, _super);
+    function MoonbeamProtocol(options) {
+        if (options === void 0) { options = new MoonbeamProtocolOptions_1.MoonbeamProtocolOptions(new MoonbeamProtocolOptions_1.MoonbeamProtocolNetwork()); }
+        var _this = _super.call(this, options) || this;
+        _this.options = options;
+        _this.symbol = 'GLMR';
+        _this.name = 'Moonbeam';
+        _this.marketSymbol = 'GLMR';
+        _this.feeSymbol = 'GLMR';
+        _this.decimals = 18;
+        _this.feeDecimals = 18;
+        _this.identifier = ProtocolSymbols_1.MainProtocolSymbols.MOONBEAM;
+        _this.feeDefaults = {
+            low: '0.000000000125',
+            medium: '0.000000000125',
+            high: '0.000000000125'
+        };
+        _this.units = [
+            {
+                unitSymbol: 'GLMR',
+                factor: '1'
+            },
+            {
+                unitSymbol: 'mGLMR',
+                factor: '0.001'
+            },
+            {
+                unitSymbol: 'uGLMR',
+                factor: '0.000001'
+            },
+            {
+                unitSymbol: 'GWEI',
+                factor: '0.000000001'
+            },
+            {
+                unitSymbol: 'MWEI',
+                factor: '0.000000000001'
+            },
+            {
+                unitSymbol: 'kWEI',
+                factor: '0.000000000000001'
+            },
+            {
+                unitSymbol: 'WEI',
+                factor: '0.000000000000000001'
+            }
+        ];
+        _this.standardDerivationPath = "m/44'/60'/0'/0/0";
+        _this.addressIsCaseSensitive = false;
+        _this.addressValidationPattern = '^0x[a-fA-F0-9]{40}$';
+        _this.addressPlaceholder = "0xabc...";
+        return _this;
+    }
+    MoonbeamProtocol.prototype.getDefaultDelegatee = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var collators;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.defaultValidator) {
+                            return [2 /*return*/, this.defaultValidator];
+                        }
+                        return [4 /*yield*/, this.options.nodeClient.getCollators()];
+                    case 1:
+                        collators = _a.sent();
+                        return [2 /*return*/, collators ? collators[0].asString() : ''];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getCurrentDelegateesForPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getCurrentCollators(publicKey)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getCurrentDelegateesForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getCurrentCollators(address)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getDelegateeDetails = function (address) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var collatorDetails;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.options.accountController.getCollatorDetails(address)];
+                    case 1:
+                        collatorDetails = _c.sent();
+                        return [2 /*return*/, {
+                                name: (_a = collatorDetails.name) !== null && _a !== void 0 ? _a : '',
+                                status: (_b = collatorDetails.status) !== null && _b !== void 0 ? _b : '',
+                                address: collatorDetails.address
+                            }];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.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)];
+            });
+        });
+    };
+    MoonbeamProtocol.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)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getDelegatorDetailsFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getDelegatorDetails(publicKey)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getDelegatorDetailsFromAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getDelegatorDetails(address)];
+            });
+        });
+    };
+    MoonbeamProtocol.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)];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getDelegationDetailsFromAddress = function (address, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var collator, delegationDetails;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (delegatees.length > 1) {
+                            throw new errors_1.UnsupportedError(coinlib_error_1.Domain.SUBSTRATE, 'Multiple validators for a single delegation are not supported');
+                        }
+                        collator = delegatees[0];
+                        return [4 /*yield*/, this.options.accountController.getDelegationDetails(address, collator)];
+                    case 1:
+                        delegationDetails = _a.sent();
+                        return [2 /*return*/, {
+                                delegator: delegationDetails.delegatorDetails,
+                                delegatees: [delegationDetails.collatorDetails]
+                            }];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareDelegatorActionFromPublicKey = function (publicKey, type, data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_m) {
+                if (!data) {
+                    data = {};
+                }
+                switch (type) {
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.DELEGATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate', 'amount');
+                        return [2 /*return*/, this.prepareDelegation(publicKey, (_a = data.tip) !== null && _a !== void 0 ? _a : 0, data.candidate, data.amount)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.BOND_MORE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate', 'more');
+                        return [2 /*return*/, this.prepareDelegatorBondMore(publicKey, (_b = data.tip) !== null && _b !== void 0 ? _b : 0, data.candidate, data.more)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.SCHEDULE_BOND_LESS:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate', 'less');
+                        return [2 /*return*/, this.prepareScheduleDelegatorBondLess(publicKey, (_c = data.tip) !== null && _c !== void 0 ? _c : 0, data.candidate, data.less)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.EXECUTE_BOND_LESS:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate');
+                        return [2 /*return*/, this.prepareExecuteDelegatorBondLess(publicKey, (_d = data.tip) !== null && _d !== void 0 ? _d : 0, data.candidate)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.CANCEL_BOND_LESS:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate');
+                        return [2 /*return*/, this.prepareCancelDelegatorBondLess(publicKey, (_e = data.tip) !== null && _e !== void 0 ? _e : 0, data.candidate)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.SCHEDULE_UNDELEGATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'collator');
+                        return [2 /*return*/, this.prepareScheduleUndelegate(publicKey, (_f = data.tip) !== null && _f !== void 0 ? _f : 0, data.collator)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.EXECUTE_UNDELEGATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate');
+                        return [2 /*return*/, this.prepareExecuteUndelegate(publicKey, (_g = data.tip) !== null && _g !== void 0 ? _g : 0, data.candidate)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.CANCEL_UNDELEGATE:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'candidate');
+                        return [2 /*return*/, this.prepareCancelUndelegate(publicKey, (_h = data.tip) !== null && _h !== void 0 ? _h : 0, data.candidate)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.SCHEDULE_UNDELEGATE_ALL:
+                        return [2 /*return*/, this.prepareScheduleUndelegateAll(publicKey, (_j = data.tip) !== null && _j !== void 0 ? _j : 0)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.EXECUTE_UNDELEGATE_ALL:
+                        return [2 /*return*/, this.prepareExecuteUndelegateAll(publicKey, (_k = data.tip) !== null && _k !== void 0 ? _k : 0)];
+                    case MoonbeamStakingActionType_1.MoonbeamStakingActionType.CANCEL_UNDELEGATE_ALL:
+                        return [2 /*return*/, this.prepareCancelUndelegateAll(publicKey, (_l = data.tip) !== null && _l !== void 0 ? _l : 0)];
+                    default:
+                        throw new errors_1.UnsupportedError(coinlib_error_1.Domain.SUBSTRATE, 'Unsupported delegator action.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareDelegation = function (publicKey, tip, candidate, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestedAmount, minAmount, results, delegatorDetails, collatorDetails, maxDelegations, balance, available, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        requestedAmount = new bignumber_1.BigNumber(amount);
+                        return [4 /*yield*/, this.getMinDelegationAmount(publicKey)];
+                    case 1:
+                        minAmount = _a.sent();
+                        if (requestedAmount.lt(minAmount)) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.SUBSTRATE, "The amount is too low, it has to be at least ".concat(minAmount.toString()));
+                        }
+                        return [4 /*yield*/, Promise.all([
+                                this.options.accountController.getDelegatorDetails(publicKey),
+                                this.options.accountController.getCollatorDetails(candidate),
+                                this.options.nodeClient.getMaxDelegationsPerDelegator(),
+                                this.getBalanceOfPublicKey(publicKey)
+                            ])];
+                    case 2:
+                        results = _a.sent();
+                        delegatorDetails = results[0];
+                        collatorDetails = results[1];
+                        maxDelegations = results[2];
+                        balance = results[3];
+                        if (maxDelegations === null || maxDelegations === void 0 ? void 0 : maxDelegations.lte(delegatorDetails.delegatees.length)) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.SUBSTRATE, 'This delegator cannot nominate more collators.');
+                        }
+                        available = new bignumber_1.BigNumber(balance).minus(amount);
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, available, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_DELEGATE,
+                                    tip: tip,
+                                    args: {
+                                        candidate: candidate,
+                                        amount: new bignumber_1.BigNumber(amount),
+                                        candidateDelegationCount: collatorDetails.delegators,
+                                        delegationCount: delegatorDetails.delegatees.length
+                                    }
+                                }
+                            ])];
+                    case 3:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareScheduleUndelegate = function (publicKey, tip, collator) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_SCHEDULE_REVOKE_DELGATION,
+                                    tip: tip,
+                                    args: {
+                                        collator: collator
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareExecuteUndelegate = function (publicKey, tip, candidate) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.prepareExecuteDelegationRequest(publicKey, tip, candidate)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareCancelUndelegate = function (publicKey, tip, candidate) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.prepareCancelDelegationRequest(publicKey, tip, candidate)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareScheduleUndelegateAll = function (publicKey, tip) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_SCHEDULE_LEAVE_DELEGATORS,
+                                    tip: tip,
+                                    args: {}
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareExecuteUndelegateAll = function (publicKey, tip) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, delegatorDetails, balance, delegator, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.getDelegatorDetails(publicKey),
+                            this.getBalanceOfPublicKey(publicKey),
+                            this.getAddressFromPublicKey(publicKey)
+                        ])];
+                    case 1:
+                        results = _a.sent();
+                        delegatorDetails = results[0];
+                        balance = results[1];
+                        delegator = results[2].address;
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_EXECUTE_LEAVE_DELEGATORS,
+                                    tip: tip,
+                                    args: {
+                                        delegator: delegator,
+                                        delegationCount: delegatorDetails.delegatees.length
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareCancelUndelegateAll = function (publicKey, tip) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_CANCEL_LEAVE_DELEGATORS,
+                                    tip: tip,
+                                    args: {}
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareDelegatorBondMore = function (publicKey, tip, candidate, more) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, available, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        available = new bignumber_1.BigNumber(balance).minus(more);
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, available, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_DELEGATOR_BOND_MORE,
+                                    tip: tip,
+                                    args: {
+                                        candidate: candidate,
+                                        more: new bignumber_1.BigNumber(more)
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareScheduleDelegatorBondLess = function (publicKey, tip, candidate, less) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, balance, delegationDetails, bondAmount, requestedAmount, encoded;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.getBalanceOfPublicKey(publicKey),
+                            this.options.accountController.getDelegationDetails(publicKey, candidate)
+                        ])];
+                    case 1:
+                        _a = _b.sent(), balance = _a[0], delegationDetails = _a[1];
+                        bondAmount = new bignumber_1.BigNumber(delegationDetails.bond);
+                        requestedAmount = new bignumber_1.BigNumber(less);
+                        if (requestedAmount.gt(bondAmount)) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.SUBSTRATE, 'Bond less amount too high');
+                        }
+                        else if (requestedAmount.eq(bondAmount)) {
+                            return [2 /*return*/, this.prepareScheduleUndelegate(publicKey, tip, candidate)];
+                        }
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_SCHEDULE_DELEGATOR_BOND_LESS,
+                                    tip: tip,
+                                    args: {
+                                        candidate: candidate,
+                                        less: requestedAmount
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _b.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareExecuteDelegatorBondLess = function (publicKey, tip, candidate) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.prepareExecuteDelegationRequest(publicKey, tip, candidate)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareCancelDelegatorBondLess = function (publicKey, tip, candidate) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.prepareCancelDelegationRequest(publicKey, tip, candidate)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareExecuteDelegationRequest = function (publicKey, tip, candidate) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, balance, delegator, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([this.getBalanceOfPublicKey(publicKey), this.getAddressFromPublicKey(publicKey)])];
+                    case 1:
+                        results = _a.sent();
+                        balance = results[0];
+                        delegator = results[1].address;
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_EXECUTE_DELGATION_REQUEST,
+                                    tip: tip,
+                                    args: {
+                                        delegator: delegator,
+                                        candidate: candidate
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.prepareCancelDelegationRequest = function (publicKey, tip, candidate) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, encoded;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [4 /*yield*/, this.options.transactionController.prepareSubmittableTransactions(publicKey, balance, [
+                                {
+                                    type: SubstrateTransaction_1.SubstrateTransactionType.M_CANCEL_DELEGATION_REQUEST,
+                                    tip: tip,
+                                    args: {
+                                        candidate: candidate
+                                    }
+                                }
+                            ])];
+                    case 2:
+                        encoded = _a.sent();
+                        return [2 /*return*/, [{ encoded: encoded }]];
+                }
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getMinDelegationAmount = function (accountId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.accountController.getMinDelegationAmount(accountId)];
+            });
+        });
+    };
+    MoonbeamProtocol.prototype.getFutureRequiredTransactions = function (accountId, intention) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, isDelegating, transferableBalance, stakingBalance, requiredTransactions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.options.accountController.isDelegating(accountId),
+                            this.options.accountController.getTransferableBalance(accountId),
+                            this.options.accountController.getTransferableBalance(accountId, false, false)
+                        ])];
+                    case 1:
+                        results = _a.sent();
+                        isDelegating = results[0];
+                        transferableBalance = results[1];
+                        stakingBalance = results[2];
+                        requiredTransactions = [];
+                        if (intention === 'transfer') {
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.TRANSFER,
+                                {
+                                    to: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder(),
+                                    value: transferableBalance
+                                }
+                            ]);
+                        }
+                        if (!isDelegating && intention === 'delegate') {
+                            // not delegated
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.M_DELEGATE,
+                                {
+                                    candidate: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder(),
+                                    amount: stakingBalance,
+                                    candidateDelegationCount: 0,
+                                    delegationCount: 0
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.M_SCHEDULE_REVOKE_DELGATION,
+                                {
+                                    collator: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder()
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.M_EXECUTE_DELGATION_REQUEST,
+                                {
+                                    delegator: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder(),
+                                    candidate: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder()
+                                }
+                            ]);
+                        }
+                        if (isDelegating && intention === 'delegate') {
+                            requiredTransactions.push([
+                                SubstrateTransaction_1.SubstrateTransactionType.M_SCHEDULE_REVOKE_DELGATION,
+                                {
+                                    collator: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder()
+                                }
+                            ], [
+                                SubstrateTransaction_1.SubstrateTransactionType.M_EXECUTE_DELGATION_REQUEST,
+                                {
+                                    delegator: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder(),
+                                    candidate: MoonbeamAddress_1.MoonbeamAddress.getPlaceholder()
+                                }
+                            ]);
+                        }
+                        return [2 /*return*/, requiredTransactions];
+                }
+            });
+        });
+    };
+    return MoonbeamProtocol;
+}(SubstrateDelegateProtocol_1.SubstrateDelegateProtocol));
+exports.MoonbeamProtocol = MoonbeamProtocol;
+//# sourceMappingURL=MoonbeamProtocol.js.map