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

package/v1/protocol/PolkadotBaseProtocol.js

@@ -1,737 +1,445 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolkadotBaseProtocolImpl = void 0;
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-var assert_1 = require("@airgap/coinlib-core/utils/assert");
-var module_kit_1 = require("@airgap/module-kit");
-var v1_1 = require("@airgap/substrate/v1");
-var PolkadotAccountController_1 = require("../controller/PolkadotAccountController");
-var PolkadotTransactionController_1 = require("../controller/PolkadotTransactionController");
-var PolkadotPayee_1 = require("../data/staking/PolkadotPayee");
-var PolkadotStakingActionType_1 = require("../data/staking/PolkadotStakingActionType");
-var PolkadotNodeClient_1 = require("../node/PolkadotNodeClient");
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const assert_1 = require("@airgap/coinlib-core/utils/assert");
+const module_kit_1 = require("@airgap/module-kit");
+const v1_1 = require("@airgap/substrate/v1");
+const PolkadotAccountController_1 = require("../controller/PolkadotAccountController");
+const PolkadotTransactionController_1 = require("../controller/PolkadotTransactionController");
+const PolkadotPayee_1 = require("../data/staking/PolkadotPayee");
+const PolkadotStakingActionType_1 = require("../data/staking/PolkadotStakingActionType");
+const PolkadotNodeClient_1 = require("../node/PolkadotNodeClient");
 // Implementation
-var PolkadotBaseProtocolImpl = /** @class */ (function (_super) {
-    __extends(PolkadotBaseProtocolImpl, _super);
-    function PolkadotBaseProtocolImpl(options) {
-        var _this = this;
-        var nodeClient = new PolkadotNodeClient_1.PolkadotNodeClient(options.configuration, options.network.rpcUrl);
-        var accountController = new PolkadotAccountController_1.PolkadotAccountController(options.configuration, nodeClient);
-        var transactionController = new PolkadotTransactionController_1.PolkadotTransactionController(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 PolkadotBaseProtocolImpl extends v1_1.SubstrateStakingProtocolImpl {
+    constructor(options) {
+        const nodeClient = new PolkadotNodeClient_1.PolkadotNodeClient(options.configuration, options.network.rpcUrl);
+        const accountController = new PolkadotAccountController_1.PolkadotAccountController(options.configuration, nodeClient);
+        const transactionController = new PolkadotTransactionController_1.PolkadotTransactionController(options.configuration, nodeClient);
+        const blockExplorer = new v1_1.SubscanBlockExplorerClient(options.network.blockExplorerApi);
+        super(options, nodeClient, accountController, transactionController, blockExplorer);
+        this.defaultValidator = options.network.defaultValidator;
     }
     // Staking
-    PolkadotBaseProtocolImpl.prototype.getDefaultDelegatee = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var validators;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.defaultValidator) {
-                            return [2 /*return*/, this.defaultValidator];
+    async getDefaultDelegatee() {
+        if (this.defaultValidator) {
+            return this.defaultValidator;
+        }
+        const validators = await this.nodeClient.getValidators();
+        return validators ? validators[0].asString() : '';
+    }
+    async getCurrentDelegateesForPublicKey(publicKey) {
+        return this.accountController.getCurrentValidators(publicKey);
+    }
+    async getCurrentDelegateesForAddress(address) {
+        return this.accountController.getCurrentValidators(address);
+    }
+    async getDelegateeDetails(address) {
+        const validatorDetails = await this.accountController.getValidatorDetails(address);
+        return {
+            name: validatorDetails.name || '',
+            status: validatorDetails.status || '',
+            address
+        };
+    }
+    async isPublicKeyDelegating(publicKey) {
+        return this.accountController.isDelegating(publicKey);
+    }
+    async isAddressDelegating(address) {
+        return this.accountController.isDelegating(address);
+    }
+    async getDelegatorDetailsFromPublicKey(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getDelegatorDetailsFromAddress(address);
+    }
+    async getDelegatorDetailsFromAddress(address) {
+        return this.accountController.getNominatorDetails(address);
+    }
+    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getDelegationDetailsFromAddress(address, delegatees);
+    }
+    async getDelegationDetailsFromAddress(address, delegatees) {
+        const [nominatorDetails, validatorsDetails] = await Promise.all([
+            this.accountController.getNominatorDetails(address, delegatees),
+            Promise.all(delegatees.map((validator) => this.accountController.getValidatorDetails(validator)))
+        ]);
+        nominatorDetails.rewards =
+            nominatorDetails.delegatees.length > 0 && nominatorDetails.stakingDetails
+                ? nominatorDetails.stakingDetails.rewards.map((reward) => ({
+                    index: reward.eraIndex,
+                    amount: reward.amount,
+                    timestamp: reward.timestamp
+                }))
+                : [];
+        return {
+            delegator: nominatorDetails,
+            delegatees: validatorsDetails
+        };
+    }
+    // tslint:disable-next-line: cyclomatic-complexity
+    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
+        if (!data) {
+            data = {};
+        }
+        switch (type) {
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.BOND_NOMINATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'targets', 'value', 'payee');
+                return this.prepareNomination(publicKey, data.tip || 0, data.targets, data.controller || publicKey, data.value, data.payee);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.REBOND_NOMINATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'targets', 'value');
+                return this.prepareRebondNominate(publicKey, data.tip || 0, data.targets, data.value);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.NOMINATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'targets');
+                return this.prepareNomination(publicKey, data.tip || 0, data.targets);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.CANCEL_NOMINATION:
+                return this.prepareScheduleUndelegate(publicKey, data.tip || 0, data.value);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.CHANGE_NOMINATION:
+                (0, assert_1.assertFields)(`${type} action`, data, 'targets');
+                return this.prepareChangeValidator(publicKey, data.tip || 0, data.targets);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.UNBOND:
+                (0, assert_1.assertFields)(`${type} action`, data, 'value');
+                return this.prepareUnbond(publicKey, data.tip || 0, data.value);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.REBOND:
+                (0, assert_1.assertFields)(`${type} action`, data, 'value');
+                return this.prepareRebond(publicKey, data.tip || 0, data.value);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.BOND_EXTRA:
+                (0, assert_1.assertFields)(`${type} action`, data, 'value');
+                return this.prepareBondExtra(publicKey, data.tip || 0, data.value);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.REBOND_EXTRA:
+                (0, assert_1.assertFields)(`${type} action`, data, 'value');
+                return this.prepareRebondExtra(publicKey, data.tip || 0, data.value);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.WITHDRAW_UNBONDED:
+                return this.prepareWithdrawUnbonded(publicKey, data.tip || 0);
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.CHANGE_REWARD_DESTINATION:
+                return Promise.reject('Unsupported delegator action.');
+            case PolkadotStakingActionType_1.PolkadotStakingActionType.CHANGE_CONTROLLER:
+                return Promise.reject('Unsupported delegator action.');
+            default:
+                return Promise.reject('Unsupported delegator action.');
+        }
+    }
+    async prepareNomination(publicKey, tip, targets, controller, value, payee) {
+        const balance = await this.accountController.getBalance(publicKey);
+        const available = new bignumber_1.default(balance.transferable).minus(value || 0);
+        const bondFirst = controller !== undefined && value !== undefined && payee !== undefined;
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, available, [
+            ...(bondFirst
+                ? [
+                    // tslint:disable-next-line: no-object-literal-type-assertion
+                    {
+                        type: 'bond',
+                        tip,
+                        args: {
+                            controller,
+                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value),
+                            payee: typeof payee === 'string' ? PolkadotPayee_1.PolkadotPayee[payee] : payee
                         }
-                        return [4 /*yield*/, this.nodeClient.getValidators()];
-                    case 1:
-                        validators = _a.sent();
-                        return [2 /*return*/, validators ? validators[0].asString() : ''];
+                    }
+                ]
+                : []),
+            {
+                type: 'nominate',
+                tip,
+                args: {
+                    targets: typeof targets === 'string' ? [targets] : targets
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getCurrentDelegateesForPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getCurrentValidators(publicKey)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getCurrentDelegateesForAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getCurrentValidators(address)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getDelegateeDetails = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var validatorDetails;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.accountController.getValidatorDetails(address)];
-                    case 1:
-                        validatorDetails = _a.sent();
-                        return [2 /*return*/, {
-                                name: validatorDetails.name || '',
-                                status: validatorDetails.status || '',
-                                address: address
-                            }];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareRebondNominate(publicKey, tip, targets, value) {
+        const [balance, lockedBalance] = await Promise.all([
+            this.accountController.getBalance(publicKey),
+            this.accountController.getUnlockingBalance(publicKey)
+        ]);
+        const toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
+        const params = [];
+        if (toDelegate.gt(lockedBalance)) {
+            params.push({
+                type: 'rebond',
+                tip,
+                args: {
+                    value: lockedBalance
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.isPublicKeyDelegating = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.isDelegating(publicKey)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.isAddressDelegating = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.isDelegating(address)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getDelegatorDetailsFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, this.getDelegatorDetailsFromAddress(address)];
+            }, {
+                type: 'bond_extra',
+                tip,
+                args: {
+                    value: toDelegate.minus(lockedBalance)
                 }
             });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getDelegatorDetailsFromAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getNominatorDetails(address)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.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)];
+        }
+        else {
+            params.push({
+                type: 'rebond',
+                tip,
+                args: {
+                    value: toDelegate
                 }
             });
+        }
+        params.push({
+            type: 'nominate',
+            tip,
+            args: {
+                targets: typeof targets === 'string' ? [targets] : targets
+            }
         });
-    };
-    PolkadotBaseProtocolImpl.prototype.getDelegationDetailsFromAddress = function (address, delegatees) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, nominatorDetails, validatorsDetails;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            this.accountController.getNominatorDetails(address, delegatees),
-                            Promise.all(delegatees.map(function (validator) { return _this.accountController.getValidatorDetails(validator); }))
-                        ])];
-                    case 1:
-                        _a = _b.sent(), nominatorDetails = _a[0], validatorsDetails = _a[1];
-                        nominatorDetails.rewards =
-                            nominatorDetails.delegatees.length > 0 && nominatorDetails.stakingDetails
-                                ? nominatorDetails.stakingDetails.rewards.map(function (reward) { return ({
-                                    index: reward.eraIndex,
-                                    amount: reward.amount,
-                                    timestamp: reward.timestamp
-                                }); })
-                                : [];
-                        return [2 /*return*/, {
-                                delegator: nominatorDetails,
-                                delegatees: validatorsDetails
-                            }];
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, params);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareScheduleUndelegate(publicKey, tip, value) {
+        const balance = await this.accountController.getBalance(publicKey);
+        const keepController = value === undefined;
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
+            {
+                type: 'cancel_nomination',
+                tip,
+                args: {}
+            },
+            ...(keepController
+                ? []
+                : [
+                    {
+                        type: 'unbond',
+                        tip,
+                        args: {
+                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
+                        }
+                    }
+                ])
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareChangeValidator(publicKey, tip, targets) {
+        const balance = await this.accountController.getBalance(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
+            {
+                type: 'nominate',
+                tip,
+                args: {
+                    targets: typeof targets === 'string' ? [targets] : targets
                 }
-            });
-        });
-    };
-    // tslint:disable-next-line: cyclomatic-complexity
-    PolkadotBaseProtocolImpl.prototype.prepareDelegatorActionFromPublicKey = function (publicKey, type, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (!data) {
-                    data = {};
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareUnbond(publicKey, tip, value) {
+        const balance = await this.accountController.getBalance(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
+            {
+                type: 'unbond',
+                tip,
+                args: {
+                    value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
                 }
-                switch (type) {
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.BOND_NOMINATE:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets', 'value', 'payee');
-                        return [2 /*return*/, this.prepareNomination(publicKey, data.tip || 0, data.targets, data.controller || publicKey, data.value, data.payee)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.REBOND_NOMINATE:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets', 'value');
-                        return [2 /*return*/, this.prepareRebondNominate(publicKey, data.tip || 0, data.targets, data.value)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.NOMINATE:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets');
-                        return [2 /*return*/, this.prepareNomination(publicKey, data.tip || 0, data.targets)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.CANCEL_NOMINATION:
-                        return [2 /*return*/, this.prepareScheduleUndelegate(publicKey, data.tip || 0, data.value)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.CHANGE_NOMINATION:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'targets');
-                        return [2 /*return*/, this.prepareChangeValidator(publicKey, data.tip || 0, data.targets)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.UNBOND:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
-                        return [2 /*return*/, this.prepareUnbond(publicKey, data.tip || 0, data.value)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.REBOND:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
-                        return [2 /*return*/, this.prepareRebond(publicKey, data.tip || 0, data.value)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.BOND_EXTRA:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
-                        return [2 /*return*/, this.prepareBondExtra(publicKey, data.tip || 0, data.value)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.REBOND_EXTRA:
-                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'value');
-                        return [2 /*return*/, this.prepareRebondExtra(publicKey, data.tip || 0, data.value)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.WITHDRAW_UNBONDED:
-                        return [2 /*return*/, this.prepareWithdrawUnbonded(publicKey, data.tip || 0)];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.CHANGE_REWARD_DESTINATION:
-                        return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
-                    case PolkadotStakingActionType_1.PolkadotStakingActionType.CHANGE_CONTROLLER:
-                        return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
-                    default:
-                        return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareRebond(publicKey, tip, value) {
+        const balance = await this.accountController.getBalance(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
+            {
+                type: 'rebond',
+                tip,
+                args: {
+                    value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareNomination = function (publicKey, tip, targets, controller, value, payee) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance, available, bondFirst, encoded;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.accountController.getBalance(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        available = new bignumber_1.default(balance.transferable).minus(value || 0);
-                        bondFirst = controller !== undefined && value !== undefined && payee !== undefined;
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, available, __spreadArray(__spreadArray([], (bondFirst
-                                ? [
-                                    // tslint:disable-next-line: no-object-literal-type-assertion
-                                    {
-                                        type: 'bond',
-                                        tip: tip,
-                                        args: {
-                                            controller: controller,
-                                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value),
-                                            payee: typeof payee === 'string' ? PolkadotPayee_1.PolkadotPayee[payee] : payee
-                                        }
-                                    }
-                                ]
-                                : []), true), [
-                                {
-                                    type: 'nominate',
-                                    tip: tip,
-                                    args: {
-                                        targets: typeof targets === 'string' ? [targets] : targets
-                                    }
-                                }
-                            ], false))];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareBondExtra(publicKey, tip, value) {
+        const balance = await this.accountController.getBalance(publicKey);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
+            {
+                type: 'bond_extra',
+                tip,
+                args: {
+                    value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareRebondNominate = function (publicKey, tip, targets, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, balance, lockedBalance, toDelegate, params, encoded;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            this.accountController.getBalance(publicKey),
-                            this.accountController.getUnlockingBalance(publicKey)
-                        ])];
-                    case 1:
-                        _a = _b.sent(), balance = _a[0], lockedBalance = _a[1];
-                        toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
-                        params = [];
-                        if (toDelegate.gt(lockedBalance)) {
-                            params.push({
-                                type: 'rebond',
-                                tip: tip,
-                                args: {
-                                    value: lockedBalance
-                                }
-                            }, {
-                                type: 'bond_extra',
-                                tip: tip,
-                                args: {
-                                    value: toDelegate.minus(lockedBalance)
-                                }
-                            });
-                        }
-                        else {
-                            params.push({
-                                type: 'rebond',
-                                tip: tip,
-                                args: {
-                                    value: toDelegate
-                                }
-                            });
-                        }
-                        params.push({
-                            type: 'nominate',
-                            tip: tip,
-                            args: {
-                                targets: typeof targets === 'string' ? [targets] : targets
-                            }
-                        });
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, params)];
-                    case 2:
-                        encoded = _b.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareRebondExtra(publicKey, tip, value) {
+        const [balance, lockedBalance] = await Promise.all([
+            this.accountController.getBalance(publicKey),
+            this.accountController.getUnlockingBalance(publicKey)
+        ]);
+        const toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
+        const configs = toDelegate.gt(lockedBalance)
+            ? [
+                {
+                    type: 'rebond',
+                    tip,
+                    args: {
+                        value: lockedBalance
+                    }
+                },
+                {
+                    type: 'bond_extra',
+                    tip,
+                    args: {
+                        value: toDelegate.minus(lockedBalance)
+                    }
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareScheduleUndelegate = function (publicKey, tip, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance, keepController, encoded;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.accountController.getBalance(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        keepController = value === undefined;
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, __spreadArray([
-                                {
-                                    type: 'cancel_nomination',
-                                    tip: tip,
-                                    args: {}
-                                }
-                            ], (keepController
-                                ? []
-                                : [
-                                    {
-                                        type: 'unbond',
-                                        tip: tip,
-                                        args: {
-                                            value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
-                                        }
-                                    }
-                                ]), true))];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ]
+            : [
+                {
+                    type: 'rebond',
+                    tip,
+                    args: {
+                        value: toDelegate
+                    }
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareChangeValidator = function (publicKey, tip, targets) {
-        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.accountController.getBalance(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
-                                {
-                                    type: 'nominate',
-                                    tip: tip,
-                                    args: {
-                                        targets: typeof targets === 'string' ? [targets] : targets
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ];
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, configs);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    async prepareWithdrawUnbonded(publicKey, tip) {
+        const [balance, slashingSpansNumber] = await Promise.all([
+            this.accountController.getBalance(publicKey),
+            this.accountController.getSlashingSpansNumber(publicKey)
+        ]);
+        const encoded = await this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
+            {
+                type: 'withdraw_unbonded',
+                tip,
+                args: { slashingSpansNumber }
+            }
+        ]);
+        return [(0, module_kit_1.newUnsignedTransaction)({ encoded })];
+    }
+    // Custom
+    async getNominatorDetails(address, validators) {
+        return this.accountController.getNominatorDetails(address, validators);
+    }
+    async getValidatorDetails(address) {
+        return this.accountController.getValidatorDetails(address);
+    }
+    async getNominationStatus(address, validator, era) {
+        return this.accountController.getNominationStatus(address, validator, era);
+    }
+    async getStakingBalance(address) {
+        const stakingBalance = await this.accountController.getStakingBalance(address);
+        if (stakingBalance === undefined) {
+            return undefined;
+        }
+        return {
+            bonded: (0, module_kit_1.newAmount)(stakingBalance.bonded, 'blockchain'),
+            unlocking: (0, module_kit_1.newAmount)(stakingBalance.unlocking, 'blockchain')
+        };
+    }
+    async getMinNominatorBond() {
+        const minNominatorBond = await this.nodeClient.getMinNominatorBond();
+        return (0, module_kit_1.newAmount)(minNominatorBond ?? 0, 'blockchain');
+    }
+    async getExistentialDeposit() {
+        const existentialDeposit = await this.nodeClient.getExistentialDeposit();
+        return (0, module_kit_1.newAmount)(existentialDeposit ?? 0, 'blockchain');
+    }
+    async getFutureStakingTransactionsFee(address) {
+        const futureTransactions = await this.getFutureRequiredTransactions(address, 'delegate');
+        const feeEstimation = await this.transactionController.estimateTransactionFees(address, futureTransactions);
+        return (0, module_kit_1.newAmount)(feeEstimation, 'blockchain');
+    }
+    async getFutureRequiredTransactions(accountId, intention) {
+        const results = await Promise.all([
+            this.accountController.isBonded(accountId),
+            this.accountController.isDelegating(accountId),
+            this.accountController.getBalance(accountId),
+            this.accountController.getUnlockingBalance(accountId)
+        ]);
+        const isBonded = results[0];
+        const isNominating = results[1];
+        const balance = results[2];
+        const unlockingBalance = results[3];
+        const transferableBalance = balance.transferable.minus(balance.existentialDeposit);
+        const stakingBalance = balance.transferable;
+        const isUnbonding = unlockingBalance.gt(0);
+        const requiredTransactions = [];
+        if (intention === 'transfer') {
+            requiredTransactions.push([
+                'transfer',
+                {
+                    to: v1_1.SubstrateSS58Address.createPlaceholder(),
+                    value: transferableBalance
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareUnbond = function (publicKey, tip, value) {
-        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.accountController.getBalance(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
-                                {
-                                    type: 'unbond',
-                                    tip: tip,
-                                    args: {
-                                        value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ]);
+        }
+        if (!isBonded && !isUnbonding && intention === 'delegate') {
+            // not delegated & unbond
+            requiredTransactions.push([
+                'bond',
+                {
+                    // controller: SubstrateSS58Address.createPlaceholder(),
+                    value: stakingBalance,
+                    payee: 0
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareRebond = function (publicKey, tip, value) {
-        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.accountController.getBalance(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
-                                {
-                                    type: 'rebond',
-                                    tip: tip,
-                                    args: {
-                                        value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ], [
+                'nominate',
+                {
+                    targets: [v1_1.SubstrateSS58Address.createPlaceholder()]
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareBondExtra = function (publicKey, tip, value) {
-        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.accountController.getBalance(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
-                                {
-                                    type: 'bond_extra',
-                                    tip: tip,
-                                    args: {
-                                        value: bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value)
-                                    }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _a.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ], ['cancel_nomination', {}], [
+                'unbond',
+                {
+                    value: stakingBalance
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareRebondExtra = function (publicKey, tip, value) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, balance, lockedBalance, toDelegate, configs, encoded;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            this.accountController.getBalance(publicKey),
-                            this.accountController.getUnlockingBalance(publicKey)
-                        ])];
-                    case 1:
-                        _a = _b.sent(), balance = _a[0], lockedBalance = _a[1];
-                        toDelegate = bignumber_1.default.isBigNumber(value) ? value : new bignumber_1.default(value);
-                        configs = toDelegate.gt(lockedBalance)
-                            ? [
-                                {
-                                    type: 'rebond',
-                                    tip: tip,
-                                    args: {
-                                        value: lockedBalance
-                                    }
-                                },
-                                {
-                                    type: 'bond_extra',
-                                    tip: tip,
-                                    args: {
-                                        value: toDelegate.minus(lockedBalance)
-                                    }
-                                }
-                            ]
-                            : [
-                                {
-                                    type: 'rebond',
-                                    tip: tip,
-                                    args: {
-                                        value: toDelegate
-                                    }
-                                }
-                            ];
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, configs)];
-                    case 2:
-                        encoded = _b.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ], [
+                'withdraw_unbonded',
+                {
+                    slashingSpansNumber: 0
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.prepareWithdrawUnbonded = function (publicKey, tip) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, balance, slashingSpansNumber, encoded;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            this.accountController.getBalance(publicKey),
-                            this.accountController.getSlashingSpansNumber(publicKey)
-                        ])];
-                    case 1:
-                        _a = _b.sent(), balance = _a[0], slashingSpansNumber = _a[1];
-                        return [4 /*yield*/, this.transactionController.prepareSubmittableTransactions(publicKey, balance.transferable, [
-                                {
-                                    type: 'withdraw_unbonded',
-                                    tip: tip,
-                                    args: { slashingSpansNumber: slashingSpansNumber }
-                                }
-                            ])];
-                    case 2:
-                        encoded = _b.sent();
-                        return [2 /*return*/, [(0, module_kit_1.newUnsignedTransaction)({ encoded: encoded })]];
+            ]);
+        }
+        else if (isUnbonding && intention === 'delegate') {
+            requiredTransactions.push([
+                'rebond',
+                {
+                    value: unlockingBalance
                 }
-            });
-        });
-    };
-    // Custom
-    PolkadotBaseProtocolImpl.prototype.getNominatorDetails = function (address, validators) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getNominatorDetails(address, validators)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getValidatorDetails = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getValidatorDetails(address)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getNominationStatus = function (address, validator, era) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountController.getNominationStatus(address, validator, era)];
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getStakingBalance = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var stakingBalance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.accountController.getStakingBalance(address)];
-                    case 1:
-                        stakingBalance = _a.sent();
-                        if (stakingBalance === undefined) {
-                            return [2 /*return*/, undefined];
-                        }
-                        return [2 /*return*/, {
-                                bonded: (0, module_kit_1.newAmount)(stakingBalance.bonded, 'blockchain'),
-                                unlocking: (0, module_kit_1.newAmount)(stakingBalance.unlocking, 'blockchain')
-                            }];
+            ], [
+                'nominate',
+                {
+                    targets: [v1_1.SubstrateSS58Address.createPlaceholder()]
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getMinNominatorBond = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var minNominatorBond;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.nodeClient.getMinNominatorBond()];
-                    case 1:
-                        minNominatorBond = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newAmount)(minNominatorBond !== null && minNominatorBond !== void 0 ? minNominatorBond : 0, 'blockchain')];
+            ], ['cancel_nomination', {}], [
+                'unbond',
+                {
+                    value: stakingBalance.plus(unlockingBalance)
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getExistentialDeposit = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var existentialDeposit;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.nodeClient.getExistentialDeposit()];
-                    case 1:
-                        existentialDeposit = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newAmount)(existentialDeposit !== null && existentialDeposit !== void 0 ? existentialDeposit : 0, 'blockchain')];
+            ], [
+                'withdraw_unbonded',
+                {
+                    slashingSpansNumber: 0
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getFutureStakingTransactionsFee = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var futureTransactions, feeEstimation;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getFutureRequiredTransactions(address, 'delegate')];
-                    case 1:
-                        futureTransactions = _a.sent();
-                        return [4 /*yield*/, this.transactionController.estimateTransactionFees(address, futureTransactions)];
-                    case 2:
-                        feeEstimation = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newAmount)(feeEstimation, 'blockchain')];
+            ]);
+        }
+        else if (isBonded) {
+            requiredTransactions.push([
+                'unbond',
+                {
+                    value: stakingBalance
                 }
-            });
-        });
-    };
-    PolkadotBaseProtocolImpl.prototype.getFutureRequiredTransactions = function (accountId, intention) {
-        return __awaiter(this, void 0, void 0, function () {
-            var results, isBonded, isNominating, balance, unlockingBalance, transferableBalance, stakingBalance, isUnbonding, requiredTransactions;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            this.accountController.isBonded(accountId),
-                            this.accountController.isDelegating(accountId),
-                            this.accountController.getBalance(accountId),
-                            this.accountController.getUnlockingBalance(accountId)
-                        ])];
-                    case 1:
-                        results = _a.sent();
-                        isBonded = results[0];
-                        isNominating = results[1];
-                        balance = results[2];
-                        unlockingBalance = results[3];
-                        transferableBalance = balance.transferable.minus(balance.existentialDeposit);
-                        stakingBalance = balance.transferable;
-                        isUnbonding = unlockingBalance.gt(0);
-                        requiredTransactions = [];
-                        if (intention === 'transfer') {
-                            requiredTransactions.push([
-                                'transfer',
-                                {
-                                    to: v1_1.SubstrateSS58Address.createPlaceholder(),
-                                    value: transferableBalance
-                                }
-                            ]);
-                        }
-                        if (!isBonded && !isUnbonding && intention === 'delegate') {
-                            // not delegated & unbond
-                            requiredTransactions.push([
-                                'bond',
-                                {
-                                    // controller: SubstrateSS58Address.createPlaceholder(),
-                                    value: stakingBalance,
-                                    payee: 0
-                                }
-                            ], [
-                                'nominate',
-                                {
-                                    targets: [v1_1.SubstrateSS58Address.createPlaceholder()]
-                                }
-                            ], ['cancel_nomination', {}], [
-                                'unbond',
-                                {
-                                    value: stakingBalance
-                                }
-                            ], [
-                                'withdraw_unbonded',
-                                {
-                                    slashingSpansNumber: 0
-                                }
-                            ]);
-                        }
-                        else if (isUnbonding && intention === 'delegate') {
-                            requiredTransactions.push([
-                                'rebond',
-                                {
-                                    value: unlockingBalance
-                                }
-                            ], [
-                                'nominate',
-                                {
-                                    targets: [v1_1.SubstrateSS58Address.createPlaceholder()]
-                                }
-                            ], ['cancel_nomination', {}], [
-                                'unbond',
-                                {
-                                    value: stakingBalance.plus(unlockingBalance)
-                                }
-                            ], [
-                                'withdraw_unbonded',
-                                {
-                                    slashingSpansNumber: 0
-                                }
-                            ]);
-                        }
-                        else if (isBonded) {
-                            requiredTransactions.push([
-                                'unbond',
-                                {
-                                    value: stakingBalance
-                                }
-                            ], [
-                                'withdraw_unbonded',
-                                {
-                                    slashingSpansNumber: 0
-                                }
-                            ]);
-                        }
-                        if (isNominating) {
-                            requiredTransactions.push(['cancel_nomination', {}]);
-                        }
-                        return [2 /*return*/, requiredTransactions];
+            ], [
+                'withdraw_unbonded',
+                {
+                    slashingSpansNumber: 0
                 }
-            });
-        });
-    };
-    return PolkadotBaseProtocolImpl;
-}(v1_1.SubstrateStakingProtocolImpl));
+            ]);
+        }
+        if (isNominating) {
+            requiredTransactions.push(['cancel_nomination', {}]);
+        }
+        return requiredTransactions;
+    }
+}
 exports.PolkadotBaseProtocolImpl = PolkadotBaseProtocolImpl;
 //# sourceMappingURL=PolkadotBaseProtocol.js.map