@airgap/moonbeam 0.13.45-beta.2 → 0.13.45-beta.3

package/v1/protocol/MoonbeamBaseProtocol.js

@@ -1,649 +1,364 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoonbeamBaseProtocolImpl = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var assert_1 = require("@airgap/coinlib-core/utils/assert");
-var module_kit_1 = require("@airgap/module-kit");
-var v1_1 = require("@airgap/substrate/v1");
-var MoonbeamAccountController_1 = require("../controller/MoonbeamAccountController");
-var MoonbeamTransactionController_1 = require("../controller/MoonbeamTransactionController");
-var MoonbeamStakingActionType_1 = require("../data/staking/MoonbeamStakingActionType");
-var MoonbeamNodeClient_1 = require("../node/MoonbeamNodeClient");
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const errors_1 = require("@airgap/coinlib-core/errors");
+const assert_1 = require("@airgap/coinlib-core/utils/assert");
+const module_kit_1 = require("@airgap/module-kit");
+const v1_1 = require("@airgap/substrate/v1");
+const MoonbeamAccountController_1 = require("../controller/MoonbeamAccountController");
+const MoonbeamTransactionController_1 = require("../controller/MoonbeamTransactionController");
+const MoonbeamStakingActionType_1 = require("../data/staking/MoonbeamStakingActionType");
+const MoonbeamNodeClient_1 = require("../node/MoonbeamNodeClient");
 // Implementation
-var MoonbeamBaseProtocolImpl = /** @class */ (function (_super) {
-    __extends(MoonbeamBaseProtocolImpl, _super);
-    function MoonbeamBaseProtocolImpl(options) {
-        var _this = this;
-        var nodeClient = new MoonbeamNodeClient_1.MoonbeamNodeClient(options.configuration, options.network.rpcUrl);
-        var accountController = new MoonbeamAccountController_1.MoonbeamAccountController(options.configuration, nodeClient);
-        var transactionController = new MoonbeamTransactionController_1.MoonbeamTransactionController(options.configuration, nodeClient);
-        var blockExplorer = new v1_1.SubscanBlockExplorerClient(options.network.blockExplorerApi);
-        _this = _super.call(this, options, nodeClient, accountController, transactionController, blockExplorer) || this;
-        _this.defaultValidator = options.network.defaultValidator;
-        return _this;
+class MoonbeamBaseProtocolImpl extends v1_1.SubstrateStakingProtocolImpl {
+    constructor(options) {
+        const nodeClient = new MoonbeamNodeClient_1.MoonbeamNodeClient(options.configuration, options.network.rpcUrl);
+        const accountController = new MoonbeamAccountController_1.MoonbeamAccountController(options.configuration, nodeClient);
+        const transactionController = new MoonbeamTransactionController_1.MoonbeamTransactionController(options.configuration, nodeClient);
+        const blockExplorer = new v1_1.SubscanBlockExplorerClient(options.network.blockExplorerApi);
+        super(options, nodeClient, accountController, transactionController, blockExplorer);
+        this.defaultValidator = options.network.defaultValidator;
     }
     // Staking
-    MoonbeamBaseProtocolImpl.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.nodeClient.getCollators()];
-                    case 1:
-                        collators = _a.sent();
-                        return [2 /*return*/, collators ? collators[0].asString() : ''];
-                }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getCurrentDelegateesForPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getCurrentCollators(publicKey)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getCurrentDelegateesForAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getCurrentCollators(address)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.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
-                            }];
-                }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.isPublicKeyDelegating = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.isDelegating(publicKey)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.isAddressDelegating = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.isDelegating(address)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getDelegatorDetailsFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getDelegatorDetails(publicKey)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getDelegatorDetailsFromAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getDelegatorDetails(address)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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, delegatees)];
-                }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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_core_1.Domain.SUBSTRATE, 'Multiple validators for a single delegation are not supported');
-                        }
-                        collator = delegatees[0];
-                        return [4 /*yield*/, this.accountController.getDelegationDetails(address, collator)];
-                    case 1:
-                        delegationDetails = _a.sent();
-                        return [2 /*return*/, {
-                                delegator: delegationDetails.delegatorDetails,
-                                delegatees: [delegationDetails.collatorDetails]
-                            }];
-                }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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_core_1.Domain.SUBSTRATE, 'Unsupported delegator action.');
+    async getDefaultDelegatee() {
+        if (this.defaultValidator) {
+            return this.defaultValidator;
+        }
+        const collators = await this.nodeClient.getCollators();
+        return collators ? collators[0].asString() : '';
+    }
+    async getCurrentDelegateesForPublicKey(publicKey) {
+        return this.accountController.getCurrentCollators(publicKey);
+    }
+    async getCurrentDelegateesForAddress(address) {
+        return this.accountController.getCurrentCollators(address);
+    }
+    async getDelegateeDetails(address) {
+        const collatorDetails = await this.accountController.getCollatorDetails(address);
+        return {
+            name: collatorDetails.name ?? '',
+            status: collatorDetails.status ?? '',
+            address: collatorDetails.address
+        };
+    }
+    async isPublicKeyDelegating(publicKey) {
+        return this.accountController.isDelegating(publicKey);
+    }
+    async isAddressDelegating(address) {
+        return this.accountController.isDelegating(address);
+    }
+    async getDelegatorDetailsFromPublicKey(publicKey) {
+        return this.accountController.getDelegatorDetails(publicKey);
+    }
+    async getDelegatorDetailsFromAddress(address) {
+        return this.accountController.getDelegatorDetails(address);
+    }
+    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getDelegationDetailsFromAddress(address, delegatees);
+    }
+    async getDelegationDetailsFromAddress(address, delegatees) {
+        if (delegatees.length > 1) {
+            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.SUBSTRATE, 'Multiple validators for a single delegation are not supported');
+        }
+        const collator = delegatees[0];
+        const delegationDetails = await this.accountController.getDelegationDetails(address, collator);
+        return {
+            delegator: delegationDetails.delegatorDetails,
+            delegatees: [delegationDetails.collatorDetails]
+        };
+    }
+    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
+        if (!data) {
+            data = {};
+        }
+        switch (type) {
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.DELEGATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate', 'amount');
+                return this.prepareDelegation(publicKey, data.tip ?? 0, data.candidate, data.amount);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.BOND_MORE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate', 'more');
+                return this.prepareDelegatorBondMore(publicKey, data.tip ?? 0, data.candidate, data.more);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.SCHEDULE_BOND_LESS:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate', 'less');
+                return this.prepareScheduleDelegatorBondLess(publicKey, data.tip ?? 0, data.candidate, data.less);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.EXECUTE_BOND_LESS:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate');
+                return this.prepareExecuteDelegatorBondLess(publicKey, data.tip ?? 0, data.candidate);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.CANCEL_BOND_LESS:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate');
+                return this.prepareCancelDelegatorBondLess(publicKey, data.tip ?? 0, data.candidate);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.SCHEDULE_UNDELEGATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'collator');
+                return this.prepareScheduleUndelegate(publicKey, data.tip ?? 0, data.collator);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.EXECUTE_UNDELEGATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate');
+                return this.prepareExecuteUndelegate(publicKey, data.tip ?? 0, data.candidate);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.CANCEL_UNDELEGATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'candidate');
+                return this.prepareCancelUndelegate(publicKey, data.tip ?? 0, data.candidate);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.SCHEDULE_UNDELEGATE_ALL:
+                return this.prepareScheduleUndelegateAll(publicKey, data.tip ?? 0);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.EXECUTE_UNDELEGATE_ALL:
+                return this.prepareExecuteUndelegateAll(publicKey, data.tip ?? 0);
+            case MoonbeamStakingActionType_1.MoonbeamStakingActionType.CANCEL_UNDELEGATE_ALL:
+                return this.prepareCancelUndelegateAll(publicKey, data.tip ?? 0);
+            default:
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.SUBSTRATE, 'Unsupported delegator action.');
+        }
+    }
+    async prepareDelegation(publicKey, tip, candidate, amount) {
+        const requestedAmount = new bignumber_1.default(amount);
+        const minAmount = await this.accountController.getMinDelegationAmount(publicKey);
+        if (requestedAmount.lt(minAmount)) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.SUBSTRATE, `The amount is too low, it has to be at least ${minAmount.toString()}`);
+        }
+        const results = await Promise.all([
+            this.accountController.getDelegatorDetails(publicKey),
+            this.accountController.getCollatorDetails(candidate),
+            this.nodeClient.getMaxDelegationsPerDelegator(),
+            this.getBalanceOfPublicKey(publicKey)
+        ]);
+        const delegatorDetails = results[0];
+        const collatorDetails = results[1];
+        const maxDelegations = results[2];
+        const balance = results[3];
+        if (maxDelegations?.lte(delegatorDetails.delegatees.length)) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.SUBSTRATE, 'This delegator cannot nominate more collators.');
+        }
+        const available = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value).minus(amount);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, available, [
+            {
+                type: 'delegate',
+                tip,
+                args: {
+                    candidate,
+                    amount: new bignumber_1.default(amount),
+                    candidateDelegationCount: collatorDetails.delegators,
+                    delegationCount: delegatorDetails.delegatees.length
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.default(amount);
-                        return [4 /*yield*/, this.accountController.getMinDelegationAmount(publicKey)];
-                    case 1:
-                        minAmount = _a.sent();
-                        if (requestedAmount.lt(minAmount)) {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.SUBSTRATE, "The amount is too low, it has to be at least ".concat(minAmount.toString()));
-                        }
-                        return [4 /*yield*/, Promise.all([
-                                this.accountController.getDelegatorDetails(publicKey),
-                                this.accountController.getCollatorDetails(candidate),
-                                this.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_core_1.Domain.SUBSTRATE, 'This delegator cannot nominate more collators.');
-                        }
-                        available = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value).minus(amount);
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, available, [
-                                {
-                                    type: 'delegate',
-                                    tip: tip,
-                                    args: {
-                                        candidate: candidate,
-                                        amount: new bignumber_1.default(amount),
-                                        candidateDelegationCount: collatorDetails.delegators,
-                                        delegationCount: delegatorDetails.delegatees.length
-                                    }
-                                }
-                            ])];
-                    case 3:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareScheduleUndelegate(publicKey, tip, collator) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'schedule_revoke_delegation',
+                tip,
+                args: {
+                    collator
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'schedule_revoke_delegation',
-                                    tip: tip,
-                                    args: {
-                                        collator: collator
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareExecuteUndelegate(publicKey, tip, candidate) {
+        return this.prepareExecuteDelegationRequest(publicKey, tip, candidate);
+    }
+    async prepareCancelUndelegate(publicKey, tip, candidate) {
+        return this.prepareCancelDelegationRequest(publicKey, tip, candidate);
+    }
+    async prepareScheduleUndelegateAll(publicKey, tip) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'schedule_leave_delegators',
+                tip,
+                args: {}
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareExecuteUndelegateAll(publicKey, tip) {
+        const results = await Promise.all([
+            this.accountController.getDelegatorDetails(publicKey),
+            this.getBalanceOfPublicKey(publicKey),
+            this.getAddressFromPublicKey(publicKey)
+        ]);
+        const delegatorDetails = results[0];
+        const balance = results[1];
+        const delegator = results[2];
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'execute_leave_delegators',
+                tip,
+                args: {
+                    delegator,
+                    delegationCount: delegatorDetails.delegatees.length
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'schedule_leave_delegators',
-                                    tip: tip,
-                                    args: {}
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareCancelUndelegateAll(publicKey, tip) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'cancel_leave_delegators',
+                tip,
+                args: {}
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareDelegatorBondMore(publicKey, tip, candidate, more) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const available = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value).minus(more);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, available, [
+            {
+                type: 'delegator_bond_more',
+                tip,
+                args: {
+                    candidate,
+                    more: new bignumber_1.default(more)
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.accountController.getDelegatorDetails(publicKey),
-                            this.getBalanceOfPublicKey(publicKey),
-                            this.getAddressFromPublicKey(publicKey)
-                        ])];
-                    case 1:
-                        results = _a.sent();
-                        delegatorDetails = results[0];
-                        balance = results[1];
-                        delegator = results[2];
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'execute_leave_delegators',
-                                    tip: tip,
-                                    args: {
-                                        delegator: delegator,
-                                        delegationCount: delegatorDetails.delegatees.length
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareScheduleDelegatorBondLess(publicKey, tip, candidate, less) {
+        const [balance, delegationDetails] = await Promise.all([
+            this.getBalanceOfPublicKey(publicKey),
+            this.accountController.getDelegationDetails(publicKey, candidate)
+        ]);
+        const bondAmount = new bignumber_1.default(delegationDetails.bond);
+        const requestedAmount = new bignumber_1.default(less);
+        if (requestedAmount.gt(bondAmount)) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.SUBSTRATE, 'Bond less amount too high');
+        }
+        else if (requestedAmount.eq(bondAmount)) {
+            return this.prepareScheduleUndelegate(publicKey, tip, candidate);
+        }
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'schedule_delegator_bond_less',
+                tip,
+                args: {
+                    candidate,
+                    less: requestedAmount
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'cancel_leave_delegators',
-                                    tip: tip,
-                                    args: {}
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareExecuteDelegatorBondLess(publicKey, tip, candidate) {
+        return this.prepareExecuteDelegationRequest(publicKey, tip, candidate);
+    }
+    async prepareCancelDelegatorBondLess(publicKey, tip, candidate) {
+        return this.prepareCancelDelegationRequest(publicKey, tip, candidate);
+    }
+    async prepareExecuteDelegationRequest(publicKey, tip, candidate) {
+        const results = await Promise.all([this.getBalanceOfPublicKey(publicKey), this.getAddressFromPublicKey(publicKey)]);
+        const balance = results[0];
+        const delegator = results[1];
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'execute_delegation_request',
+                tip,
+                args: {
+                    delegator,
+                    candidate
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value).minus(more);
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, available, [
-                                {
-                                    type: 'delegator_bond_more',
-                                    tip: tip,
-                                    args: {
-                                        candidate: candidate,
-                                        more: new bignumber_1.default(more)
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareCancelDelegationRequest(publicKey, tip, candidate) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
+            {
+                type: 'cancel_delegation_request',
+                tip,
+                args: {
+                    candidate
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.accountController.getDelegationDetails(publicKey, candidate)
-                        ])];
-                    case 1:
-                        _a = _b.sent(), balance = _a[0], delegationDetails = _a[1];
-                        bondAmount = new bignumber_1.default(delegationDetails.bond);
-                        requestedAmount = new bignumber_1.default(less);
-                        if (requestedAmount.gt(bondAmount)) {
-                            throw new errors_1.ConditionViolationError(coinlib_core_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.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'schedule_delegator_bond_less',
-                                    tip: tip,
-                                    args: {
-                                        candidate: candidate,
-                                        less: requestedAmount
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _b.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async getMinDelegationAmountWithPublicKey(publicKey) {
+        return this.accountController.getMinDelegationAmount(publicKey);
+    }
+    async getMinDelegationAmountWithAddress(address) {
+        return this.accountController.getMinDelegationAmount(address);
+    }
+    // Custom
+    async getStakingDetails(address, collator) {
+        return this.accountController.getDelegationDetails(address, collator);
+    }
+    async getCollatorDetails(address) {
+        return this.accountController.getCollatorDetails(address);
+    }
+    async getMaxDelegationsPerDelegator() {
+        const maxDelegations = await this.nodeClient.getMaxDelegationsPerDelegator();
+        return maxDelegations?.toString();
+    }
+    async getMaxTopDelegationsPerCandidate() {
+        const maxTopDelegations = await this.nodeClient.getMaxTopDelegationsPerCandidate();
+        return maxTopDelegations?.toString();
+    }
+    async getFutureRequiredTransactions(accountId, intention) {
+        const results = await Promise.all([this.accountController.isDelegating(accountId), this.accountController.getBalance(accountId)]);
+        const isDelegating = results[0];
+        const balance = results[1];
+        const transferableBalance = balance.transferable.minus(balance.existentialDeposit);
+        const stakingBalance = balance.transferable;
+        const requiredTransactions = [];
+        if (intention === 'transfer') {
+            requiredTransactions.push([
+                'transfer',
+                {
+                    to: v1_1.SubstrateEthAddress.createPlaceholder(),
+                    value: transferableBalance
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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];
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'execute_delegation_request',
-                                    tip: tip,
-                                    args: {
-                                        delegator: delegator,
-                                        candidate: candidate
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ]);
+        }
+        if (!isDelegating && intention === 'delegate') {
+            // not delegated
+            requiredTransactions.push([
+                'delegate',
+                {
+                    candidate: v1_1.SubstrateEthAddress.createPlaceholder(),
+                    amount: stakingBalance,
+                    candidateDelegationCount: 0,
+                    delegationCount: 0
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.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.transactionController.prepareSubmittableTransactions(publicKey, (0, module_kit_1.newAmount)(balance.total).blockchain(this.metadata.units).value, [
-                                {
-                                    type: 'cancel_delegation_request',
-                                    tip: tip,
-                                    args: {
-                                        candidate: candidate
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ], [
+                'schedule_revoke_delegation',
+                {
+                    collator: v1_1.SubstrateEthAddress.createPlaceholder()
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getMinDelegationAmountWithPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getMinDelegationAmount(publicKey)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getMinDelegationAmountWithAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getMinDelegationAmount(address)];
-            });
-        });
-    };
-    // Custom
-    MoonbeamBaseProtocolImpl.prototype.getStakingDetails = function (address, collator) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getDelegationDetails(address, collator)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getCollatorDetails = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getCollatorDetails(address)];
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getMaxDelegationsPerDelegator = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var maxDelegations;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.nodeClient.getMaxDelegationsPerDelegator()];
-                    case 1:
-                        maxDelegations = _a.sent();
-                        return [2 /*return*/, maxDelegations === null || maxDelegations === void 0 ? void 0 : maxDelegations.toString()];
+            ], [
+                'execute_delegation_request',
+                {
+                    delegator: v1_1.SubstrateEthAddress.createPlaceholder(),
+                    candidate: v1_1.SubstrateEthAddress.createPlaceholder()
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getMaxTopDelegationsPerCandidate = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var maxTopDelegations;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.nodeClient.getMaxTopDelegationsPerCandidate()];
-                    case 1:
-                        maxTopDelegations = _a.sent();
-                        return [2 /*return*/, maxTopDelegations === null || maxTopDelegations === void 0 ? void 0 : maxTopDelegations.toString()];
+            ]);
+        }
+        if (isDelegating && intention === 'delegate') {
+            requiredTransactions.push([
+                'schedule_revoke_delegation',
+                {
+                    collator: v1_1.SubstrateEthAddress.createPlaceholder()
                 }
-            });
-        });
-    };
-    MoonbeamBaseProtocolImpl.prototype.getFutureRequiredTransactions = function (accountId, intention) {
-        return __awaiter(this, void 0, void 0, function () {
-            var results, isDelegating, balance, transferableBalance, stakingBalance, requiredTransactions;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all([this.accountController.isDelegating(accountId), this.accountController.getBalance(accountId)])];
-                    case 1:
-                        results = _a.sent();
-                        isDelegating = results[0];
-                        balance = results[1];
-                        transferableBalance = balance.transferable.minus(balance.existentialDeposit);
-                        stakingBalance = balance.transferable;
-                        requiredTransactions = [];
-                        if (intention === 'transfer') {
-                            requiredTransactions.push([
-                                'transfer',
-                                {
-                                    to: v1_1.SubstrateEthAddress.createPlaceholder(),
-                                    value: transferableBalance
-                                }
-                            ]);
-                        }
-                        if (!isDelegating && intention === 'delegate') {
-                            // not delegated
-                            requiredTransactions.push([
-                                'delegate',
-                                {
-                                    candidate: v1_1.SubstrateEthAddress.createPlaceholder(),
-                                    amount: stakingBalance,
-                                    candidateDelegationCount: 0,
-                                    delegationCount: 0
-                                }
-                            ], [
-                                'schedule_revoke_delegation',
-                                {
-                                    collator: v1_1.SubstrateEthAddress.createPlaceholder()
-                                }
-                            ], [
-                                'execute_delegation_request',
-                                {
-                                    delegator: v1_1.SubstrateEthAddress.createPlaceholder(),
-                                    candidate: v1_1.SubstrateEthAddress.createPlaceholder()
-                                }
-                            ]);
-                        }
-                        if (isDelegating && intention === 'delegate') {
-                            requiredTransactions.push([
-                                'schedule_revoke_delegation',
-                                {
-                                    collator: v1_1.SubstrateEthAddress.createPlaceholder()
-                                }
-                            ], [
-                                'execute_delegation_request',
-                                {
-                                    delegator: v1_1.SubstrateEthAddress.createPlaceholder(),
-                                    candidate: v1_1.SubstrateEthAddress.createPlaceholder()
-                                }
-                            ]);
-                        }
-                        return [2 /*return*/, requiredTransactions];
+            ], [
+                'execute_delegation_request',
+                {
+                    delegator: v1_1.SubstrateEthAddress.createPlaceholder(),
+                    candidate: v1_1.SubstrateEthAddress.createPlaceholder()
                 }
-            });
-        });
-    };
-    return MoonbeamBaseProtocolImpl;
-}(v1_1.SubstrateStakingProtocolImpl));
+            ]);
+        }
+        return requiredTransactions;
+    }
+}
 exports.MoonbeamBaseProtocolImpl = MoonbeamBaseProtocolImpl;
 //# sourceMappingURL=MoonbeamBaseProtocol.js.map