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

package/v0/protocol/CosmosProtocol.js

@@ -1,62 +1,123 @@
 "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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) 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.CosmosProtocol = exports.CosmosDelegationActionType = void 0;
-const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 // @ts-ignore
-const index_1 = require("@airgap/coinlib-core/dependencies/src/bip32-2.0.4/src/index");
+var index_1 = require("@airgap/coinlib-core/dependencies/src/bip32-2.0.4/src/index");
 // @ts-ignore
-const index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
-const cosmjs_1 = require("@airgap/coinlib-core/dependencies/src/cosmjs");
+var index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
+var cosmjs_1 = require("@airgap/coinlib-core/dependencies/src/cosmjs");
 // @ts-ignore
-const SECP256K1 = require("@airgap/coinlib-core/dependencies/src/secp256k1-3.7.1/elliptic");
+var SECP256K1 = require("@airgap/coinlib-core/dependencies/src/secp256k1-3.7.1/elliptic");
 // @ts-ignore
-const sha = require("@airgap/coinlib-core/dependencies/src/sha.js-2.4.11/index");
-const errors_1 = require("@airgap/coinlib-core/errors");
-const coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-const NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
-const assert_1 = require("@airgap/coinlib-core/utils/assert");
-const ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
-const CosmosDelegateMessage_1 = require("./cosmos-message/CosmosDelegateMessage");
-const CosmosMessage_1 = require("./cosmos-message/CosmosMessage");
-const CosmosSendMessage_1 = require("./cosmos-message/CosmosSendMessage");
-const CosmosWithdrawDelegationRewardMessage_1 = require("./cosmos-message/CosmosWithdrawDelegationRewardMessage");
-const CosmosAddress_1 = require("./CosmosAddress");
-const CosmosCoin_1 = require("./CosmosCoin");
-const CosmosCryptoClient_1 = require("./CosmosCryptoClient");
-const CosmosFee_1 = require("./CosmosFee");
-const CosmosTypes_1 = require("./CosmosTypes");
-const CosmosProtocolOptions_1 = require("./CosmosProtocolOptions");
-const CosmosTransaction_1 = require("./CosmosTransaction");
+var sha = require("@airgap/coinlib-core/dependencies/src/sha.js-2.4.11/index");
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
+var assert_1 = require("@airgap/coinlib-core/utils/assert");
+var ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
+var CosmosDelegateMessage_1 = require("./cosmos-message/CosmosDelegateMessage");
+var CosmosMessage_1 = require("./cosmos-message/CosmosMessage");
+var CosmosSendMessage_1 = require("./cosmos-message/CosmosSendMessage");
+var CosmosWithdrawDelegationRewardMessage_1 = require("./cosmos-message/CosmosWithdrawDelegationRewardMessage");
+var CosmosAddress_1 = require("./CosmosAddress");
+var CosmosCoin_1 = require("./CosmosCoin");
+var CosmosCryptoClient_1 = require("./CosmosCryptoClient");
+var CosmosFee_1 = require("./CosmosFee");
+var CosmosTypes_1 = require("./CosmosTypes");
+var CosmosProtocolOptions_1 = require("./CosmosProtocolOptions");
+var CosmosTransaction_1 = require("./CosmosTransaction");
 var CosmosDelegationActionType;
 (function (CosmosDelegationActionType) {
     CosmosDelegationActionType["DELEGATE"] = "delegate";
     CosmosDelegationActionType["UNDELEGATE"] = "undelegate";
     CosmosDelegationActionType["WITHDRAW_ALL_REWARDS"] = "withdraw_all_rewards";
     CosmosDelegationActionType["WITHDRAW_VALIDATOR_REWARDS"] = "withdraw_validator_rewards";
-})(CosmosDelegationActionType || (exports.CosmosDelegationActionType = CosmosDelegationActionType = {}));
-class CosmosProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
-    get nodeClient() {
-        return this.options.config.nodeClient;
-    }
-    constructor(options = new CosmosProtocolOptions_1.CosmosProtocolOptions()) {
-        super();
-        this.options = options;
-        this.symbol = 'ATOM';
-        this.name = 'Cosmos';
-        this.marketSymbol = 'atom';
-        this.feeSymbol = 'atom';
-        this.feeDefaults = {
+})(CosmosDelegationActionType = exports.CosmosDelegationActionType || (exports.CosmosDelegationActionType = {}));
+var CosmosProtocol = /** @class */ (function (_super) {
+    __extends(CosmosProtocol, _super);
+    function CosmosProtocol(options) {
+        if (options === void 0) { options = new CosmosProtocolOptions_1.CosmosProtocolOptions(); }
+        var _this = _super.call(this) || this;
+        _this.options = options;
+        _this.symbol = 'ATOM';
+        _this.name = 'Cosmos';
+        _this.marketSymbol = 'atom';
+        _this.feeSymbol = 'atom';
+        _this.feeDefaults = {
             low: '0.0005',
             medium: '0.005',
             high: '0.0075'
         };
-        this.decimals = 6;
-        this.feeDecimals = 6;
-        this.identifier = ProtocolSymbols_1.MainProtocolSymbols.COSMOS;
-        this.units = [
+        _this.decimals = 6;
+        _this.feeDecimals = 6;
+        _this.identifier = ProtocolSymbols_1.MainProtocolSymbols.COSMOS;
+        _this.units = [
             {
                 unitSymbol: 'atom',
                 factor: '1'
@@ -66,534 +127,961 @@ class CosmosProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
                 factor: '0.000001'
             }
         ];
-        this.supportsHD = false;
-        this.standardDerivationPath = `m/44'/118'/0'/0/0`;
-        this.addressIsCaseSensitive = false;
-        this.addressValidationPattern = '^(cosmos|cosmosvaloper)[a-zA-Z0-9]{39}$';
-        this.addressPlaceholder = 'cosmos...';
-        this.defaultGas = new bignumber_1.default('310000');
-        this.cryptoClient = new CosmosCryptoClient_1.CosmosCryptoClient();
-    }
-    async getSymbol() {
-        return this.symbol;
-    }
-    async getName() {
-        return this.name;
-    }
-    async getMarketSymbol() {
-        return this.marketSymbol;
-    }
-    async getAssetSymbol() {
-        return undefined;
-    }
-    async getFeeSymbol() {
-        return this.feeSymbol;
-    }
-    async getFeeDefaults() {
-        return this.feeDefaults;
-    }
-    async getDecimals() {
-        return this.decimals;
-    }
-    async getFeeDecimals() {
-        return this.feeDecimals;
-    }
-    async getIdentifier() {
-        return this.identifier;
-    }
-    async getUnits() {
-        return this.units;
-    }
-    async getSupportsHD() {
-        return this.supportsHD;
-    }
-    async getStandardDerivationPath() {
-        return this.standardDerivationPath;
-    }
-    async getAddressIsCaseSensitive() {
-        return this.addressIsCaseSensitive;
-    }
-    async getAddressValidationPattern() {
-        return this.addressValidationPattern;
-    }
-    async getAddressPlaceholder() {
-        return this.addressPlaceholder;
-    }
-    async getOptions() {
-        return this.options;
-    }
-    async getBlockExplorerLinkForAddress(address) {
-        return this.options.network.blockExplorer.getAddressLink(address);
-    }
-    async getBlockExplorerLinkForTxId(txId) {
-        return this.options.network.blockExplorer.getTransactionLink(txId);
-    }
-    generateKeyPair(mnemonic, derivationPath = this.standardDerivationPath, password) {
+        _this.supportsHD = false;
+        _this.standardDerivationPath = "m/44'/118'/0'/0/0";
+        _this.addressIsCaseSensitive = false;
+        _this.addressValidationPattern = '^(cosmos|cosmosvaloper)[a-zA-Z0-9]{39}$';
+        _this.addressPlaceholder = 'cosmos...';
+        _this.defaultGas = new bignumber_1.default('310000');
+        _this.cryptoClient = new CosmosCryptoClient_1.CosmosCryptoClient();
+        return _this;
+    }
+    Object.defineProperty(CosmosProtocol.prototype, "nodeClient", {
+        get: function () {
+            return this.options.config.nodeClient;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CosmosProtocol.prototype.getSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.symbol];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getName = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.name];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getMarketSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.marketSymbol];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAssetSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getFeeSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeSymbol];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getFeeDefaults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDefaults];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decimals];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getFeeDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDecimals];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getIdentifier = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.identifier];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getUnits = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.units];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getSupportsHD = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.supportsHD];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getStandardDerivationPath = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.standardDerivationPath];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAddressIsCaseSensitive = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressIsCaseSensitive];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAddressValidationPattern = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressValidationPattern];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAddressPlaceholder = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressPlaceholder];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getOptions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getBlockExplorerLinkForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network.blockExplorer.getAddressLink(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getBlockExplorerLinkForTxId = function (txId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network.blockExplorer.getTransactionLink(txId)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.generateKeyPair = function (mnemonic, derivationPath, password) {
+        if (derivationPath === void 0) { derivationPath = this.standardDerivationPath; }
         (0, index_2.validateMnemonic)(mnemonic);
-        const seed = (0, index_2.mnemonicToSeed)(mnemonic, password);
-        const node = (0, index_1.fromSeed)(seed);
+        var seed = (0, index_2.mnemonicToSeed)(mnemonic, password);
+        var node = (0, index_1.fromSeed)(seed);
         return this.generateKeyPairFromNode(node, derivationPath);
-    }
-    generateKeyPairFromNode(node, derivationPath) {
-        const keys = node.derivePath(derivationPath);
-        const privateKey = keys.privateKey;
+    };
+    CosmosProtocol.prototype.generateKeyPairFromNode = function (node, derivationPath) {
+        var keys = node.derivePath(derivationPath);
+        var privateKey = keys.privateKey;
         if (privateKey === undefined) {
             throw new errors_1.InvalidValueError(coinlib_error_1.Domain.COSMOS, 'Cannot generate private key');
         }
         return {
             publicKey: keys.publicKey,
-            privateKey
+            privateKey: privateKey
         };
-    }
-    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
-        return this.generateKeyPair(mnemonic, derivationPath, password).publicKey.toString('hex');
-    }
-    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
-        return this.generateKeyPair(mnemonic, derivationPath, password).privateKey.toString('hex');
-    }
-    async getPublicKeyFromHexSecret(secret, derivationPath) {
-        const node = (0, index_1.fromSeed)(Buffer.from(secret, 'hex'));
-        return this.generateKeyPairFromNode(node, derivationPath).publicKey.toString('hex');
-    }
-    getPublicKeyFromPrivateKey(privateKey) {
-        const publicKey = SECP256K1.publicKeyCreate(privateKey);
+    };
+    CosmosProtocol.prototype.getPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.generateKeyPair(mnemonic, derivationPath, password).publicKey.toString('hex')];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.generateKeyPair(mnemonic, derivationPath, password).privateKey.toString('hex')];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node;
+            return __generator(this, function (_a) {
+                node = (0, index_1.fromSeed)(Buffer.from(secret, 'hex'));
+                return [2 /*return*/, this.generateKeyPairFromNode(node, derivationPath).publicKey.toString('hex')];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getPublicKeyFromPrivateKey = function (privateKey) {
+        var publicKey = SECP256K1.publicKeyCreate(privateKey);
         return Buffer.from(publicKey, 'binary');
-    }
-    async getPrivateKeyFromHexSecret(secret, derivationPath) {
-        const node = (0, index_1.fromSeed)(Buffer.from(secret, 'hex'));
-        return this.generateKeyPairFromNode(node, derivationPath).privateKey.toString('hex');
-    }
-    async getAddressFromPublicKey(publicKey, cursor) {
-        const address = CosmosAddress_1.CosmosAddress.from(publicKey);
-        return {
-            address: address.asString(),
-            cursor: { hasNext: false }
-        };
-    }
-    async getAddressesFromPublicKey(publicKey, cursor) {
-        return [await this.getAddressFromPublicKey(publicKey, cursor)];
-    }
-    async getTransactionsFromPublicKey(publicKey, limit, cursor) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getTransactionsFromAddresses([address.address], limit, cursor);
-    }
-    async getTransactionsFromAddresses(addresses, limit, cursor) {
-        const address = cursor?.address ?? addresses[0];
-        const promises = [];
-        let senderOffset = 0;
-        let recipientOffset = 0;
-        let senderTotal = 0;
-        let recipientTotal = 0;
-        let senderLimit = 0;
-        let recipientLimit = 0;
-        if (cursor) {
-            senderOffset = cursor.sender.offset;
-            recipientOffset = cursor.recipient.offset;
-            senderTotal = cursor.sender.total;
-            recipientTotal = cursor.recipient.total;
-            senderLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
-            if (senderOffset <= Math.floor(senderTotal / senderLimit) * senderLimit) {
-                promises.push(this.nodeClient.fetchSendTransactionsFor(address, senderLimit, senderOffset, true));
-            }
-            else {
-                promises.push(new Promise((resolve) => {
-                    resolve({ txs: [], tx_responses: [], pagination: { total: String(senderTotal) } });
-                }));
-            }
-            recipientLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, recipientTotal, senderTotal, recipientOffset, senderOffset);
-            if (recipientOffset <= Math.floor(recipientTotal / recipientLimit) * recipientLimit) {
-                promises.push(this.nodeClient.fetchSendTransactionsFor(address, recipientLimit, recipientOffset, false));
-            }
-            else {
-                promises.push(new Promise((resolve) => {
-                    resolve({ txs: [], tx_responses: [], pagination: { total: String(recipientTotal) } });
-                }));
-            }
-        }
-        else {
-            ;
-            [senderTotal, recipientTotal] = await Promise.all([
-                this.nodeClient
-                    .fetchSendTransactionsFor(address, 1, 0, true)
-                    .then((response) => new bignumber_1.default(response.pagination.total).toNumber()),
-                this.nodeClient
-                    .fetchSendTransactionsFor(address, 1, 0, false)
-                    .then((response) => new bignumber_1.default(response.pagination.total).toNumber())
-            ]);
-            senderLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
-            recipientLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, recipientTotal, senderTotal, recipientOffset, senderOffset);
-            promises.push(this.nodeClient.fetchSendTransactionsFor(address, senderLimit, senderOffset, true), this.nodeClient.fetchSendTransactionsFor(address, recipientLimit, recipientOffset, false));
-        }
-        const transactions = await Promise.all(promises);
-        const sentTransactions = transactions[0];
-        const receivedTransactions = transactions[1];
-        const allTransactions = sentTransactions?.tx_responses.concat(receivedTransactions?.tx_responses);
-        let result = [];
-        for (const transaction of allTransactions) {
-            const timestamp = new Date(transaction.timestamp).getTime() / 1000;
-            const fee = transaction.tx.auth_info.fee.amount
-                .filter((coin) => coin.denom === 'uatom')
-                .map((coin) => new bignumber_1.default(coin.amount))
-                .reduce((current, next) => current.plus(next));
-            result = result.concat(transaction.tx.body.messages.map((msg) => {
-                const tx = {
-                    fee: fee.toFixed(),
-                    protocolIdentifier: this.identifier,
-                    network: this.options.network,
-                    hash: transaction.txhash,
-                    timestamp,
-                    isInbound: false,
-                    amount: '0'
-                };
-                switch (msg['@type']) {
-                    case CosmosMessage_1.CosmosMessageTypeValue.UNDELEGATE:
-                        return {
-                            ...tx,
-                            from: [msg.validator_address],
-                            to: [msg.delegator_address]
-                        };
-                    case CosmosMessage_1.CosmosMessageTypeValue.WITHDRAW_DELEGATION_REWARD:
-                        return {
-                            ...tx,
-                            from: [msg.delegator_address],
-                            to: [msg.validator_address]
-                        };
-                    case CosmosMessage_1.CosmosMessageTypeValue.DELEGATE:
-                        return {
-                            ...tx,
-                            from: [msg.delegator_address],
-                            to: [msg.validator_address]
-                        };
-                    default:
-                        return {
-                            ...tx,
-                            from: [msg.from_address],
-                            to: [msg.to_address],
-                            isInbound: msg.to_address === address,
-                            amount: msg.amount[0].amount
+    };
+    CosmosProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node;
+            return __generator(this, function (_a) {
+                node = (0, index_1.fromSeed)(Buffer.from(secret, 'hex'));
+                return [2 /*return*/, this.generateKeyPairFromNode(node, derivationPath).privateKey.toString('hex')];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAddressFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                address = CosmosAddress_1.CosmosAddress.from(publicKey);
+                return [2 /*return*/, {
+                        address: address.asString(),
+                        cursor: { hasNext: false }
+                    }];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAddressesFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey, cursor)];
+                    case 1: return [2 /*return*/, [_a.sent()]];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getTransactionsFromPublicKey = function (publicKey, limit, cursor) {
+        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.getTransactionsFromAddresses([address.address], limit, cursor)];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getTransactionsFromAddresses = function (addresses, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var address, promises, senderOffset, recipientOffset, senderTotal, recipientTotal, senderLimit, recipientLimit, transactions, sentTransactions, receivedTransactions, allTransactions, result, _loop_1, _i, allTransactions_1, transaction;
+            var _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.address) !== null && _a !== void 0 ? _a : addresses[0];
+                        promises = [];
+                        senderOffset = 0;
+                        recipientOffset = 0;
+                        senderTotal = 0;
+                        recipientTotal = 0;
+                        senderLimit = 0;
+                        recipientLimit = 0;
+                        if (!cursor) return [3 /*break*/, 1];
+                        senderOffset = cursor.sender.offset;
+                        recipientOffset = cursor.recipient.offset;
+                        senderTotal = cursor.sender.total;
+                        recipientTotal = cursor.recipient.total;
+                        senderLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
+                        if (senderOffset <= Math.floor(senderTotal / senderLimit) * senderLimit) {
+                            promises.push(this.nodeClient.fetchSendTransactionsFor(address, senderLimit, senderOffset, true));
+                        }
+                        else {
+                            promises.push(new Promise(function (resolve) {
+                                resolve({ txs: [], tx_responses: [], pagination: { total: String(senderTotal) } });
+                            }));
+                        }
+                        recipientLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, recipientTotal, senderTotal, recipientOffset, senderOffset);
+                        if (recipientOffset <= Math.floor(recipientTotal / recipientLimit) * recipientLimit) {
+                            promises.push(this.nodeClient.fetchSendTransactionsFor(address, recipientLimit, recipientOffset, false));
+                        }
+                        else {
+                            promises.push(new Promise(function (resolve) {
+                                resolve({ txs: [], tx_responses: [], pagination: { total: String(recipientTotal) } });
+                            }));
+                        }
+                        return [3 /*break*/, 3];
+                    case 1:
+                        ;
+                        return [4 /*yield*/, Promise.all([
+                                this.nodeClient
+                                    .fetchSendTransactionsFor(address, 1, 0, true)
+                                    .then(function (response) { return new bignumber_1.default(response.pagination.total).toNumber(); }),
+                                this.nodeClient
+                                    .fetchSendTransactionsFor(address, 1, 0, false)
+                                    .then(function (response) { return new bignumber_1.default(response.pagination.total).toNumber(); })
+                            ])];
+                    case 2:
+                        _b = _c.sent(), senderTotal = _b[0], recipientTotal = _b[1];
+                        senderLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
+                        recipientLimit = (0, CosmosTypes_1.calculateTransactionLimit)(limit, recipientTotal, senderTotal, recipientOffset, senderOffset);
+                        promises.push(this.nodeClient.fetchSendTransactionsFor(address, senderLimit, senderOffset, true), this.nodeClient.fetchSendTransactionsFor(address, recipientLimit, recipientOffset, false));
+                        _c.label = 3;
+                    case 3: return [4 /*yield*/, Promise.all(promises)];
+                    case 4:
+                        transactions = _c.sent();
+                        sentTransactions = transactions[0];
+                        receivedTransactions = transactions[1];
+                        allTransactions = sentTransactions === null || sentTransactions === void 0 ? void 0 : sentTransactions.tx_responses.concat(receivedTransactions === null || receivedTransactions === void 0 ? void 0 : receivedTransactions.tx_responses);
+                        result = [];
+                        _loop_1 = function (transaction) {
+                            var timestamp = new Date(transaction.timestamp).getTime() / 1000;
+                            var fee = transaction.tx.auth_info.fee.amount
+                                .filter(function (coin) { return coin.denom === 'uatom'; })
+                                .map(function (coin) { return new bignumber_1.default(coin.amount); })
+                                .reduce(function (current, next) { return current.plus(next); });
+                            result = result.concat(transaction.tx.body.messages.map(function (msg) {
+                                var tx = {
+                                    fee: fee.toFixed(),
+                                    protocolIdentifier: _this.identifier,
+                                    network: _this.options.network,
+                                    hash: transaction.txhash,
+                                    timestamp: timestamp,
+                                    isInbound: false,
+                                    amount: '0'
+                                };
+                                switch (msg['@type']) {
+                                    case CosmosMessage_1.CosmosMessageTypeValue.UNDELEGATE:
+                                        return __assign(__assign({}, tx), { from: [msg.validator_address], to: [msg.delegator_address] });
+                                    case CosmosMessage_1.CosmosMessageTypeValue.WITHDRAW_DELEGATION_REWARD:
+                                        return __assign(__assign({}, tx), { from: [msg.delegator_address], to: [msg.validator_address] });
+                                    case CosmosMessage_1.CosmosMessageTypeValue.DELEGATE:
+                                        return __assign(__assign({}, tx), { from: [msg.delegator_address], to: [msg.validator_address] });
+                                    default:
+                                        return __assign(__assign({}, tx), { from: [msg.from_address], to: [msg.to_address], isInbound: msg.to_address === address, amount: msg.amount[0].amount });
+                                }
+                            }));
                         };
+                        for (_i = 0, allTransactions_1 = allTransactions; _i < allTransactions_1.length; _i++) {
+                            transaction = allTransactions_1[_i];
+                            _loop_1(transaction);
+                        }
+                        return [2 /*return*/, {
+                                transactions: result,
+                                cursor: {
+                                    address: address,
+                                    limit: limit,
+                                    sender: {
+                                        total: senderTotal,
+                                        offset: senderOffset + senderLimit
+                                    },
+                                    recipient: {
+                                        total: recipientTotal,
+                                        offset: recipientOffset + recipientLimit
+                                    }
+                                }
+                            }];
                 }
-            }));
-        }
-        return {
-            transactions: result,
-            cursor: {
-                address,
-                limit,
-                sender: {
-                    total: senderTotal,
-                    offset: senderOffset + senderLimit
-                },
-                recipient: {
-                    total: recipientTotal,
-                    offset: recipientOffset + recipientLimit
+            });
+        });
+    };
+    CosmosProtocol.prototype.signWithPrivateKey = function (privateKey, transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var privateKeyBuffer, publicKey, encodedObject, signBytes, sha256Hash, hash, signed, sigBase64, txBytes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        privateKeyBuffer = Buffer.from(privateKey, 'hex');
+                        publicKey = this.getPublicKeyFromPrivateKey(privateKeyBuffer);
+                        encodedObject = transaction.toEncodeObject();
+                        return [4 /*yield*/, (0, cosmjs_1.prepareSignBytes)(encodedObject, transaction.fee, Uint8Array.from(publicKey), new bignumber_1.default(transaction.sequence).toNumber(), transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber())];
+                    case 1:
+                        signBytes = _a.sent();
+                        sha256Hash = sha('sha256').update(signBytes).digest();
+                        hash = Buffer.from(sha256Hash);
+                        signed = SECP256K1.sign(hash, privateKeyBuffer);
+                        sigBase64 = Buffer.from(signed.signature, 'binary').toString('base64');
+                        return [4 /*yield*/, (0, cosmjs_1.encodeTxBytes)(encodedObject, transaction.fee, Uint8Array.from(publicKey), new bignumber_1.default(transaction.sequence).toNumber(), {
+                                signature: sigBase64,
+                                pub_key: {
+                                    type: 'tendermint/PubKeySecp256k1',
+                                    value: publicKey.toString('base64')
+                                }
+                            }, transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber())];
+                    case 2:
+                        txBytes = _a.sent();
+                        return [2 /*return*/, Buffer.from(txBytes).toString('base64')];
                 }
-            }
-        };
-    }
-    async signWithPrivateKey(privateKey, transaction) {
-        const privateKeyBuffer = Buffer.from(privateKey, 'hex');
-        const publicKey = this.getPublicKeyFromPrivateKey(privateKeyBuffer);
-        const encodedObject = transaction.toEncodeObject();
-        const signBytes = await (0, cosmjs_1.prepareSignBytes)(encodedObject, transaction.fee, Uint8Array.from(publicKey), new bignumber_1.default(transaction.sequence).toNumber(), transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber());
-        const sha256Hash = sha('sha256').update(signBytes).digest();
-        const hash = Buffer.from(sha256Hash);
-        const signed = SECP256K1.sign(hash, privateKeyBuffer);
-        const sigBase64 = Buffer.from(signed.signature, 'binary').toString('base64');
-        const txBytes = await (0, cosmjs_1.encodeTxBytes)(encodedObject, transaction.fee, Uint8Array.from(publicKey), new bignumber_1.default(transaction.sequence).toNumber(), {
-            signature: sigBase64,
-            pub_key: {
-                type: 'tendermint/PubKeySecp256k1',
-                value: publicKey.toString('base64')
-            }
-        }, transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber());
-        return Buffer.from(txBytes).toString('base64');
-    }
-    async getTransactionDetails(transaction) {
-        const result = transaction.transaction.toAirGapTransactions(this.identifier, this.options.network);
-        return result;
-    }
-    async getTransactionDetailsFromSigned(transaction) {
-        const bytes = Uint8Array.from(Buffer.from(transaction.transaction, 'base64'));
-        const decoded = await (0, cosmjs_1.decodeTxBytes)(bytes);
-        const fee = (decoded.fee?.amount)
-            .map(({ amount }) => new bignumber_1.default(amount))
-            .reduce((current, next) => current.plus(next))
-            .toString(10);
-        const result = decoded.messages
-            .map((message) => {
-            const type = message.typeUrl;
-            switch (type) {
-                case CosmosMessage_1.CosmosMessageType.Send.value:
-                    const sendMessage = CosmosSendMessage_1.CosmosSendMessage.fromEncodeObject(message);
-                    return sendMessage.toAirGapTransaction(this.identifier, this.options.network, fee);
-                case CosmosMessage_1.CosmosMessageType.Undelegate.value:
-                case CosmosMessage_1.CosmosMessageType.Delegate.value:
-                    const delegateMessage = CosmosDelegateMessage_1.CosmosDelegateMessage.fromEncodeObject(message);
-                    return delegateMessage.toAirGapTransaction(this.identifier, this.options.network, fee);
-                case CosmosMessage_1.CosmosMessageType.WithdrawDelegationReward.value:
-                    const withdrawMessage = CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage.fromEncodeObject(message);
-                    return withdrawMessage.toAirGapTransaction(this.identifier, this.options.network, fee);
-                default:
-                    throw new errors_1.InvalidValueError(coinlib_error_1.Domain.COSMOS, 'Unknown transaction');
-            }
-        })
-            .map((tx) => {
-            if (!tx.transactionDetails) {
-                tx.transactionDetails = {};
-            }
-            tx.transactionDetails.memo = decoded.memo;
-            if (decoded.signerInfos.length > 0) {
-                tx.transactionDetails.sequence = decoded.signerInfos[0].sequence.toString(10);
-            }
-            return tx;
+            });
         });
-        return result;
-    }
-    async getBalanceOfAddresses(addresses) {
-        return this.getBalance(addresses);
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddresses([address.address]);
-    }
-    async getAvailableBalanceOfAddresses(addresses) {
-        return this.getBalance(addresses, false);
-    }
-    async getBalanceOfPublicKeyForSubProtocols(publicKey, subProtocols) {
-        throw Promise.reject('get balance of sub protocols not supported');
-    }
-    async getBalance(addresses, totalBalance = true) {
-        const promises = [];
-        for (const address of addresses) {
-            promises.push(this.nodeClient.fetchBalance(address, totalBalance));
-        }
-        return (await Promise.all(promises).then((balances) => {
-            return balances.reduce((current, next) => {
-                return current.plus(next);
+    };
+    CosmosProtocol.prototype.getTransactionDetails = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                result = transaction.transaction.toAirGapTransactions(this.identifier, this.options.network);
+                return [2 /*return*/, result];
             });
-        })).toString(10);
-    }
-    async estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee) {
-        const address = (await this.getAddressFromPublicKey(publicKey)).address;
-        const balance = await this.getAvailableBalanceOfAddresses([address]);
-        const balanceWrapper = new bignumber_1.default(balance);
-        let maxFee;
-        if (fee !== undefined) {
-            maxFee = new bignumber_1.default(fee);
-        }
-        else {
-            const estimatedFeeDefaults = await this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, [balance]);
-            maxFee = new bignumber_1.default(estimatedFeeDefaults.medium).shiftedBy(this.decimals);
-            if (maxFee.gte(balanceWrapper)) {
-                maxFee = new bignumber_1.default(0);
-            }
-        }
-        let amountWithoutFees = balanceWrapper.minus(maxFee);
-        if (amountWithoutFees.isNegative()) {
-            amountWithoutFees = new bignumber_1.default(0);
-        }
-        return amountWithoutFees.toFixed();
-    }
-    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data) {
-        return this.feeDefaults;
-    }
-    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data) {
-        const wrappedValues = values.map((value) => new bignumber_1.default(value));
-        const wrappedFee = new bignumber_1.default(fee);
-        if (recipients.length !== wrappedValues.length) {
-            return Promise.reject('recipients length does not match with values');
-        }
-        const address = (await this.getAddressFromPublicKey(publicKey)).address;
-        const nodeInfo = await this.nodeClient.fetchNodeInfo();
-        const account = await this.nodeClient.fetchAccount(address);
-        const balance = new bignumber_1.default(await this.getAvailableBalanceOfAddresses([address]));
-        if (balance.lt(values.reduce((pv, cv) => pv.plus(cv), wrappedFee))) {
-            throw new errors_1.BalanceError(coinlib_error_1.Domain.COSMOS, 'not enough balance');
-        }
-        const messages = [];
-        for (let i = 0; i < recipients.length; ++i) {
-            const message = new CosmosSendMessage_1.CosmosSendMessage(address, recipients[i], [
-                new CosmosCoin_1.CosmosCoin('uatom', wrappedValues[i].toString(10))
-            ]);
-            messages.push(message);
-        }
-        const memo = data?.memo ?? '';
-        const transaction = new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin('uatom', wrappedFee.toString(10))], this.defaultGas.toString(10)), memo, nodeInfo.network, account.value.account_number, account.value.sequence ?? '0');
-        return transaction;
-    }
-    async getDefaultDelegatee() {
-        const validators = await this.nodeClient.fetchValidators();
-        return validators.length > 0 ? validators[0].operator_address : '';
-    }
-    async getCurrentDelegateesForPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getCurrentDelegateesForAddress(address.address);
-    }
-    async getCurrentDelegateesForAddress(address) {
-        const delegations = await this.nodeClient.fetchDelegations(address);
-        return delegations.map((delegation) => delegation.delegation.validator_address);
-    }
-    async getDelegateeDetails(address) {
-        const validator = await this.nodeClient.fetchValidator(address);
-        const statusCodes = { 0: 'jailed', 1: 'inactive', 2: 'active' };
-        return {
-            name: validator.description.moniker,
-            status: statusCodes[validator.status],
-            address: validator.operator_address
-        };
-    }
-    async isPublicKeyDelegating(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.isAddressDelegating(address.address);
-    }
-    async isAddressDelegating(address) {
-        const delegations = await this.nodeClient.fetchDelegations(address);
-        return delegations.length > 0;
-    }
-    async getDelegatorDetailsFromPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getDelegatorDetailsFromAddress(address.address);
-    }
-    async getDelegatorDetailsFromAddress(address) {
-        return this.getDelegatorDetails(address);
-    }
-    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getDelegationDetailsFromAddress(address.address, delegatees);
-    }
-    async getDelegationDetailsFromAddress(address, delegatees) {
-        if (delegatees.length > 1) {
-            return Promise.reject('Multiple validators for a single delegation are not supported.');
-        }
-        const validator = delegatees[0];
-        const results = await Promise.all([this.getDelegatorDetails(address, validator), this.getDelegateeDetails(validator)]);
-        const delegatorDetails = results[0];
-        const validatorDetails = results[1];
-        return {
-            delegator: delegatorDetails,
-            delegatees: [validatorDetails]
-        };
-    }
-    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
-        switch (type) {
-            case CosmosDelegationActionType.DELEGATE:
-                (0, assert_1.assertFields)(`${type} action`, data, 'validator', 'amount');
-                return [await this.delegate(publicKey, data.validator, data.amount)];
-            case CosmosDelegationActionType.UNDELEGATE:
-                (0, assert_1.assertFields)(`${type} action`, data, 'validator', 'amount');
-                return [await this.undelegate(publicKey, data.validator, data.amount)];
-            case CosmosDelegationActionType.WITHDRAW_ALL_REWARDS:
-                return [await this.withdrawDelegationRewards(publicKey)];
-            case CosmosDelegationActionType.WITHDRAW_VALIDATOR_REWARDS:
-                (0, assert_1.assertFields)(`${type} action`, data, 'validator');
-                return [await this.withdrawDelegationRewards(publicKey, [data.validator])];
-            default:
-                return Promise.reject(`Delegator action type ${type} is not supported.`);
-        }
-    }
-    async undelegate(publicKey, validatorAddress, amount, memo) {
-        return this.delegate(publicKey, validatorAddress, amount, true, memo);
-    }
-    async delegate(publicKey, validatorAddress, amount, undelegate = false, memo) {
-        const address = (await this.getAddressFromPublicKey(publicKey)).address;
-        const nodeInfo = await this.nodeClient.fetchNodeInfo();
-        const account = await this.nodeClient.fetchAccount(address);
-        const message = new CosmosDelegateMessage_1.CosmosDelegateMessage(address, Array.isArray(validatorAddress) ? validatorAddress[0] : validatorAddress, new CosmosCoin_1.CosmosCoin('uatom', amount), undelegate);
-        return new CosmosTransaction_1.CosmosTransaction([message], new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin('uatom', new bignumber_1.default(this.feeDefaults.low).shiftedBy(this.feeDecimals).toString(10))], this.defaultGas.toString(10)), memo !== undefined ? memo : '', nodeInfo.network, account.value.account_number, account.value.sequence ?? '0');
-    }
-    async withdrawDelegationRewards(publicKey, _validatorAddresses = [], memo) {
-        let validatorAddresses;
-        if (_validatorAddresses.length > 0) {
-            validatorAddresses = _validatorAddresses;
-        }
-        else {
-            const address = (await this.getAddressFromPublicKey(publicKey)).address;
-            const rewards = await this.nodeClient.fetchRewardDetails(address);
-            const filteredRewards = rewards.filter((reward) => reward.reward
-                ? reward.reward
-                    .reduce((total, next) => total.plus(new bignumber_1.default(next.amount)), new bignumber_1.default(0))
-                    .decimalPlaces(0, bignumber_1.default.ROUND_FLOOR)
-                    .gt(0)
-                : false);
-            validatorAddresses = filteredRewards.map((reward) => reward.validator_address);
-        }
-        const address = (await this.getAddressFromPublicKey(publicKey)).address;
-        const nodeInfo = await this.nodeClient.fetchNodeInfo();
-        const account = await this.nodeClient.fetchAccount(address);
-        const messages = validatorAddresses.map((validatorAddress) => new CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage(address, validatorAddress));
-        return new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin('uatom', new bignumber_1.default(this.feeDefaults.low).shiftedBy(this.feeDecimals).toString(10))], this.defaultGas.toString(10)), memo !== undefined ? memo : '', nodeInfo.network, account.value.account_number, account.value.sequence ?? '0');
-    }
-    async withdrawAllDelegationRewards(delegatorAddress, fee, memo) {
-        const nodeInfo = await this.nodeClient.fetchNodeInfo();
-        const account = await this.nodeClient.fetchAccount(delegatorAddress);
-        return this.nodeClient.withdrawAllDelegationRewards(delegatorAddress, nodeInfo.network, account.value.account_number, account.value.sequence ?? '0', this.defaultGas, fee, memo !== undefined ? memo : '');
-    }
-    async fetchTotalReward(delegatorAddress) {
-        return this.nodeClient.fetchTotalReward(delegatorAddress);
-    }
-    async fetchRewardForDelegation(delegatorAddress, validatorAddress) {
-        return this.nodeClient.fetchRewardForDelegation(delegatorAddress, validatorAddress);
-    }
-    async fetchDelegations(address) {
-        return this.nodeClient.fetchDelegations(address);
-    }
-    async fetchTotalDelegatedAmount(address) {
-        return this.nodeClient.fetchTotalDelegatedAmount(address);
-    }
-    async fetchValidator(address) {
-        return this.nodeClient.fetchValidator(address);
-    }
-    async fetchUnbondingDelegations(delegatorAddress) {
-        return this.nodeClient.fetchUnbondingDelegations(delegatorAddress);
-    }
-    async fetchTotalUnbondingAmount(address) {
-        return this.nodeClient.fetchTotalUnbondingAmount(address);
-    }
-    async fetchValidators() {
-        return this.nodeClient.fetchValidators();
-    }
-    async fetchSelfDelegation(address) {
-        return this.nodeClient.fetchSelfDelegation(address);
-    }
-    async broadcastTransaction(rawTransaction) {
-        return this.nodeClient.broadcastSignedTransaction(rawTransaction);
-    }
-    async getDelegatorDetails(address, validator) {
-        const results = await Promise.all([
-            this.getBalanceOfAddresses([address]),
-            this.getAvailableBalanceOfAddresses([address]),
-            this.nodeClient.fetchDelegations(address).catch(() => []),
-            this.nodeClient.fetchRewardDetails(address).catch(() => [])
-        ]);
-        const totalBalance = results[0];
-        const availableBalance = new bignumber_1.default(results[1]);
-        const delegations = results[2];
-        const rewardDetails = results[3];
-        const unclaimedRewards = rewardDetails.map((details) => [
-            details.validator_address,
-            details.reward?.reduce((total, next) => total.plus(next.amount), new bignumber_1.default(0)).decimalPlaces(0, bignumber_1.default.ROUND_FLOOR) ??
-                new bignumber_1.default(0)
-        ]);
-        const unclaimedTotalRewards = unclaimedRewards.reduce((total, next) => total.plus(next[1]), new bignumber_1.default(0));
-        const unclaimedValidatorRewards = validator
-            ? unclaimedRewards.find(([validatorAddress, _]) => validatorAddress === validator)?.[1] || new bignumber_1.default(0)
-            : undefined;
-        const isDelegating = validator
-            ? delegations.some((delegation) => delegation.delegation.validator_address === validator)
-            : delegations.length > 0;
-        const availableActions = this.getAvailableDelegatorActions(isDelegating, availableBalance, unclaimedTotalRewards, unclaimedValidatorRewards);
-        return {
-            address,
-            balance: totalBalance,
-            delegatees: delegations.map((delegation) => delegation.delegation.validator_address),
-            availableActions
-        };
-    }
-    getAvailableDelegatorActions(isDelegating, availableBalance, unclaimedTotalRewards, unclaimedDelegationRewards) {
-        const actions = [];
-        const requiredFee = new bignumber_1.default(this.feeDefaults.low).shiftedBy(this.feeDecimals);
-        const hasSufficientBalance = availableBalance.gt(requiredFee);
+        });
+    };
+    CosmosProtocol.prototype.getTransactionDetailsFromSigned = function (transaction) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var bytes, decoded, fee, result;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        bytes = Uint8Array.from(Buffer.from(transaction.transaction, 'base64'));
+                        return [4 /*yield*/, (0, cosmjs_1.decodeTxBytes)(bytes)];
+                    case 1:
+                        decoded = _b.sent();
+                        fee = ((_a = decoded.fee) === null || _a === void 0 ? void 0 : _a.amount)
+                            .map(function (_a) {
+                            var amount = _a.amount;
+                            return new bignumber_1.default(amount);
+                        })
+                            .reduce(function (current, next) { return current.plus(next); })
+                            .toString(10);
+                        result = decoded.messages
+                            .map(function (message) {
+                            var type = message.typeUrl;
+                            switch (type) {
+                                case CosmosMessage_1.CosmosMessageType.Send.value:
+                                    var sendMessage = CosmosSendMessage_1.CosmosSendMessage.fromEncodeObject(message);
+                                    return sendMessage.toAirGapTransaction(_this.identifier, _this.options.network, fee);
+                                case CosmosMessage_1.CosmosMessageType.Undelegate.value:
+                                case CosmosMessage_1.CosmosMessageType.Delegate.value:
+                                    var delegateMessage = CosmosDelegateMessage_1.CosmosDelegateMessage.fromEncodeObject(message);
+                                    return delegateMessage.toAirGapTransaction(_this.identifier, _this.options.network, fee);
+                                case CosmosMessage_1.CosmosMessageType.WithdrawDelegationReward.value:
+                                    var withdrawMessage = CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage.fromEncodeObject(message);
+                                    return withdrawMessage.toAirGapTransaction(_this.identifier, _this.options.network, fee);
+                                default:
+                                    throw new errors_1.InvalidValueError(coinlib_error_1.Domain.COSMOS, 'Unknown transaction');
+                            }
+                        })
+                            .map(function (tx) {
+                            if (!tx.transactionDetails) {
+                                tx.transactionDetails = {};
+                            }
+                            tx.transactionDetails.memo = decoded.memo;
+                            if (decoded.signerInfos.length > 0) {
+                                tx.transactionDetails.sequence = decoded.signerInfos[0].sequence.toString(10);
+                            }
+                            return tx;
+                        });
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getBalance(addresses)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getBalanceOfPublicKey = 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.getBalanceOfAddresses([address.address])];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAvailableBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getBalance(addresses, false)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getBalanceOfPublicKeyForSubProtocols = function (publicKey, subProtocols) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw Promise.reject('get balance of sub protocols not supported');
+            });
+        });
+    };
+    CosmosProtocol.prototype.getBalance = function (addresses, totalBalance) {
+        if (totalBalance === void 0) { totalBalance = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var promises, _i, addresses_1, address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        promises = [];
+                        for (_i = 0, addresses_1 = addresses; _i < addresses_1.length; _i++) {
+                            address = addresses_1[_i];
+                            promises.push(this.nodeClient.fetchBalance(address, totalBalance));
+                        }
+                        return [4 /*yield*/, Promise.all(promises).then(function (balances) {
+                                return balances.reduce(function (current, next) {
+                                    return current.plus(next);
+                                });
+                            })];
+                    case 1: return [2 /*return*/, (_a.sent()).toString(10)];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.estimateMaxTransactionValueFromPublicKey = function (publicKey, recipients, fee) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, balance, balanceWrapper, maxFee, estimatedFeeDefaults, amountWithoutFees;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = (_a.sent()).address;
+                        return [4 /*yield*/, this.getAvailableBalanceOfAddresses([address])];
+                    case 2:
+                        balance = _a.sent();
+                        balanceWrapper = new bignumber_1.default(balance);
+                        if (!(fee !== undefined)) return [3 /*break*/, 3];
+                        maxFee = new bignumber_1.default(fee);
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, [balance])];
+                    case 4:
+                        estimatedFeeDefaults = _a.sent();
+                        maxFee = new bignumber_1.default(estimatedFeeDefaults.medium).shiftedBy(this.decimals);
+                        if (maxFee.gte(balanceWrapper)) {
+                            maxFee = new bignumber_1.default(0);
+                        }
+                        _a.label = 5;
+                    case 5:
+                        amountWithoutFees = balanceWrapper.minus(maxFee);
+                        if (amountWithoutFees.isNegative()) {
+                            amountWithoutFees = new bignumber_1.default(0);
+                        }
+                        return [2 /*return*/, amountWithoutFees.toFixed()];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.estimateFeeDefaultsFromPublicKey = function (publicKey, recipients, values, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDefaults];
+            });
+        });
+    };
+    CosmosProtocol.prototype.prepareTransactionFromPublicKey = function (publicKey, recipients, values, fee, data) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var wrappedValues, wrappedFee, address, nodeInfo, account, balance, _c, messages, i, message, memo, transaction;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        wrappedValues = values.map(function (value) { return new bignumber_1.default(value); });
+                        wrappedFee = new bignumber_1.default(fee);
+                        if (recipients.length !== wrappedValues.length) {
+                            return [2 /*return*/, Promise.reject('recipients length does not match with values')];
+                        }
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = (_d.sent()).address;
+                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
+                    case 2:
+                        nodeInfo = _d.sent();
+                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
+                    case 3:
+                        account = _d.sent();
+                        _c = bignumber_1.default.bind;
+                        return [4 /*yield*/, this.getAvailableBalanceOfAddresses([address])];
+                    case 4:
+                        balance = new (_c.apply(bignumber_1.default, [void 0, _d.sent()]))();
+                        if (balance.lt(values.reduce(function (pv, cv) { return pv.plus(cv); }, wrappedFee))) {
+                            throw new errors_1.BalanceError(coinlib_error_1.Domain.COSMOS, 'not enough balance');
+                        }
+                        messages = [];
+                        for (i = 0; i < recipients.length; ++i) {
+                            message = new CosmosSendMessage_1.CosmosSendMessage(address, recipients[i], [
+                                new CosmosCoin_1.CosmosCoin('uatom', wrappedValues[i].toString(10))
+                            ]);
+                            messages.push(message);
+                        }
+                        memo = (_a = data === null || data === void 0 ? void 0 : data.memo) !== null && _a !== void 0 ? _a : '';
+                        transaction = new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin('uatom', wrappedFee.toString(10))], this.defaultGas.toString(10)), memo, nodeInfo.network, account.value.account_number, (_b = account.value.sequence) !== null && _b !== void 0 ? _b : '0');
+                        return [2 /*return*/, transaction];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDefaultDelegatee = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var validators;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.fetchValidators()];
+                    case 1:
+                        validators = _a.sent();
+                        return [2 /*return*/, validators.length > 0 ? validators[0].operator_address : ''];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getCurrentDelegateesForPublicKey = 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.getCurrentDelegateesForAddress(address.address)];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getCurrentDelegateesForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var delegations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.fetchDelegations(address)];
+                    case 1:
+                        delegations = _a.sent();
+                        return [2 /*return*/, delegations.map(function (delegation) { return delegation.delegation.validator_address; })];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDelegateeDetails = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validator, statusCodes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.fetchValidator(address)];
+                    case 1:
+                        validator = _a.sent();
+                        statusCodes = { 0: 'jailed', 1: 'inactive', 2: 'active' };
+                        return [2 /*return*/, {
+                                name: validator.description.moniker,
+                                status: statusCodes[validator.status],
+                                address: validator.operator_address
+                            }];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.isPublicKeyDelegating = 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.isAddressDelegating(address.address)];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.isAddressDelegating = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var delegations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.fetchDelegations(address)];
+                    case 1:
+                        delegations = _a.sent();
+                        return [2 /*return*/, delegations.length > 0];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDelegatorDetailsFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getDelegatorDetailsFromAddress(address.address)];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDelegatorDetailsFromAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDelegatorDetails(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDelegationDetailsFromPublicKey = function (publicKey, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getDelegationDetailsFromAddress(address.address, delegatees)];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDelegationDetailsFromAddress = function (address, delegatees) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validator, results, delegatorDetails, validatorDetails;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (delegatees.length > 1) {
+                            return [2 /*return*/, Promise.reject('Multiple validators for a single delegation are not supported.')];
+                        }
+                        validator = delegatees[0];
+                        return [4 /*yield*/, Promise.all([this.getDelegatorDetails(address, validator), this.getDelegateeDetails(validator)])];
+                    case 1:
+                        results = _a.sent();
+                        delegatorDetails = results[0];
+                        validatorDetails = results[1];
+                        return [2 /*return*/, {
+                                delegator: delegatorDetails,
+                                delegatees: [validatorDetails]
+                            }];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.prepareDelegatorActionFromPublicKey = function (publicKey, type, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = type;
+                        switch (_a) {
+                            case CosmosDelegationActionType.DELEGATE: return [3 /*break*/, 1];
+                            case CosmosDelegationActionType.UNDELEGATE: return [3 /*break*/, 3];
+                            case CosmosDelegationActionType.WITHDRAW_ALL_REWARDS: return [3 /*break*/, 5];
+                            case CosmosDelegationActionType.WITHDRAW_VALIDATOR_REWARDS: return [3 /*break*/, 7];
+                        }
+                        return [3 /*break*/, 9];
+                    case 1:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'validator', 'amount');
+                        return [4 /*yield*/, this.delegate(publicKey, data.validator, data.amount)];
+                    case 2: return [2 /*return*/, [_b.sent()]];
+                    case 3:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'validator', 'amount');
+                        return [4 /*yield*/, this.undelegate(publicKey, data.validator, data.amount)];
+                    case 4: return [2 /*return*/, [_b.sent()]];
+                    case 5: return [4 /*yield*/, this.withdrawDelegationRewards(publicKey)];
+                    case 6: return [2 /*return*/, [_b.sent()]];
+                    case 7:
+                        (0, assert_1.assertFields)("".concat(type, " action"), data, 'validator');
+                        return [4 /*yield*/, this.withdrawDelegationRewards(publicKey, [data.validator])];
+                    case 8: return [2 /*return*/, [_b.sent()]];
+                    case 9: return [2 /*return*/, Promise.reject("Delegator action type ".concat(type, " is not supported."))];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.undelegate = function (publicKey, validatorAddress, amount, memo) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.delegate(publicKey, validatorAddress, amount, true, memo)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.delegate = function (publicKey, validatorAddress, amount, undelegate, memo) {
+        var _a;
+        if (undelegate === void 0) { undelegate = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var address, nodeInfo, account, message;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = (_b.sent()).address;
+                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
+                    case 2:
+                        nodeInfo = _b.sent();
+                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
+                    case 3:
+                        account = _b.sent();
+                        message = new CosmosDelegateMessage_1.CosmosDelegateMessage(address, Array.isArray(validatorAddress) ? validatorAddress[0] : validatorAddress, new CosmosCoin_1.CosmosCoin('uatom', amount), undelegate);
+                        return [2 /*return*/, new CosmosTransaction_1.CosmosTransaction([message], new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin('uatom', new bignumber_1.default(this.feeDefaults.low).shiftedBy(this.feeDecimals).toString(10))], this.defaultGas.toString(10)), memo !== undefined ? memo : '', nodeInfo.network, account.value.account_number, (_a = account.value.sequence) !== null && _a !== void 0 ? _a : '0')];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.withdrawDelegationRewards = function (publicKey, _validatorAddresses, memo) {
+        var _a;
+        if (_validatorAddresses === void 0) { _validatorAddresses = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var validatorAddresses, address_1, rewards, filteredRewards, address, nodeInfo, account, messages;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(_validatorAddresses.length > 0)) return [3 /*break*/, 1];
+                        validatorAddresses = _validatorAddresses;
+                        return [3 /*break*/, 4];
+                    case 1: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 2:
+                        address_1 = (_b.sent()).address;
+                        return [4 /*yield*/, this.nodeClient.fetchRewardDetails(address_1)];
+                    case 3:
+                        rewards = _b.sent();
+                        filteredRewards = rewards.filter(function (reward) {
+                            return reward.reward
+                                ? reward.reward
+                                    .reduce(function (total, next) { return total.plus(new bignumber_1.default(next.amount)); }, new bignumber_1.default(0))
+                                    .decimalPlaces(0, bignumber_1.default.ROUND_FLOOR)
+                                    .gt(0)
+                                : false;
+                        });
+                        validatorAddresses = filteredRewards.map(function (reward) { return reward.validator_address; });
+                        _b.label = 4;
+                    case 4: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 5:
+                        address = (_b.sent()).address;
+                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
+                    case 6:
+                        nodeInfo = _b.sent();
+                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
+                    case 7:
+                        account = _b.sent();
+                        messages = validatorAddresses.map(function (validatorAddress) { return new CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage(address, validatorAddress); });
+                        return [2 /*return*/, new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin('uatom', new bignumber_1.default(this.feeDefaults.low).shiftedBy(this.feeDecimals).toString(10))], this.defaultGas.toString(10)), memo !== undefined ? memo : '', nodeInfo.network, account.value.account_number, (_a = account.value.sequence) !== null && _a !== void 0 ? _a : '0')];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.withdrawAllDelegationRewards = function (delegatorAddress, fee, memo) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var nodeInfo, account;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
+                    case 1:
+                        nodeInfo = _b.sent();
+                        return [4 /*yield*/, this.nodeClient.fetchAccount(delegatorAddress)];
+                    case 2:
+                        account = _b.sent();
+                        return [2 /*return*/, this.nodeClient.withdrawAllDelegationRewards(delegatorAddress, nodeInfo.network, account.value.account_number, (_a = account.value.sequence) !== null && _a !== void 0 ? _a : '0', this.defaultGas, fee, memo !== undefined ? memo : '')];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchTotalReward = function (delegatorAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchTotalReward(delegatorAddress)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchRewardForDelegation = function (delegatorAddress, validatorAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchRewardForDelegation(delegatorAddress, validatorAddress)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchDelegations = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchDelegations(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchTotalDelegatedAmount = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchTotalDelegatedAmount(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchValidator = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchValidator(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchUnbondingDelegations = function (delegatorAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchUnbondingDelegations(delegatorAddress)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchTotalUnbondingAmount = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchTotalUnbondingAmount(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchValidators = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchValidators()];
+            });
+        });
+    };
+    CosmosProtocol.prototype.fetchSelfDelegation = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.fetchSelfDelegation(address)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.broadcastTransaction = function (rawTransaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.broadcastSignedTransaction(rawTransaction)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getDelegatorDetails = function (address, validator) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var results, totalBalance, availableBalance, delegations, rewardDetails, unclaimedRewards, unclaimedTotalRewards, unclaimedValidatorRewards, isDelegating, availableActions;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            this.getBalanceOfAddresses([address]),
+                            this.getAvailableBalanceOfAddresses([address]),
+                            this.nodeClient.fetchDelegations(address).catch(function () { return []; }),
+                            this.nodeClient.fetchRewardDetails(address).catch(function () { return []; })
+                        ])];
+                    case 1:
+                        results = _b.sent();
+                        totalBalance = results[0];
+                        availableBalance = new bignumber_1.default(results[1]);
+                        delegations = results[2];
+                        rewardDetails = results[3];
+                        unclaimedRewards = rewardDetails.map(function (details) {
+                            var _a, _b;
+                            return [
+                                details.validator_address,
+                                (_b = (_a = details.reward) === null || _a === void 0 ? void 0 : _a.reduce(function (total, next) { return total.plus(next.amount); }, new bignumber_1.default(0)).decimalPlaces(0, bignumber_1.default.ROUND_FLOOR)) !== null && _b !== void 0 ? _b : new bignumber_1.default(0)
+                            ];
+                        });
+                        unclaimedTotalRewards = unclaimedRewards.reduce(function (total, next) { return total.plus(next[1]); }, new bignumber_1.default(0));
+                        unclaimedValidatorRewards = validator
+                            ? ((_a = unclaimedRewards.find(function (_a) {
+                                var validatorAddress = _a[0], _ = _a[1];
+                                return validatorAddress === validator;
+                            })) === null || _a === void 0 ? void 0 : _a[1]) || new bignumber_1.default(0)
+                            : undefined;
+                        isDelegating = validator
+                            ? delegations.some(function (delegation) { return delegation.delegation.validator_address === validator; })
+                            : delegations.length > 0;
+                        availableActions = this.getAvailableDelegatorActions(isDelegating, availableBalance, unclaimedTotalRewards, unclaimedValidatorRewards);
+                        return [2 /*return*/, {
+                                address: address,
+                                balance: totalBalance,
+                                delegatees: delegations.map(function (delegation) { return delegation.delegation.validator_address; }),
+                                availableActions: availableActions
+                            }];
+                }
+            });
+        });
+    };
+    CosmosProtocol.prototype.getAvailableDelegatorActions = function (isDelegating, availableBalance, unclaimedTotalRewards, unclaimedDelegationRewards) {
+        var actions = [];
+        var requiredFee = new bignumber_1.default(this.feeDefaults.low).shiftedBy(this.feeDecimals);
+        var hasSufficientBalance = availableBalance.gt(requiredFee);
         if (hasSufficientBalance) {
             actions.push({
                 type: CosmosDelegationActionType.DELEGATE,
@@ -611,35 +1099,64 @@ class CosmosProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
                 type: CosmosDelegationActionType.WITHDRAW_ALL_REWARDS
             });
         }
-        if (unclaimedDelegationRewards?.gt(0)) {
+        if (unclaimedDelegationRewards === null || unclaimedDelegationRewards === void 0 ? void 0 : unclaimedDelegationRewards.gt(0)) {
             actions.push({
                 type: CosmosDelegationActionType.WITHDRAW_VALIDATOR_REWARDS,
                 args: ['validator']
             });
         }
         return actions;
-    }
-    async signMessage(message, keypair) {
-        return this.cryptoClient.signMessage(message, keypair);
-    }
-    async verifyMessage(message, signature, publicKey) {
-        return this.cryptoClient.verifyMessage(message, signature, publicKey);
-    }
-    async encryptAsymmetric(message, publicKey) {
-        return this.cryptoClient.encryptAsymmetric(message, publicKey);
-    }
-    async decryptAsymmetric(message, keypair) {
-        return this.cryptoClient.decryptAsymmetric(message, keypair);
-    }
-    async encryptAES(message, privateKey) {
-        return this.cryptoClient.encryptAES(message, privateKey);
-    }
-    async decryptAES(message, privateKey) {
-        return this.cryptoClient.decryptAES(message, privateKey);
-    }
-    async getTransactionStatuses(transactionHashes) {
-        return Promise.reject('Transaction status not implemented');
-    }
-}
+    };
+    CosmosProtocol.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.signMessage(message, keypair)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, signature, publicKey)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.encryptAsymmetric = function (message, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(message, publicKey)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.decryptAsymmetric = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(message, keypair)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.encryptAES = function (message, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.encryptAES(message, privateKey)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.decryptAES = function (message, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.decryptAES(message, privateKey)];
+            });
+        });
+    };
+    CosmosProtocol.prototype.getTransactionStatuses = function (transactionHashes) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.reject('Transaction status not implemented')];
+            });
+        });
+    };
+    return CosmosProtocol;
+}(NonExtendedProtocol_1.NonExtendedProtocol));
 exports.CosmosProtocol = CosmosProtocol;
 //# sourceMappingURL=CosmosProtocol.js.map