@airgap/cosmos 0.13.11-beta.9 → 0.13.12-beta.0

package/v1/protocol/CosmosProtocol.js

@@ -1,4 +1,19 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -46,43 +61,22 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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.createCosmosProtocolOptions = exports.COSMOS_MAINNET_PROTOCOL_NETWORK = exports.createCosmosProtocol = exports.CosmosProtocolImpl = 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"));
-// @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");
-// @ts-ignore
-var 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 crypto_1 = require("@airgap/crypto");
 var module_kit_1 = require("@airgap/module-kit");
-var CosmosAddress_1 = require("../data/CosmosAddress");
-var CosmosCoin_1 = require("../data/CosmosCoin");
-var CosmosFee_1 = require("../data/CosmosFee");
-var CosmosTransaction_1 = require("../data/transaction/CosmosTransaction");
-var CosmosDelegateMessage_1 = require("../data/transaction/message/CosmosDelegateMessage");
-var CosmosMessage_1 = require("../data/transaction/message/CosmosMessage");
-var CosmosSendMessage_1 = require("../data/transaction/message/CosmosSendMessage");
-var CosmosWithdrawDelegationRewardMessage_1 = require("../data/transaction/message/CosmosWithdrawDelegationRewardMessage");
-var CosmosNodeClient_1 = require("../node/CosmosNodeClient");
-var key_1 = require("../utils/key");
-var signature_1 = require("../utils/signature");
-var transaction_1 = require("../utils/transaction");
-var CosmosCryptoClient_1 = require("./CosmosCryptoClient");
+var cosmos_core_1 = require("@airgap/cosmos-core");
 // Implementation
 var DEFAULT_GAS = (0, module_kit_1.newAmount)('200000', 'blockchain');
-var CosmosProtocolImpl = /** @class */ (function () {
+var CosmosProtocolImpl = /** @class */ (function (_super) {
+    __extends(CosmosProtocolImpl, _super);
     function CosmosProtocolImpl(options) {
         if (options === void 0) { options = {}; }
+        var _this = this;
+        var fullOptions = createCosmosProtocolOptions(options);
+        _this = _super.call(this, fullOptions) || this;
         // Common
-        this.units = {
+        _this.units = {
             atom: {
                 symbol: { value: 'ATOM', market: 'atom' },
                 decimals: 6
@@ -92,18 +86,18 @@ var CosmosProtocolImpl = /** @class */ (function () {
                 decimals: 0
             }
         };
-        this.feeDefaults = {
-            low: (0, module_kit_1.newAmount)(0.0005, 'atom').blockchain(this.units),
-            medium: (0, module_kit_1.newAmount)(0.005, 'atom').blockchain(this.units),
-            high: (0, module_kit_1.newAmount)(0.0072, 'atom').blockchain(this.units)
+        _this.feeDefaults = {
+            low: (0, module_kit_1.newAmount)(0.0005, 'atom').blockchain(_this.units),
+            medium: (0, module_kit_1.newAmount)(0.005, 'atom').blockchain(_this.units),
+            high: (0, module_kit_1.newAmount)(0.0072, 'atom').blockchain(_this.units)
         };
-        this.metadata = {
+        _this.metadata = {
             identifier: coinlib_core_1.MainProtocolSymbols.COSMOS,
             name: 'Cosmos',
-            units: this.units,
+            units: _this.units,
             mainUnit: 'atom',
             fee: {
-                defaults: this.feeDefaults
+                defaults: _this.feeDefaults
             },
             account: {
                 standardDerivationPath: "m/44'/118'/0'/0/0",
@@ -119,13 +113,7 @@ var CosmosProtocolImpl = /** @class */ (function () {
                 }
             }
         };
-        // Offline
-        this.cryptoConfiguration = {
-            algorithm: 'secp256k1'
-        };
-        this.options = createCosmosProtocolOptions(options.network);
-        this.nodeClient = new CosmosNodeClient_1.CosmosNodeClient(this.options.network.rpcUrl, this.options.network.useCORSProxy);
-        this.cryptoClient = new CosmosCryptoClient_1.CosmosCryptoClient();
+        return _this;
     }
     CosmosProtocolImpl.prototype.getMetadata = function () {
         return __awaiter(this, void 0, void 0, function () {
@@ -134,415 +122,6 @@ var CosmosProtocolImpl = /** @class */ (function () {
             });
         });
     };
-    CosmosProtocolImpl.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).asString()];
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-                    default:
-                        (0, coinlib_core_1.assertNever)(transaction);
-                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.COSMOS, 'Unsupported transaction type.');
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    CosmosProtocolImpl.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];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-            });
-        });
-    };
-    CosmosProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoConfiguration];
-            });
-        });
-    };
-    CosmosProtocolImpl.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')
-                    }];
-            });
-        });
-    };
-    CosmosProtocolImpl.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')
-                            })];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.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')];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.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
-                    })];
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-            });
-        });
-    };
-    // Online
-    CosmosProtocolImpl.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network];
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.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_1.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
-                        if (senderOffset <= Math.floor(senderTotal / senderLimit) * senderLimit) {
-                            promises.push(this.nodeClient.fetchSendTransactionsFor(address, senderLimit, senderOffset, true));
-                        }
-                        else {
-                            promises.push(new Promise(function (resolve) {
-                                resolve({ txs: [], tx_responses: [], pagination: { total: String(senderTotal) } });
-                            }));
-                        }
-                        recipientLimit = (0, transaction_1.calculateTransactionLimit)(limit, recipientTotal, senderTotal, recipientOffset, senderOffset);
-                        if (recipientOffset <= Math.floor(recipientTotal / recipientLimit) * recipientLimit) {
-                            promises.push(this.nodeClient.fetchSendTransactionsFor(address, recipientLimit, recipientOffset, false));
-                        }
-                        else {
-                            promises.push(new Promise(function (resolve) {
-                                resolve({ txs: [], tx_responses: [], pagination: { total: String(recipientTotal) } });
-                            }));
-                        }
-                        return [3 /*break*/, 3];
-                    case 1:
-                        ;
-                        return [4 /*yield*/, Promise.all([
-                                this.nodeClient
-                                    .fetchSendTransactionsFor(address, 1, 0, true)
-                                    .then(function (response) { return new bignumber_1.default(response.pagination.total).toNumber(); }),
-                                this.nodeClient
-                                    .fetchSendTransactionsFor(address, 1, 0, false)
-                                    .then(function (response) { return new bignumber_1.default(response.pagination.total).toNumber(); })
-                            ])];
-                    case 2:
-                        _a = _b.sent(), senderTotal = _a[0], recipientTotal = _a[1];
-                        senderLimit = (0, transaction_1.calculateTransactionLimit)(limit, senderTotal, recipientTotal, senderOffset, recipientOffset);
-                        recipientLimit = (0, transaction_1.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
-                                .filter(function (coin) { return coin.denom === 'uatom'; })
-                                .map(function (coin) { return new bignumber_1.default(coin.amount); })
-                                .reduce(function (current, next) { return current.plus(next); });
-                            result = result.concat(transaction.tx.body.messages.map(function (msg) {
-                                var tx = {
-                                    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') });
-                                }
-                            }));
-                        };
-                        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
-                                    }
-                                }
-                            }];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, this.getBalanceOfAddress(address)];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.prototype.getBalanceOfAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.nodeClient.fetchBalance(address)];
-                    case 1:
-                        balance = _a.sent();
-                        return [2 /*return*/, {
-                                total: (0, module_kit_1.newAmount)(balance.total, 'blockchain'),
-                                transferable: (0, module_kit_1.newAmount)(balance.available, 'blockchain')
-                            }];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, total, transferable, balance, fee, estimatedFee, amountWithoutFees;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        _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(this.units).value);
-                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 2];
-                        fee = configuration.fee;
-                        return [3 /*break*/, 4];
-                    case 2: 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 3:
-                        estimatedFee = _b.sent();
-                        fee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(this.units);
-                        if (balance.lte(fee.value)) {
-                            fee = (0, module_kit_1.newAmount)(0, 'blockchain');
-                        }
-                        _b.label = 4;
-                    case 4:
-                        fee = (0, module_kit_1.newAmount)(fee).blockchain(this.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')];
-                }
-            });
-        });
-    };
     CosmosProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (_publicKey, _details) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
@@ -550,84 +129,8 @@ var CosmosProtocolImpl = /** @class */ (function () {
             });
         });
     };
-    CosmosProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var fee, estimatedFee, wrappedFee, address, nodeInfo, account, _c, total, transferable, balance, messages, i, message, memo, transaction;
-            var _this = this;
-            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:
-                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.units).value);
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 4:
-                        address = _d.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchNodeInfo()];
-                    case 5:
-                        nodeInfo = _d.sent();
-                        return [4 /*yield*/, this.nodeClient.fetchAccount(address)];
-                    case 6:
-                        account = _d.sent();
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 7:
-                        _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(this.units).value);
-                        if (balance.lt(details.reduce(function (acc, next) { return acc.plus((0, module_kit_1.newAmount)(next.amount).blockchain(_this.units).value); }, wrappedFee))) {
-                            throw new errors_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('uatom', (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.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('uatom', wrappedFee.toString(10))], (0, module_kit_1.newAmount)(DEFAULT_GAS).blockchain(this.units).value), memo, nodeInfo.network, account.value.account_number, (_b = account.value.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
-                            })];
-                }
-            });
-        });
-    };
-    CosmosProtocolImpl.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)];
-            });
-        });
-    };
-    // Custom
-    CosmosProtocolImpl.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')
-                    }];
-            });
-        });
-    };
     return CosmosProtocolImpl;
-}());
+}(cosmos_core_1.CosmosBaseProtocolImpl));
 exports.CosmosProtocolImpl = CosmosProtocolImpl;
 // Factory
 function createCosmosProtocol(options) {
@@ -641,10 +144,17 @@ exports.COSMOS_MAINNET_PROTOCOL_NETWORK = {
     rpcUrl: 'https://cosmos-node.prod.gke.papers.tech'
 };
 var DEFAULT_COSMOS_PROTOCOL_NETWORK = exports.COSMOS_MAINNET_PROTOCOL_NETWORK;
-function createCosmosProtocolOptions(network) {
-    if (network === void 0) { network = {}; }
+function createCosmosProtocolOptions(partialOptions) {
+    var _a, _b, _c, _d, _e, _f;
+    if (partialOptions === void 0) { partialOptions = {}; }
     return {
-        network: __assign(__assign({}, DEFAULT_COSMOS_PROTOCOL_NETWORK), network)
+        network: __assign(__assign({}, DEFAULT_COSMOS_PROTOCOL_NETWORK), partialOptions.network),
+        addressPrefix: (_a = partialOptions.addressPrefix) !== null && _a !== void 0 ? _a : 'cosmos',
+        baseUnit: (_b = partialOptions.baseUnit) !== null && _b !== void 0 ? _b : 'uatom',
+        defaultGas: {
+            value: (_d = (_c = partialOptions.defaultGas) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : DEFAULT_GAS.value,
+            unit: (_f = (_e = partialOptions.defaultGas) === null || _e === void 0 ? void 0 : _e.unit) !== null && _f !== void 0 ? _f : DEFAULT_GAS.unit
+        }
     };
 }
 exports.createCosmosProtocolOptions = createCosmosProtocolOptions;