@airgap/cosmos-core 0.13.45-beta.2 → 0.13.45-beta.3

package/v1/protocol/CosmosBaseProtocol.js

@@ -1,84 +1,37 @@
 "use strict";
-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.CosmosBaseProtocolImpl = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 // @ts-ignore
-var index_1 = require("@airgap/coinlib-core/dependencies/src/bip32-2.0.4/src/index");
-var cosmjs_1 = require("@airgap/coinlib-core/dependencies/src/cosmjs");
-var SECP256K1 = require("@airgap/coinlib-core/dependencies/src/secp256k1-3.7.1/elliptic");
+const index_1 = require("@airgap/coinlib-core/dependencies/src/bip32-2.0.4/src/index");
+const cosmjs_1 = require("@airgap/coinlib-core/dependencies/src/cosmjs");
+const SECP256K1 = require("@airgap/coinlib-core/dependencies/src/secp256k1-3.7.1/elliptic");
 // @ts-ignore
-var sha = require("@airgap/coinlib-core/dependencies/src/sha.js-2.4.11/index");
-var errors_1 = require("@airgap/coinlib-core/errors");
-var assert_1 = require("@airgap/coinlib-core/utils/assert");
-var crypto_1 = require("@airgap/crypto");
-var module_kit_1 = require("@airgap/module-kit");
-var CosmosNodeClient_1 = require("../node/CosmosNodeClient");
-var CosmosAddress_1 = require("../types/data/CosmosAddress");
-var CosmosCoin_1 = require("../types/data/CosmosCoin");
-var CosmosFee_1 = require("../types/data/CosmosFee");
-var CosmosTransaction_1 = require("../types/data/transaction/CosmosTransaction");
-var CosmosDelegateMessage_1 = require("../types/data/transaction/message/CosmosDelegateMessage");
-var CosmosMessage_1 = require("../types/data/transaction/message/CosmosMessage");
-var CosmosSendMessage_1 = require("../types/data/transaction/message/CosmosSendMessage");
-var CosmosWithdrawDelegationRewardMessage_1 = require("../types/data/transaction/message/CosmosWithdrawDelegationRewardMessage");
-var transaction_1 = require("../types/transaction");
-var key_1 = require("../utils/key");
-var signature_1 = require("../utils/signature");
-var transaction_2 = require("../utils/transaction");
-var CosmosCryptoClient_1 = require("./CosmosCryptoClient");
-var CosmosBaseProtocolImpl = /** @class */ (function () {
-    function CosmosBaseProtocolImpl(options) {
+const sha = require("@airgap/coinlib-core/dependencies/src/sha.js-2.4.11/index");
+const errors_1 = require("@airgap/coinlib-core/errors");
+const assert_1 = require("@airgap/coinlib-core/utils/assert");
+const crypto_1 = require("@airgap/crypto");
+const module_kit_1 = require("@airgap/module-kit");
+const CosmosNodeClient_1 = require("../node/CosmosNodeClient");
+const CosmosAddress_1 = require("../types/data/CosmosAddress");
+const CosmosCoin_1 = require("../types/data/CosmosCoin");
+const CosmosFee_1 = require("../types/data/CosmosFee");
+const CosmosTransaction_1 = require("../types/data/transaction/CosmosTransaction");
+const CosmosDelegateMessage_1 = require("../types/data/transaction/message/CosmosDelegateMessage");
+const CosmosMessage_1 = require("../types/data/transaction/message/CosmosMessage");
+const CosmosSendMessage_1 = require("../types/data/transaction/message/CosmosSendMessage");
+const CosmosWithdrawDelegationRewardMessage_1 = require("../types/data/transaction/message/CosmosWithdrawDelegationRewardMessage");
+const transaction_1 = require("../types/transaction");
+const key_1 = require("../utils/key");
+const signature_1 = require("../utils/signature");
+const transaction_2 = require("../utils/transaction");
+const CosmosCryptoClient_1 = require("./CosmosCryptoClient");
+class CosmosBaseProtocolImpl {
+    constructor(options) {
         this.cryptoConfiguration = {
             algorithm: 'secp256k1'
         };
@@ -86,939 +39,550 @@ var CosmosBaseProtocolImpl = /** @class */ (function () {
         this.nodeClient = new CosmosNodeClient_1.CosmosNodeClient(this.options.network.rpcUrl, this.options.network.useCORSProxy);
         this.cryptoClient = new CosmosCryptoClient_1.CosmosCryptoClient();
     }
-    CosmosBaseProtocolImpl.prototype.getKeyPairFromSecretKey = function (secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, publicKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                publicKey = SECP256K1.publicKeyCreate(Buffer.from(secretKey.value, 'hex'));
-                return [2 /*return*/, {
-                        secretKey: hexSecretKey,
-                        publicKey: (0, module_kit_1.newPublicKey)(Buffer.from(publicKey, 'binary').toString('hex'), 'hex')
-                    }];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoConfiguration];
-            });
+    async getKeyPairFromSecretKey(secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        const publicKey = SECP256K1.publicKeyCreate(Buffer.from(secretKey.value, 'hex'));
+        return {
+            secretKey: hexSecretKey,
+            publicKey: (0, module_kit_1.newPublicKey)(Buffer.from(publicKey, 'binary').toString('hex'), 'hex')
+        };
+    }
+    async getCryptoConfiguration() {
+        return this.cryptoConfiguration;
+    }
+    async getKeyPairFromDerivative(derivative) {
+        const bip32Node = (0, crypto_1.encodeDerivative)('bip32', derivative);
+        const bip32 = (0, index_1.fromBase58)(bip32Node.secretKey);
+        const secretKey = bip32.privateKey;
+        if (secretKey === undefined) {
+            throw new errors_1.InvalidValueError(coinlib_core_1.Domain.COSMOS, 'Cannot generate secret key');
+        }
+        const publicKey = bip32.publicKey;
+        return {
+            secretKey: (0, module_kit_1.newSecretKey)(secretKey.toString('hex'), 'hex'),
+            publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
+        };
+    }
+    async signTransactionWithSecretKey(transaction, secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        const privateKeyBuffer = Buffer.from(hexSecretKey.value, 'hex');
+        const { publicKey } = await this.getKeyPairFromSecretKey(secretKey);
+        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+        const publicKeyBuffer = Buffer.from(hexPublicKey.value, 'hex');
+        const encodedObject = CosmosTransaction_1.CosmosTransaction.fromJSON(transaction).toEncodeObject();
+        const signBytes = await (0, cosmjs_1.prepareSignBytes)(encodedObject, transaction.fee, Uint8Array.from(publicKeyBuffer), 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(publicKeyBuffer), new bignumber_1.default(transaction.sequence).toNumber(), {
+            signature: sigBase64,
+            pub_key: {
+                type: 'tendermint/PubKeySecp256k1',
+                value: publicKeyBuffer.toString('base64')
+            }
+        }, transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber());
+        return (0, module_kit_1.newSignedTransaction)({
+            encoded: Buffer.from(txBytes).toString('base64')
         });
-    };
-    CosmosBaseProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bip32Node, bip32, secretKey, publicKey;
-            return __generator(this, function (_a) {
-                bip32Node = (0, crypto_1.encodeDerivative)('bip32', derivative);
-                bip32 = (0, index_1.fromBase58)(bip32Node.secretKey);
-                secretKey = bip32.privateKey;
-                if (secretKey === undefined) {
-                    throw new errors_1.InvalidValueError(coinlib_core_1.Domain.COSMOS, 'Cannot generate secret key');
-                }
-                publicKey = bip32.publicKey;
-                return [2 /*return*/, {
-                        secretKey: (0, module_kit_1.newSecretKey)(secretKey.toString('hex'), 'hex'),
-                        publicKey: (0, module_kit_1.newPublicKey)(publicKey.toString('hex'), 'hex')
-                    }];
-            });
+    }
+    async getAddressFromPublicKey(publicKey) {
+        return CosmosAddress_1.CosmosAddress.from(publicKey, this.options.addressPrefix).asString();
+    }
+    async getDetailsFromTransaction(transaction, publicKey) {
+        switch (transaction.type) {
+            case 'signed':
+                return this.getDetailsFromSignedTransaction(transaction);
+            case 'unsigned':
+                return this.getDetailsFromUnsignedTransaction(transaction);
+            default:
+                (0, coinlib_core_1.assertNever)(transaction);
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.COSMOS, 'Unsupported transaction type.');
+        }
+    }
+    async getDetailsFromSignedTransaction(transaction) {
+        const bytes = Uint8Array.from(Buffer.from(transaction.encoded, '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.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.options.network, fee);
+                case CosmosMessage_1.CosmosMessageType.WithdrawDelegationReward.value:
+                    const withdrawMessage = CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage.fromEncodeObject(message);
+                    return withdrawMessage.toAirGapTransaction(this.options.network, fee);
+                default:
+                    throw new errors_1.InvalidValueError(coinlib_core_1.Domain.COSMOS, 'Unknown transaction');
+            }
+        })
+            .map((tx) => {
+            if (!tx.json) {
+                tx.json = {};
+            }
+            tx.json.memo = decoded.memo;
+            if (decoded.signerInfos.length > 0) {
+                tx.json.sequence = decoded.signerInfos[0].sequence.toString(10);
+            }
+            tx.arbitraryData = decoded.memo;
+            return tx;
         });
-    };
-    CosmosBaseProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, privateKeyBuffer, publicKey, hexPublicKey, publicKeyBuffer, encodedObject, signBytes, sha256Hash, hash, signed, sigBase64, txBytes;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                        privateKeyBuffer = Buffer.from(hexSecretKey.value, 'hex');
-                        return [4 /*yield*/, this.getKeyPairFromSecretKey(secretKey)];
-                    case 1:
-                        publicKey = (_a.sent()).publicKey;
-                        hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-                        publicKeyBuffer = Buffer.from(hexPublicKey.value, 'hex');
-                        encodedObject = CosmosTransaction_1.CosmosTransaction.fromJSON(transaction).toEncodeObject();
-                        return [4 /*yield*/, (0, cosmjs_1.prepareSignBytes)(encodedObject, transaction.fee, Uint8Array.from(publicKeyBuffer), new bignumber_1.default(transaction.sequence).toNumber(), transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber())];
-                    case 2:
-                        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(publicKeyBuffer), new bignumber_1.default(transaction.sequence).toNumber(), {
-                                signature: sigBase64,
-                                pub_key: {
-                                    type: 'tendermint/PubKeySecp256k1',
-                                    value: publicKeyBuffer.toString('base64')
-                                }
-                            }, transaction.chainID, new bignumber_1.default(transaction.accountNumber).toNumber())];
-                    case 3:
-                        txBytes = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({
-                                encoded: Buffer.from(txBytes).toString('base64')
-                            })];
-                }
-            });
+        return result;
+    }
+    async getDetailsFromUnsignedTransaction(transaction) {
+        return CosmosTransaction_1.CosmosTransaction.fromJSON(transaction).toAirGapTransactions(this.options.network);
+    }
+    async getNetwork() {
+        return this.options.network;
+    }
+    async getTransactionsForPublicKey(publicKey, limit, cursor) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getTransactionsForAddress(address, limit, cursor);
+    }
+    async getBalanceOfPublicKey(publicKey, configuration) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getBalanceOfAddress(address);
+    }
+    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
+        const units = (await this.getMetadata()).units;
+        const { total, transferable } = await this.getBalanceOfPublicKey(publicKey);
+        const balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable ?? total).blockchain(units).value);
+        let fee;
+        if (configuration?.fee !== undefined) {
+            fee = configuration.fee;
+        }
+        else {
+            const estimatedFee = await this.getTransactionFeeWithPublicKey(publicKey, to.map((recipient) => ({
+                to: recipient,
+                amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.default.ROUND_CEIL), 'blockchain')
+            })));
+            fee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(units);
+            if (balance.lte(fee.value)) {
+                fee = (0, module_kit_1.newAmount)(0, 'blockchain');
+            }
+        }
+        fee = (0, module_kit_1.newAmount)(fee).blockchain(units);
+        let amountWithoutFees = balance.minus(fee.value);
+        if (amountWithoutFees.isNegative()) {
+            amountWithoutFees = new bignumber_1.default(0);
+        }
+        return (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain');
+    }
+    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
+        let fee;
+        if (configuration?.fee !== undefined) {
+            fee = configuration.fee;
+        }
+        else {
+            const estimatedFee = await this.getTransactionFeeWithPublicKey(publicKey, details);
+            fee = estimatedFee.medium;
+        }
+        const units = (await this.getMetadata()).units;
+        const wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(units).value);
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const nodeInfo = await this.nodeClient.fetchNodeInfo();
+        const account = await this.nodeClient.fetchAccount(address);
+        const { total, transferable } = await this.getBalanceOfPublicKey(publicKey);
+        const balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable ?? total).blockchain(units).value);
+        if (balance.lt(details.reduce((acc, next) => acc.plus((0, module_kit_1.newAmount)(next.amount).blockchain(units).value), wrappedFee))) {
+            throw new coinlib_core_1.BalanceError(coinlib_core_1.Domain.COSMOS, 'not enough balance');
+        }
+        const messages = [];
+        for (let i = 0; i < details.length; ++i) {
+            const message = new CosmosSendMessage_1.CosmosSendMessage(address, details[i].to, [
+                new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(details[i].amount).blockchain(units).value)
+            ]);
+            messages.push(message);
+        }
+        const memo = configuration?.arbitraryData ?? '';
+        const transaction = new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, wrappedFee.toString(10))], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(units).value), memo, nodeInfo.network, account.account_number, account.sequence ?? '0');
+        return (0, module_kit_1.newUnsignedTransaction)({
+            messages: transaction.messages.map((message) => message.toJSON()),
+            fee: transaction.fee.toJSON(),
+            memo: transaction.memo,
+            chainID: transaction.chainID,
+            accountNumber: transaction.accountNumber,
+            sequence: transaction.sequence
         });
-    };
-    CosmosBaseProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, CosmosAddress_1.CosmosAddress.from(publicKey, this.options.addressPrefix).asString()];
-            });
+    }
+    async broadcastTransaction(transaction) {
+        return this.nodeClient.broadcastSignedTransaction(transaction.encoded);
+    }
+    async signMessageWithKeyPair(message, keyPair) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
+        const signature = await this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value });
+        return (0, module_kit_1.newSignature)(signature, 'hex');
+    }
+    async verifyMessageWithPublicKey(message, signature, publicKey) {
+        const hexSignature = (0, signature_1.convertSignature)(signature, 'hex');
+        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+        return this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value);
+    }
+    async decryptAsymmetricWithKeyPair(payload, keyPair) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
+        const hexPublicKey = (0, key_1.convertPublicKey)(keyPair.publicKey, 'hex');
+        return this.cryptoClient.decryptAsymmetric(payload, {
+            privateKey: hexSecretKey.value,
+            publicKey: hexPublicKey.value
         });
-    };
-    CosmosBaseProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (transaction.type) {
-                    case 'signed':
-                        return [2 /*return*/, this.getDetailsFromSignedTransaction(transaction)];
-                    case 'unsigned':
-                        return [2 /*return*/, this.getDetailsFromUnsignedTransaction(transaction)];
+    }
+    async encryptAsymmetricWithPublicKey(payload, publicKey) {
+        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+        return this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value);
+    }
+    async encryptAESWithSecretKey(payload, secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        return this.cryptoClient.encryptAES(payload, hexSecretKey.value);
+    }
+    async decryptAESWithSecretKey(payload, secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        return this.cryptoClient.decryptAES(payload, hexSecretKey.value);
+    }
+    async getTransactionsForAddress(address, limit, cursor) {
+        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, transaction_2.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: null, total: String(senderTotal) });
+                }));
+            }
+            recipientLimit = (0, transaction_2.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: null, total: String(senderTotal) });
+                }));
+            }
+        }
+        else {
+            ;
+            [senderTotal, recipientTotal] = await Promise.all([
+                this.nodeClient.fetchSendTransactionsFor(address, 1, 0, true).then((response) => new bignumber_1.default(response.total).toNumber()),
+                this.nodeClient.fetchSendTransactionsFor(address, 1, 0, false).then((response) => new bignumber_1.default(response.total).toNumber())
+            ]);
+            senderLimit = (0, transaction_2.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
+            recipientLimit = (0, transaction_2.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.reduce((current, next) => (next.denom === this.options.baseUnit ? current.plus(new bignumber_1.default(next.amount)) : current), new bignumber_1.default(0));
+            result = result.concat(transaction.tx.body.messages
+                .filter((msg) => msg['@type'] !== CosmosMessage_1.CosmosMessageTypeValue.MSGMULTISEND)
+                .map((msg) => {
+                const tx = {
+                    isInbound: false,
+                    amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
+                    fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
+                    network: this.options.network,
+                    status: {
+                        type: 'unknown',
+                        hash: transaction.txhash
+                    },
+                    timestamp
+                };
+                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:
-                        (0, coinlib_core_1.assertNever)(transaction);
-                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.COSMOS, 'Unsupported transaction type.');
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getDetailsFromSignedTransaction = 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.encoded, '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.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.options.network, fee);
-                                case CosmosMessage_1.CosmosMessageType.WithdrawDelegationReward.value:
-                                    var withdrawMessage = CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage.fromEncodeObject(message);
-                                    return withdrawMessage.toAirGapTransaction(_this.options.network, fee);
-                                default:
-                                    throw new errors_1.InvalidValueError(coinlib_core_1.Domain.COSMOS, 'Unknown transaction');
-                            }
-                        })
-                            .map(function (tx) {
-                            if (!tx.json) {
-                                tx.json = {};
-                            }
-                            tx.json.memo = decoded.memo;
-                            if (decoded.signerInfos.length > 0) {
-                                tx.json.sequence = decoded.signerInfos[0].sequence.toString(10);
-                            }
-                            tx.arbitraryData = decoded.memo;
-                            return tx;
-                        });
-                        return [2 /*return*/, result];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getDetailsFromUnsignedTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, CosmosTransaction_1.CosmosTransaction.fromJSON(transaction).toAirGapTransactions(this.options.network)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getTransactionsForPublicKey = 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.getTransactionsForAddress(address, limit, cursor)];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey, configuration) {
-        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.getBalanceOfAddress(address)];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var units, _a, total, transferable, balance, fee, estimatedFee, amountWithoutFees;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getMetadata()];
-                    case 1:
-                        units = (_b.sent()).units;
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 2:
-                        _a = _b.sent(), total = _a.total, transferable = _a.transferable;
-                        balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(units).value);
-                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 3];
-                        fee = configuration.fee;
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, to.map(function (recipient) { return ({
-                            to: recipient,
-                            amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.default.ROUND_CEIL), 'blockchain')
-                        }); }))];
-                    case 4:
-                        estimatedFee = _b.sent();
-                        fee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(units);
-                        if (balance.lte(fee.value)) {
-                            fee = (0, module_kit_1.newAmount)(0, 'blockchain');
-                        }
-                        _b.label = 5;
-                    case 5:
-                        fee = (0, module_kit_1.newAmount)(fee).blockchain(units);
-                        amountWithoutFees = balance.minus(fee.value);
-                        if (amountWithoutFees.isNegative()) {
-                            amountWithoutFees = new bignumber_1.default(0);
-                        }
-                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain')];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var fee, estimatedFee, units, wrappedFee, address, nodeInfo, account, _c, total, transferable, balance, messages, i, message, memo, transaction;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 1];
-                        fee = configuration.fee;
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, details)];
-                    case 2:
-                        estimatedFee = _d.sent();
-                        fee = estimatedFee.medium;
-                        _d.label = 3;
-                    case 3: return [4 /*yield*/, this.getMetadata()];
-                    case 4:
-                        units = (_d.sent()).units;
-                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(units).value);
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 5:
-                        address = _d.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
-                    case 6:
-                        nodeInfo = _d.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
-                    case 7:
-                        account = _d.sent();
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 8:
-                        _c = _d.sent(), total = _c.total, transferable = _c.transferable;
-                        balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(units).value);
-                        if (balance.lt(details.reduce(function (acc, next) { return acc.plus((0, module_kit_1.newAmount)(next.amount).blockchain(units).value); }, wrappedFee))) {
-                            throw new coinlib_core_1.BalanceError(coinlib_core_1.Domain.COSMOS, 'not enough balance');
-                        }
-                        messages = [];
-                        for (i = 0; i < details.length; ++i) {
-                            message = new CosmosSendMessage_1.CosmosSendMessage(address, details[i].to, [
-                                new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(details[i].amount).blockchain(units).value)
-                            ]);
-                            messages.push(message);
-                        }
-                        memo = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.arbitraryData) !== null && _a !== void 0 ? _a : '';
-                        transaction = new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, wrappedFee.toString(10))], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(units).value), memo, nodeInfo.network, account.account_number, (_b = account.sequence) !== null && _b !== void 0 ? _b : '0');
-                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
-                                messages: transaction.messages.map(function (message) { return message.toJSON(); }),
-                                fee: transaction.fee.toJSON(),
-                                memo: transaction.memo,
-                                chainID: transaction.chainID,
-                                accountNumber: transaction.accountNumber,
-                                sequence: transaction.sequence
-                            })];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.broadcastTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.broadcastSignedTransaction(transaction.encoded)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, signature;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
-                        return [4 /*yield*/, this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value })];
-                    case 1:
-                        signature = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newSignature)(signature, 'hex')];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSignature, hexPublicKey;
-            return __generator(this, function (_a) {
-                hexSignature = (0, signature_1.convertSignature)(signature, 'hex');
-                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, hexPublicKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
-                hexPublicKey = (0, key_1.convertPublicKey)(keyPair.publicKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(payload, {
-                        privateKey: hexSecretKey.value,
-                        publicKey: hexPublicKey.value
-                    })];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexPublicKey;
-            return __generator(this, function (_a) {
-                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.encryptAES(payload, hexSecretKey.value)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.decryptAES(payload, hexSecretKey.value)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var promises, senderOffset, recipientOffset, senderTotal, recipientTotal, senderLimit, recipientLimit, transactions, sentTransactions, receivedTransactions, allTransactions, result, _loop_1, _i, allTransactions_1, transaction;
-            var _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 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, transaction_2.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: null, total: String(senderTotal) });
-                            }));
-                        }
-                        recipientLimit = (0, transaction_2.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: null, total: String(senderTotal) });
-                            }));
-                        }
-                        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.total).toNumber(); }),
-                                this.nodeClient.fetchSendTransactionsFor(address, 1, 0, false).then(function (response) { return new bignumber_1.default(response.total).toNumber(); })
-                            ])];
-                    case 2:
-                        _a = _b.sent(), senderTotal = _a[0], recipientTotal = _a[1];
-                        senderLimit = (0, transaction_2.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
-                        recipientLimit = (0, transaction_2.calculateTransactionLimit)(limit, recipientTotal, senderTotal, recipientOffset, senderOffset);
-                        promises.push(this.nodeClient.fetchSendTransactionsFor(address, senderLimit, senderOffset, true), this.nodeClient.fetchSendTransactionsFor(address, recipientLimit, recipientOffset, false));
-                        _b.label = 3;
-                    case 3: return [4 /*yield*/, Promise.all(promises)];
-                    case 4:
-                        transactions = _b.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.reduce(function (current, next) { return (next.denom === _this.options.baseUnit ? current.plus(new bignumber_1.default(next.amount)) : current); }, new bignumber_1.default(0));
-                            result = result.concat(transaction.tx.body.messages
-                                .filter(function (msg) { return msg['@type'] !== CosmosMessage_1.CosmosMessageTypeValue.MSGMULTISEND; })
-                                .map(function (msg) {
-                                var tx = {
-                                    isInbound: false,
-                                    amount: (0, module_kit_1.newAmount)('0', 'blockchain'),
-                                    fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
-                                    network: _this.options.network,
-                                    status: {
-                                        type: 'unknown',
-                                        hash: transaction.txhash
-                                    },
-                                    timestamp: timestamp
-                                };
-                                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: (0, module_kit_1.newAmount)(msg.amount[0].amount, 'blockchain') });
-                                }
-                            }));
+                        return {
+                            ...tx,
+                            from: [msg.from_address],
+                            to: [msg.to_address],
+                            isInbound: msg.to_address === address,
+                            amount: (0, module_kit_1.newAmount)(msg.amount[0].amount, 'blockchain')
                         };
-                        for (_i = 0, allTransactions_1 = allTransactions; _i < allTransactions_1.length; _i++) {
-                            transaction = allTransactions_1[_i];
-                            _loop_1(transaction);
-                        }
-                        return [2 /*return*/, {
-                                transactions: result,
-                                cursor: {
-                                    hasNext: senderOffset + senderLimit < senderTotal || recipientOffset + recipientLimit < recipientTotal,
-                                    limit: limit,
-                                    sender: {
-                                        total: senderTotal,
-                                        offset: senderOffset + senderLimit
-                                    },
-                                    recipient: {
-                                        total: recipientTotal,
-                                        offset: recipientOffset + recipientLimit
-                                    }
-                                }
-                            }];
                 }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getBalanceOfAddress = function (address, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var metadata, _a, total, available;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getMetadata()];
-                    case 1:
-                        metadata = _b.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchBalance(address, this.options.baseUnit)];
-                    case 2:
-                        _a = _b.sent(), total = _a.total, available = _a.available;
-                        return [2 /*return*/, {
-                                total: (0, module_kit_1.newAmount)(total).blockchain(metadata.units),
-                                transferable: (0, module_kit_1.newAmount)(available).blockchain(metadata.units)
-                            }];
+            }));
+        }
+        return {
+            transactions: result,
+            cursor: {
+                hasNext: senderOffset + senderLimit < senderTotal || recipientOffset + recipientLimit < recipientTotal,
+                limit,
+                sender: {
+                    total: senderTotal,
+                    offset: senderOffset + senderLimit
+                },
+                recipient: {
+                    total: recipientTotal,
+                    offset: recipientOffset + recipientLimit
                 }
-            });
-        });
-    };
+            }
+        };
+    }
+    async getBalanceOfAddress(address, _configuration) {
+        const metadata = await this.getMetadata();
+        const { total, available } = await this.nodeClient.fetchBalance(address, this.options.baseUnit);
+        return {
+            total: (0, module_kit_1.newAmount)(total).blockchain(metadata.units),
+            transferable: (0, module_kit_1.newAmount)(available).blockchain(metadata.units)
+        };
+    }
     // DELEGATION
-    CosmosBaseProtocolImpl.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 : ''];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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; })];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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
-                            }];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getDelegatorDetailsFromAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getDelegatorDetails(address)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getDelegatorDetails = function (address, validator) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var results, metadata, 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.getBalanceOfAddress(address),
-                            this.nodeClient.fetchDelegations(address).catch(function () { return []; }),
-                            this.nodeClient.fetchRewardDetails(address).catch(function () { return []; })
-                        ])];
-                    case 1:
-                        results = _b.sent();
-                        return [4 /*yield*/, this.getMetadata()];
-                    case 2:
-                        metadata = _b.sent();
-                        totalBalance = (0, module_kit_1.newAmount)(results[0].total).blockchain(metadata.units);
-                        availableBalance = results[0].transferable ? (0, module_kit_1.newAmount)(results[0].transferable).blockchain(metadata.units) : totalBalance;
-                        delegations = results[1];
-                        rewardDetails = results[2];
-                        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;
-                        return [4 /*yield*/, this.getAvailableDelegatorActions(isDelegating, new bignumber_1.default(availableBalance.value), unclaimedTotalRewards, unclaimedValidatorRewards)];
-                    case 3:
-                        availableActions = _b.sent();
-                        return [2 /*return*/, {
-                                address: address,
-                                balance: totalBalance.value,
-                                delegatees: delegations.map(function (delegation) { return delegation.delegation.validator_address; }),
-                                availableActions: availableActions
-                            }];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getAvailableDelegatorActions = function (isDelegating, availableBalance, unclaimedTotalRewards, unclaimedDelegationRewards) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var actions, metadata, requiredFee, hasSufficientBalance;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        actions = [];
-                        return [4 /*yield*/, this.getMetadata()];
-                    case 1:
-                        metadata = _d.sent();
-                        requiredFee = new bignumber_1.default((_c = (_b = (_a = metadata.fee) === null || _a === void 0 ? void 0 : _a.defaults) === null || _b === void 0 ? void 0 : _b.medium.value) !== null && _c !== void 0 ? _c : '0');
-                        hasSufficientBalance = availableBalance.gt(requiredFee);
-                        if (hasSufficientBalance) {
-                            actions.push({
-                                type: transaction_1.CosmosDelegationActionType.DELEGATE,
-                                args: ['validator', 'amount']
-                            });
-                        }
-                        if (isDelegating) {
-                            actions.push({
-                                type: transaction_1.CosmosDelegationActionType.UNDELEGATE,
-                                args: ['validator', 'amount']
-                            });
-                        }
-                        if (unclaimedTotalRewards.gt(0)) {
-                            actions.push({
-                                type: transaction_1.CosmosDelegationActionType.WITHDRAW_ALL_REWARDS
-                            });
-                        }
-                        if (unclaimedDelegationRewards === null || unclaimedDelegationRewards === void 0 ? void 0 : unclaimedDelegationRewards.gt(0)) {
-                            actions.push({
-                                type: transaction_1.CosmosDelegationActionType.WITHDRAW_VALIDATOR_REWARDS,
-                                args: ['validator']
-                            });
-                        }
-                        return [2 /*return*/, actions];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.getDelegationDetailsFromPublicKey = function (publicKey, delegatees) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, this.getDelegationDetailsFromAddress(address, delegatees)];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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]
-                            }];
-                }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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 transaction_1.CosmosDelegationActionType.DELEGATE: return [3 /*break*/, 1];
-                            case transaction_1.CosmosDelegationActionType.UNDELEGATE: return [3 /*break*/, 3];
-                            case transaction_1.CosmosDelegationActionType.WITHDRAW_ALL_REWARDS: return [3 /*break*/, 5];
-                            case transaction_1.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, { value: data.amount, unit: 'blockchain' }, false)];
-                    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, { value: data.amount, unit: 'blockchain' })];
-                    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."))];
-                }
+    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);
+    }
+    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);
+    }
+    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);
+    }
+    async getDelegatorDetailsFromAddress(address) {
+        return this.getDelegatorDetails(address);
+    }
+    async getDelegatorDetails(address, validator) {
+        const results = await Promise.all([
+            this.getBalanceOfAddress(address),
+            this.nodeClient.fetchDelegations(address).catch(() => []),
+            this.nodeClient.fetchRewardDetails(address).catch(() => [])
+        ]);
+        const metadata = await this.getMetadata();
+        const totalBalance = (0, module_kit_1.newAmount)(results[0].total).blockchain(metadata.units);
+        const availableBalance = results[0].transferable ? (0, module_kit_1.newAmount)(results[0].transferable).blockchain(metadata.units) : totalBalance;
+        const delegations = results[1];
+        const rewardDetails = results[2];
+        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 = await this.getAvailableDelegatorActions(isDelegating, new bignumber_1.default(availableBalance.value), unclaimedTotalRewards, unclaimedValidatorRewards);
+        return {
+            address,
+            balance: totalBalance.value,
+            delegatees: delegations.map((delegation) => delegation.delegation.validator_address),
+            availableActions
+        };
+    }
+    async getAvailableDelegatorActions(isDelegating, availableBalance, unclaimedTotalRewards, unclaimedDelegationRewards) {
+        const actions = [];
+        const metadata = await this.getMetadata();
+        const requiredFee = new bignumber_1.default(metadata.fee?.defaults?.medium.value ?? '0');
+        const hasSufficientBalance = availableBalance.gt(requiredFee);
+        if (hasSufficientBalance) {
+            actions.push({
+                type: transaction_1.CosmosDelegationActionType.DELEGATE,
+                args: ['validator', 'amount']
             });
-        });
-    };
-    CosmosBaseProtocolImpl.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)];
+        }
+        if (isDelegating) {
+            actions.push({
+                type: transaction_1.CosmosDelegationActionType.UNDELEGATE,
+                args: ['validator', 'amount']
             });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.delegate = function (publicKey, validatorAddress, amount, undelegate, memo) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var address, nodeInfo, account, metadata, message;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _b.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
-                    case 2:
-                        nodeInfo = _b.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
-                    case 3:
-                        account = _b.sent();
-                        return [4 /*yield*/, this.getMetadata()];
-                    case 4:
-                        metadata = _b.sent();
-                        message = new CosmosDelegateMessage_1.CosmosDelegateMessage(address, Array.isArray(validatorAddress) ? validatorAddress[0] : validatorAddress, new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(amount).blockchain(metadata.units).value), undelegate);
-                        return [2 /*return*/, new CosmosTransaction_1.CosmosTransaction([message], new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(metadata.fee.defaults.medium).blockchain(metadata.units).value)], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(metadata.units).value), memo !== undefined ? memo : '', nodeInfo.network, account.account_number, (_a = account.sequence) !== null && _a !== void 0 ? _a : '0')];
-                }
+        }
+        if (unclaimedTotalRewards.gt(0)) {
+            actions.push({
+                type: transaction_1.CosmosDelegationActionType.WITHDRAW_ALL_REWARDS
             });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.withdrawDelegationRewards = function (publicKey, _validatorAddresses, memo) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var validatorAddresses, address_1, rewards, filteredRewards, address, nodeInfo, account, messages, metadata, cosmosSimulateTx, fee, hexPublicKey, publicKeyBuffer, dummySigB64, txBytes, calcullatedFee, error_1;
-            return __generator(this, function (_c) {
-                switch (_c.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 = _c.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchRewardDetails(address_1)];
-                    case 3:
-                        rewards = _c.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; });
-                        _c.label = 4;
-                    case 4: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 5:
-                        address = _c.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
-                    case 6:
-                        nodeInfo = _c.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
-                    case 7:
-                        account = _c.sent();
-                        messages = validatorAddresses.map(function (validatorAddress) { return new CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage(address, validatorAddress); });
-                        return [4 /*yield*/, this.getMetadata()];
-                    case 8:
-                        metadata = _c.sent();
-                        cosmosSimulateTx = new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(metadata.fee.defaults.high).blockchain(metadata.units).value)], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(metadata.units).toBigNumber().times(messages.length).toFixed()), memo !== undefined ? memo : '', nodeInfo.network, account.account_number, (_a = account.sequence) !== null && _a !== void 0 ? _a : '0');
-                        _c.label = 9;
-                    case 9:
-                        _c.trys.push([9, 12, , 13]);
-                        hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-                        publicKeyBuffer = Buffer.from(hexPublicKey.value, 'hex');
-                        dummySigB64 = Buffer.alloc(64, 0).toString('base64');
-                        return [4 /*yield*/, (0, cosmjs_1.encodeTxBytes)(cosmosSimulateTx.toEncodeObject(), cosmosSimulateTx.fee, Uint8Array.from(publicKeyBuffer), new bignumber_1.default(cosmosSimulateTx.sequence).toNumber(), {
-                                signature: dummySigB64,
-                                pub_key: {
-                                    type: 'tendermint/PubKeySecp256k1',
-                                    value: publicKeyBuffer.toString('base64')
-                                }
-                            }, cosmosSimulateTx.chainID, new bignumber_1.default(cosmosSimulateTx.accountNumber).toNumber())];
-                    case 10:
-                        txBytes = _c.sent();
-                        return [4 /*yield*/, this.nodeClient.simulateTx(Buffer.from(txBytes).toString('base64'))];
-                    case 11:
-                        calcullatedFee = _c.sent();
-                        fee = calcullatedFee.gas_used.toString();
-                        return [3 /*break*/, 13];
-                    case 12:
-                        error_1 = _c.sent();
-                        fee = (0, module_kit_1.newAmount)(metadata.fee.defaults.high).blockchain(metadata.units).value;
-                        return [3 /*break*/, 13];
-                    case 13: return [2 /*return*/, new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, fee)], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(metadata.units).toBigNumber().times(messages.length).toFixed()), memo !== undefined ? memo : '', nodeInfo.network, account.account_number, (_b = account.sequence) !== null && _b !== void 0 ? _b : '0')];
-                }
+        }
+        if (unclaimedDelegationRewards?.gt(0)) {
+            actions.push({
+                type: transaction_1.CosmosDelegationActionType.WITHDRAW_VALIDATOR_REWARDS,
+                args: ['validator']
             });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.withdrawAllDelegationRewards = function (delegatorAddress, fee, memo) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var nodeInfo, account, metadata;
-            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 [4 /*yield*/, this.getMetadata()];
-                    case 3:
-                        metadata = _b.sent();
-                        return [2 /*return*/, this.nodeClient.withdrawAllDelegationRewards(delegatorAddress, nodeInfo.network, account.account_number, (_a = account.sequence) !== null && _a !== void 0 ? _a : '0', new bignumber_1.default((0, module_kit_1.newAmount)(metadata.fee.defaults.high).blockchain(metadata.units).value), new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(metadata.units).value), memo !== undefined ? memo : '')];
+        }
+        return actions;
+    }
+    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getDelegationDetailsFromAddress(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 transaction_1.CosmosDelegationActionType.DELEGATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'validator', 'amount');
+                return [await this.delegate(publicKey, data.validator, { value: data.amount, unit: 'blockchain' }, false)];
+            case transaction_1.CosmosDelegationActionType.UNDELEGATE:
+                (0, assert_1.assertFields)(`${type} action`, data, 'validator', 'amount');
+                return [await this.undelegate(publicKey, data.validator, { value: data.amount, unit: 'blockchain' })];
+            case transaction_1.CosmosDelegationActionType.WITHDRAW_ALL_REWARDS:
+                return [await this.withdrawDelegationRewards(publicKey, [])];
+            case transaction_1.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, memo) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const nodeInfo = await this.nodeClient.fetchNodeInfo();
+        const account = await this.nodeClient.fetchAccount(address);
+        const metadata = await this.getMetadata();
+        const message = new CosmosDelegateMessage_1.CosmosDelegateMessage(address, Array.isArray(validatorAddress) ? validatorAddress[0] : validatorAddress, new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(amount).blockchain(metadata.units).value), undelegate);
+        return new CosmosTransaction_1.CosmosTransaction([message], new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(metadata.fee.defaults.medium).blockchain(metadata.units).value)], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(metadata.units).value), memo !== undefined ? memo : '', nodeInfo.network, account.account_number, account.sequence ?? '0');
+    }
+    async withdrawDelegationRewards(publicKey, _validatorAddresses, memo) {
+        let validatorAddresses;
+        if (_validatorAddresses.length > 0) {
+            validatorAddresses = _validatorAddresses;
+        }
+        else {
+            const address = await this.getAddressFromPublicKey(publicKey);
+            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);
+        const nodeInfo = await this.nodeClient.fetchNodeInfo();
+        const account = await this.nodeClient.fetchAccount(address);
+        const messages = validatorAddresses.map((validatorAddress) => new CosmosWithdrawDelegationRewardMessage_1.CosmosWithdrawDelegationRewardMessage(address, validatorAddress));
+        const metadata = await this.getMetadata();
+        const cosmosSimulateTx = new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, (0, module_kit_1.newAmount)(metadata.fee.defaults.high).blockchain(metadata.units).value)], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(metadata.units).toBigNumber().times(messages.length).toFixed()), memo !== undefined ? memo : '', nodeInfo.network, account.account_number, account.sequence ?? '0');
+        let fee;
+        try {
+            const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+            const publicKeyBuffer = Buffer.from(hexPublicKey.value, 'hex');
+            const dummySigB64 = Buffer.alloc(64, 0).toString('base64');
+            const txBytes = await (0, cosmjs_1.encodeTxBytes)(cosmosSimulateTx.toEncodeObject(), cosmosSimulateTx.fee, Uint8Array.from(publicKeyBuffer), new bignumber_1.default(cosmosSimulateTx.sequence).toNumber(), {
+                signature: dummySigB64,
+                pub_key: {
+                    type: 'tendermint/PubKeySecp256k1',
+                    value: publicKeyBuffer.toString('base64')
                 }
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchTotalReward = function (delegatorAddress) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchTotalReward(delegatorAddress, this.options.baseUnit)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.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, this.options.baseUnit)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchDelegations = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchDelegations(address)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchTotalDelegatedAmount = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchTotalDelegatedAmount(address, this.options.baseUnit)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchValidator = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchValidator(address)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchValidators = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchValidators()];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchUnbondingDelegations = function (delegatorAddress) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchUnbondingDelegations(delegatorAddress)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchTotalUnbondingAmount = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchTotalUnbondingAmount(address, this.options.baseUnit)];
-            });
-        });
-    };
-    CosmosBaseProtocolImpl.prototype.fetchSelfDelegation = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.fetchSelfDelegation(address)];
-            });
-        });
-    };
-    return CosmosBaseProtocolImpl;
-}());
+            }, cosmosSimulateTx.chainID, new bignumber_1.default(cosmosSimulateTx.accountNumber).toNumber());
+            const calcullatedFee = await this.nodeClient.simulateTx(Buffer.from(txBytes).toString('base64'));
+            fee = calcullatedFee.gas_used.toString();
+        }
+        catch (error) {
+            fee = (0, module_kit_1.newAmount)(metadata.fee.defaults.high).blockchain(metadata.units).value;
+        }
+        return new CosmosTransaction_1.CosmosTransaction(messages, new CosmosFee_1.CosmosFee([new CosmosCoin_1.CosmosCoin(this.options.baseUnit, fee)], (0, module_kit_1.newAmount)(this.options.defaultGas).blockchain(metadata.units).toBigNumber().times(messages.length).toFixed()), memo !== undefined ? memo : '', nodeInfo.network, account.account_number, account.sequence ?? '0');
+    }
+    async withdrawAllDelegationRewards(delegatorAddress, fee, memo) {
+        const nodeInfo = await this.nodeClient.fetchNodeInfo();
+        const account = await this.nodeClient.fetchAccount(delegatorAddress);
+        const metadata = await this.getMetadata();
+        return this.nodeClient.withdrawAllDelegationRewards(delegatorAddress, nodeInfo.network, account.account_number, account.sequence ?? '0', new bignumber_1.default((0, module_kit_1.newAmount)(metadata.fee.defaults.high).blockchain(metadata.units).value), new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(metadata.units).value), memo !== undefined ? memo : '');
+    }
+    async fetchTotalReward(delegatorAddress) {
+        return this.nodeClient.fetchTotalReward(delegatorAddress, this.options.baseUnit);
+    }
+    async fetchRewardForDelegation(delegatorAddress, validatorAddress) {
+        return this.nodeClient.fetchRewardForDelegation(delegatorAddress, validatorAddress, this.options.baseUnit);
+    }
+    async fetchDelegations(address) {
+        return this.nodeClient.fetchDelegations(address);
+    }
+    async fetchTotalDelegatedAmount(address) {
+        return this.nodeClient.fetchTotalDelegatedAmount(address, this.options.baseUnit);
+    }
+    async fetchValidator(address) {
+        return this.nodeClient.fetchValidator(address);
+    }
+    async fetchValidators() {
+        return this.nodeClient.fetchValidators();
+    }
+    async fetchUnbondingDelegations(delegatorAddress) {
+        return this.nodeClient.fetchUnbondingDelegations(delegatorAddress);
+    }
+    async fetchTotalUnbondingAmount(address) {
+        return this.nodeClient.fetchTotalUnbondingAmount(address, this.options.baseUnit);
+    }
+    async fetchSelfDelegation(address) {
+        return this.nodeClient.fetchSelfDelegation(address);
+    }
+}
 exports.CosmosBaseProtocolImpl = CosmosBaseProtocolImpl;
 //# sourceMappingURL=CosmosBaseProtocol.js.map