@airgap/cosmos 0.13.7-beta.11

package/index.d.ts

@@ -0,0 +1,10 @@
+import { CosmosAddress } from './protocol/CosmosAddress';
+import { CosmosCryptoClient } from './protocol/CosmosCryptoClient';
+import { CosmosDelegationActionType, CosmosProtocol } from './protocol/CosmosProtocol';
+import { CosmosProtocolConfig, CosmosProtocolNetwork, CosmosProtocolOptions, MintscanBlockExplorer } from './protocol/CosmosProtocolOptions';
+import { CosmosTransaction } from './protocol/CosmosTransaction';
+import { CosmosUnbondingDelegation, CosmosValidator } from './protocol/CosmosTypes';
+import { SignedCosmosTransaction } from './types/signed-transaction-cosmos';
+import { UnsignedCosmosTransaction } from './types/transaction-cosmos';
+import { SerializableUnsignedCosmosTransaction } from './types/unsigned-transaction-cosmos';
+export { CosmosProtocol, CosmosCryptoClient, MintscanBlockExplorer, CosmosProtocolNetwork, CosmosProtocolConfig, CosmosProtocolOptions, CosmosUnbondingDelegation, CosmosValidator, CosmosDelegationActionType, CosmosAddress, CosmosTransaction, UnsignedCosmosTransaction, SignedCosmosTransaction, SerializableUnsignedCosmosTransaction };

package/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosTransaction = exports.CosmosAddress = exports.CosmosDelegationActionType = exports.CosmosProtocolOptions = exports.CosmosProtocolConfig = exports.CosmosProtocolNetwork = exports.MintscanBlockExplorer = exports.CosmosCryptoClient = exports.CosmosProtocol = void 0;
+var CosmosAddress_1 = require("./protocol/CosmosAddress");
+Object.defineProperty(exports, "CosmosAddress", { enumerable: true, get: function () { return CosmosAddress_1.CosmosAddress; } });
+var CosmosCryptoClient_1 = require("./protocol/CosmosCryptoClient");
+Object.defineProperty(exports, "CosmosCryptoClient", { enumerable: true, get: function () { return CosmosCryptoClient_1.CosmosCryptoClient; } });
+var CosmosProtocol_1 = require("./protocol/CosmosProtocol");
+Object.defineProperty(exports, "CosmosDelegationActionType", { enumerable: true, get: function () { return CosmosProtocol_1.CosmosDelegationActionType; } });
+Object.defineProperty(exports, "CosmosProtocol", { enumerable: true, get: function () { return CosmosProtocol_1.CosmosProtocol; } });
+var CosmosProtocolOptions_1 = require("./protocol/CosmosProtocolOptions");
+Object.defineProperty(exports, "CosmosProtocolConfig", { enumerable: true, get: function () { return CosmosProtocolOptions_1.CosmosProtocolConfig; } });
+Object.defineProperty(exports, "CosmosProtocolNetwork", { enumerable: true, get: function () { return CosmosProtocolOptions_1.CosmosProtocolNetwork; } });
+Object.defineProperty(exports, "CosmosProtocolOptions", { enumerable: true, get: function () { return CosmosProtocolOptions_1.CosmosProtocolOptions; } });
+Object.defineProperty(exports, "MintscanBlockExplorer", { enumerable: true, get: function () { return CosmosProtocolOptions_1.MintscanBlockExplorer; } });
+var CosmosTransaction_1 = require("./protocol/CosmosTransaction");
+Object.defineProperty(exports, "CosmosTransaction", { enumerable: true, get: function () { return CosmosTransaction_1.CosmosTransaction; } });
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,0DAAwD;AAoBtD,8FApBO,6BAAa,OAoBP;AAnBf,oEAAkE;AAWhE,mGAXO,uCAAkB,OAWP;AAVpB,4DAAsF;AAiBpF,2GAjBO,2CAA0B,OAiBP;AAR1B,+FATmC,+BAAc,OASnC;AARhB,0EAA4I;AAY1I,qGAZO,4CAAoB,OAYP;AADpB,sGAX6B,6CAAqB,OAW7B;AAErB,sGAboD,6CAAqB,OAapD;AAHrB,sGAV2E,6CAAqB,OAU3E;AATvB,kEAAgE;AAiB9D,kGAjBO,qCAAiB,OAiBP"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@airgap/cosmos",
+  "version": "0.13.7-beta.11",
+  "description": "The @airgap/cosmos is a Cosmos implementation of the ICoinProtocol interface from @airgap/coinlib-core.",
+  "keywords": [
+    "airgap",
+    "blockchain",
+    "crypto",
+    "cosmos"
+  ],
+  "license": "MIT",
+  "homepage": "https://www.airgap.it",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/airgap-it/airgap-coin-lib"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && tsc && node scripts/copy-files-after-build.js",
+    "build-scripts": "tsc scripts/*.ts",
+    "lint": "tslint -c ./tslint.json --project ./tsconfig.json --format stylish --fix",
+    "lint:prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint-ci": "tslint -t json -o ../../lint-reports/cosmos.json --project . || true",
+    "lint-ci:prettier": "prettier \"src/**/*.ts\" \"test/**/*.ts\" --list-different",
+    "test": "nyc mocha --bail --require ts-node/register --require source-map-support/register --full-trace --delay --timeout 40000 ./test/**/**.spec.ts",
+    "test-ci": "nyc --reporter=lcov npm test",
+    "test-legacy": "",
+    "browserify": "browserify ./dist/index.js -p realpathify -s airgapCoinLibCosmos > ./dist/airgap-coinlib-cosmos.min.js"
+  },
+  "author": "Papers GmbH <contact@papers.ch> (https://papers.ch)",
+  "peerDependencies": {
+    "@airgap/coinlib-core": "^0.13.7-beta.0"
+  },
+  "localDependencies": {},
+  "nyc": {
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "test/**/*.spec.ts"
+    ],
+    "extension": [
+      ".ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "reporter": [
+      "text",
+      "text-summary"
+    ],
+    "report-dir": "../../coverage/cosmos",
+    "sourceMap": true,
+    "instrument": true
+  },
+  "gitHead": "8e8feb6788204501b7173aa825f5456c2a5f185b"
+}

package/protocol/CosmosAddress.d.ts

@@ -0,0 +1,8 @@
+import { IAirGapAddress } from '@airgap/coinlib-core/interfaces/IAirGapAddress';
+export declare class CosmosAddress implements IAirGapAddress {
+    private readonly value;
+    private static readonly addressPrefix;
+    private constructor();
+    static from(publicKey: string): CosmosAddress;
+    asString(): string;
+}

package/protocol/CosmosAddress.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosAddress = void 0;
+var BECH32 = require("@airgap/coinlib-core/dependencies/src/bech32-1.1.3/index");
+var RIPEMD160 = require("@airgap/coinlib-core/dependencies/src/ripemd160-2.0.2/index");
+var sha = require("@airgap/coinlib-core/dependencies/src/sha.js-2.4.11/index");
+var CosmosAddress = /** @class */ (function () {
+    function CosmosAddress(value) {
+        this.value = value;
+    }
+    CosmosAddress.from = function (publicKey) {
+        var pubkey = Buffer.from(publicKey, 'hex');
+        var sha256Hash = sha('sha256').update(pubkey).digest();
+        var hash = new RIPEMD160().update(Buffer.from(sha256Hash)).digest();
+        var address = BECH32.encode(CosmosAddress.addressPrefix, BECH32.toWords(hash));
+        return new CosmosAddress(address);
+    };
+    CosmosAddress.prototype.asString = function () {
+        return this.value;
+    };
+    CosmosAddress.addressPrefix = 'cosmos';
+    return CosmosAddress;
+}());
+exports.CosmosAddress = CosmosAddress;
+//# sourceMappingURL=CosmosAddress.js.map

package/protocol/CosmosAddress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CosmosAddress.js","sourceRoot":"","sources":["../../src/protocol/CosmosAddress.ts"],"names":[],"mappings":";;;AAAA,iFAAmF;AACnF,uFAAyF;AACzF,+EAAiF;AAGjF;IAGE,uBAAqC,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;IAExC,kBAAI,GAAlB,UAAmB,SAAiB;QAClC,IAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;QAE5C,IAAM,UAAU,GAAW,GAAG,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,CAAA;QAChE,IAAM,IAAI,GAAG,IAAI,SAAS,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,EAAE,CAAA;QACrE,IAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;QAEhF,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAA;IACnC,CAAC;IAEM,gCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;IAhBuB,2BAAa,GAAW,QAAQ,CAAA;IAiB1D,oBAAC;CAAA,AAlBD,IAkBC;AAlBY,sCAAa"}

package/protocol/CosmosCoin.d.ts

@@ -0,0 +1,19 @@
+import BigNumber from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { JSONConvertible } from '@airgap/coinlib-core/interfaces/JSONConvertible';
+import { RPCConvertible } from '@airgap/coinlib-core/interfaces/RPCConvertible';
+export interface CosmosCoinJSON {
+    denom: string;
+    amount: string;
+}
+export declare class CosmosCoin implements JSONConvertible, RPCConvertible {
+    private static readonly supportedDenominations;
+    readonly denom: string;
+    readonly amount: string;
+    constructor(denom: string, amount: string);
+    toJSON(): CosmosCoinJSON;
+    static fromJSON(json: CosmosCoinJSON): CosmosCoin;
+    static fromCoins(json: CosmosCoinJSON[]): CosmosCoin[];
+    static sum(coins: CosmosCoin[]): BigNumber;
+    toRPCBody(): any;
+    static fromRPCBody(json: any): CosmosCoin;
+}

package/protocol/CosmosCoin.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosCoin = void 0;
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var CosmosCoin = /** @class */ (function () {
+    function CosmosCoin(denom, amount) {
+        this.denom = denom;
+        this.amount = amount;
+    }
+    CosmosCoin.prototype.toJSON = function () {
+        return {
+            amount: this.amount,
+            denom: this.denom
+        };
+    };
+    CosmosCoin.fromJSON = function (json) {
+        if (!CosmosCoin.supportedDenominations.includes(json.denom)) {
+            throw new errors_1.UnsupportedError(coinlib_error_1.Domain.COSMOS, 'Unsupported cosmos denomination');
+        }
+        return new CosmosCoin(json.denom, json.amount);
+    };
+    CosmosCoin.fromCoins = function (json) {
+        return json
+            .map(function (coinJSON) {
+            try {
+                return CosmosCoin.fromJSON(coinJSON);
+            }
+            catch (_a) {
+                return undefined;
+            }
+        })
+            .filter(function (value) { return value !== undefined; });
+    };
+    CosmosCoin.sum = function (coins) {
+        return coins.reduce(function (current, next) { return current.plus(new bignumber_1.default(next.amount)); }, new bignumber_1.default(0));
+    };
+    CosmosCoin.prototype.toRPCBody = function () {
+        return {
+            amount: this.amount,
+            denom: this.denom
+        };
+    };
+    CosmosCoin.fromRPCBody = function (json) {
+        return new CosmosCoin(json.denom, json.amount);
+    };
+    CosmosCoin.supportedDenominations = ['uatom'];
+    return CosmosCoin;
+}());
+exports.CosmosCoin = CosmosCoin;
+//# sourceMappingURL=CosmosCoin.js.map

package/protocol/CosmosCoin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CosmosCoin.js","sourceRoot":"","sources":["../../src/protocol/CosmosCoin.ts"],"names":[],"mappings":";;;;;;AAAA,iHAA0F;AAC1F,sDAA8D;AAC9D,2EAAkE;AASlE;IAKE,oBAAY,KAAa,EAAE,MAAc;QACvC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;IAEM,2BAAM,GAAb;QACE,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAA;IACH,CAAC;IAEa,mBAAQ,GAAtB,UAAuB,IAAoB;QACzC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAC3D,MAAM,IAAI,yBAAgB,CAAC,sBAAM,CAAC,MAAM,EAAE,iCAAiC,CAAC,CAAA;SAC7E;QAED,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IAChD,CAAC;IAEa,oBAAS,GAAvB,UAAwB,IAAsB;QAC5C,OAAO,IAAI;aACR,GAAG,CAAC,UAAC,QAAQ;YACZ,IAAI;gBACF,OAAO,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;aACrC;YAAC,WAAM;gBACN,OAAO,SAAS,CAAA;aACjB;QACH,CAAC,CAAC;aACD,MAAM,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,KAAK,SAAS,EAAnB,CAAmB,CAAiB,CAAA;IAC3D,CAAC;IAEa,cAAG,GAAjB,UAAkB,KAAmB;QACnC,OAAO,KAAK,CAAC,MAAM,CAAC,UAAC,OAAO,EAAE,IAAI,IAAK,OAAA,OAAO,CAAC,IAAI,CAAC,IAAI,mBAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAxC,CAAwC,EAAE,IAAI,mBAAS,CAAC,CAAC,CAAC,CAAC,CAAA;IACpG,CAAC;IAEM,8BAAS,GAAhB;QACE,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAA;IACH,CAAC;IAEa,sBAAW,GAAzB,UAA0B,IAAS;QACjC,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IAChD,CAAC;IAjDuB,iCAAsB,GAAG,CAAC,OAAO,CAAC,CAAA;IAkD5D,iBAAC;CAAA,AAnDD,IAmDC;AAnDY,gCAAU"}

package/protocol/CosmosCryptoClient.d.ts

@@ -0,0 +1,8 @@
+import { Secp256k1CryptoClient } from '@airgap/coinlib-core/protocols/Secp256k1CryptoClient';
+export declare class CosmosCryptoClient extends Secp256k1CryptoClient {
+    constructor();
+    signMessage(message: string, keypair: {
+        privateKey: string;
+    }): Promise<string>;
+    verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
+}

package/protocol/CosmosCryptoClient.js

@@ -0,0 +1,86 @@
+"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) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosCryptoClient = void 0;
+var SECP256K1 = require("@airgap/coinlib-core/dependencies/src/secp256k1-3.7.1/elliptic");
+var sha = require("@airgap/coinlib-core/dependencies/src/sha.js-2.4.11/index");
+var Secp256k1CryptoClient_1 = require("@airgap/coinlib-core/protocols/Secp256k1CryptoClient");
+var CosmosCryptoClient = /** @class */ (function (_super) {
+    __extends(CosmosCryptoClient, _super);
+    function CosmosCryptoClient() {
+        return _super.call(this) || this;
+    }
+    CosmosCryptoClient.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sha256Hash, hash, signed;
+            return __generator(this, function (_a) {
+                sha256Hash = sha('sha256').update(Buffer.from(message)).digest();
+                hash = Buffer.from(sha256Hash);
+                signed = SECP256K1.sign(hash, Buffer.from(keypair.privateKey, 'hex'));
+                return [2 /*return*/, "0x" + Buffer.from(signed.signature).toString('hex')];
+            });
+        });
+    };
+    CosmosCryptoClient.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawSignature, sha256Hash, messageHash;
+            return __generator(this, function (_a) {
+                rawSignature = Buffer.from(signature.slice(2), 'hex');
+                sha256Hash = sha('sha256').update(Buffer.from(message)).digest();
+                messageHash = Buffer.from(sha256Hash);
+                return [2 /*return*/, SECP256K1.verify(messageHash, rawSignature, Buffer.from(publicKey, 'hex'))];
+            });
+        });
+    };
+    return CosmosCryptoClient;
+}(Secp256k1CryptoClient_1.Secp256k1CryptoClient));
+exports.CosmosCryptoClient = CosmosCryptoClient;
+//# sourceMappingURL=CosmosCryptoClient.js.map

package/protocol/CosmosCryptoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CosmosCryptoClient.js","sourceRoot":"","sources":["../../src/protocol/CosmosCryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0FAA4F;AAC5F,+EAAiF;AACjF,8FAA4F;AAE5F;IAAwC,sCAAqB;IAC3D;eACE,iBAAO;IACT,CAAC;IAEY,wCAAW,GAAxB,UAAyB,OAAe,EAAE,OAA+B;;;;gBACjE,UAAU,GAAW,GAAG,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAA;gBACxE,IAAI,GAAW,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;gBACtC,MAAM,GAA0B,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAA;gBAElG,sBAAO,OAAK,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAG,EAAA;;;KAC5D;IAEY,0CAAa,GAA1B,UAA2B,OAAe,EAAE,SAAiB,EAAE,SAAiB;;;;gBACxE,YAAY,GAAW,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;gBAE7D,UAAU,GAAW,GAAG,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,CAAA;gBACxE,WAAW,GAAW,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;gBAEnD,sBAAO,SAAS,CAAC,MAAM,CAAC,WAAW,EAAE,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,EAAA;;;KAClF;IACH,yBAAC;AAAD,CAAC,AArBD,CAAwC,6CAAqB,GAqB5D;AArBY,gDAAkB"}

package/protocol/CosmosFee.d.ts

@@ -0,0 +1,15 @@
+import { JSONConvertible } from '@airgap/coinlib-core/interfaces/JSONConvertible';
+import { RPCConvertible } from '@airgap/coinlib-core/interfaces/RPCConvertible';
+import { CosmosCoin } from './CosmosCoin';
+export declare class CosmosFee implements JSONConvertible, RPCConvertible {
+    readonly amount: CosmosCoin[];
+    readonly gas: string;
+    constructor(amount: CosmosCoin[], gas: string);
+    toJSON(): {
+        amount: import("./CosmosCoin").CosmosCoinJSON[];
+        gas: string;
+    };
+    static fromJSON(json: any): CosmosFee;
+    toRPCBody(): any;
+    static fromRPCBody(json: any): CosmosFee;
+}

package/protocol/CosmosFee.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosFee = void 0;
+var CosmosCoin_1 = require("./CosmosCoin");
+var CosmosFee = /** @class */ (function () {
+    function CosmosFee(amount, gas) {
+        this.amount = amount;
+        this.gas = gas;
+    }
+    CosmosFee.prototype.toJSON = function () {
+        return {
+            amount: this.amount.map(function (value) { return value.toJSON(); }),
+            gas: this.gas
+        };
+    };
+    CosmosFee.fromJSON = function (json) {
+        return new CosmosFee(json.amount.map(function (value) { return CosmosCoin_1.CosmosCoin.fromJSON(value); }), json.gas);
+    };
+    CosmosFee.prototype.toRPCBody = function () {
+        return {
+            amount: this.amount.map(function (value) { return value.toRPCBody(); }),
+            gas: this.gas
+        };
+    };
+    CosmosFee.fromRPCBody = function (json) {
+        return new CosmosFee(json.amount.map(function (value) { return CosmosCoin_1.CosmosCoin.fromRPCBody(value); }), json.gas);
+    };
+    return CosmosFee;
+}());
+exports.CosmosFee = CosmosFee;
+//# sourceMappingURL=CosmosFee.js.map

package/protocol/CosmosFee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CosmosFee.js","sourceRoot":"","sources":["../../src/protocol/CosmosFee.ts"],"names":[],"mappings":";;;AAEA,2CAAyC;AAEzC;IAIE,mBAAY,MAAoB,EAAE,GAAW;QAC3C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IAEM,0BAAM,GAAb;QACE,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,CAAC,MAAM,EAAE,EAAd,CAAc,CAAC;YAClD,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAA;IACH,CAAC;IAEa,kBAAQ,GAAtB,UAAuB,IAAS;QAC9B,OAAO,IAAI,SAAS,CAClB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,KAAU,IAAK,OAAA,uBAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,EAA1B,CAA0B,CAAC,EAC3D,IAAI,CAAC,GAAG,CACT,CAAA;IACH,CAAC;IAEM,6BAAS,GAAhB;QACE,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,KAAK,IAAK,OAAA,KAAK,CAAC,SAAS,EAAE,EAAjB,CAAiB,CAAC;YACrD,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAA;IACH,CAAC;IAEa,qBAAW,GAAzB,UAA0B,IAAS;QACjC,OAAO,IAAI,SAAS,CAClB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAC,KAAU,IAAK,OAAA,uBAAU,CAAC,WAAW,CAAC,KAAK,CAAC,EAA7B,CAA6B,CAAC,EAC9D,IAAI,CAAC,GAAG,CACT,CAAA;IACH,CAAC;IACH,gBAAC;AAAD,CAAC,AApCD,IAoCC;AApCY,8BAAS"}

package/protocol/CosmosNodeClient.d.ts

@@ -0,0 +1,25 @@
+import BigNumber from '@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { CosmosAccount, CosmosDelegation, CosmosNodeInfo, CosmosPagedSendTxsResponse, CosmosRewardDetails, CosmosUnbondingDelegation, CosmosValidator } from './CosmosTypes';
+export declare class CosmosNodeClient {
+    readonly baseURL: string;
+    useCORSProxy: boolean;
+    constructor(baseURL: string, useCORSProxy?: boolean);
+    fetchBalance(address: string, totalBalance?: boolean): Promise<BigNumber>;
+    fetchSendTransactionsFor(address: string, limit: number, offset: number, isSender?: boolean): Promise<CosmosPagedSendTxsResponse>;
+    fetchNodeInfo(): Promise<CosmosNodeInfo>;
+    broadcastSignedTransaction(tx_bytes: string): Promise<string>;
+    fetchAccount(address: string): Promise<CosmosAccount>;
+    fetchDelegations(address: string, filterEmpty?: boolean): Promise<CosmosDelegation[]>;
+    fetchTotalDelegatedAmount(address: string): Promise<BigNumber>;
+    fetchValidator(address: string): Promise<CosmosValidator>;
+    fetchValidators(): Promise<CosmosValidator[]>;
+    fetchSelfDelegation(validatorAddress: string): Promise<CosmosDelegation>;
+    fetchUnbondingDelegations(delegatorAddress: string): Promise<CosmosUnbondingDelegation[]>;
+    fetchTotalUnbondingAmount(address: string): Promise<BigNumber>;
+    fetchRewardDetails(delegatorAddress: string): Promise<CosmosRewardDetails[]>;
+    fetchTotalReward(delegatorAddress: string): Promise<BigNumber>;
+    fetchRewardForDelegation(delegatorAddress: string, validatorAddress: string): Promise<BigNumber>;
+    withdrawAllDelegationRewards(delegatorAddress: string, chainID: string, accountNumber: string, sequence: string, gas: BigNumber, fee: BigNumber, memo: string, simulate?: boolean): Promise<string>;
+    withdrawDelegationRewards(delegatorAddress: string, validatorAdress: string, chainID: string, accountNumber: string, sequence: string, gas: BigNumber, fee: BigNumber, memo: string, simulate?: boolean): Promise<string>;
+    private url;
+}