@firmachain/firma-js 0.2.17 → 0.2.18

package/dist/sdk/FirmaWalletService.d.ts

@@ -0,0 +1,40 @@
+import { DirectSecp256k1Wallet, Registry } from "@cosmjs/proto-signing";
+import { EncodeObject } from "@cosmjs/proto-signing";
+import { FirmaConfig } from "./FirmaConfig";
+import { SignAndBroadcastOptions } from "./firmachain/common";
+import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+export interface LedgerWalletInterface {
+    getAddress(): Promise<string>;
+    sign(message: string): Promise<Uint8Array>;
+    getPublicKey(): Promise<Uint8Array>;
+}
+export declare class FirmaWalletService {
+    private readonly config;
+    private mnemonic;
+    private privateKey;
+    private accountIndex;
+    private wallet;
+    private ledger;
+    getHdPath(): string;
+    getPrefix(): string;
+    getRawWallet(): DirectSecp256k1Wallet;
+    getPrivateKey(): string;
+    getMnemonic(): string;
+    isLedger(): boolean;
+    initFromLedger(ledger: LedgerWalletInterface): Promise<FirmaWalletService>;
+    signLedger(messages: EncodeObject[], option: SignAndBroadcastOptions, registry: Registry): Promise<TxRaw>;
+    getAddress(): Promise<string>;
+    constructor(config: FirmaConfig);
+    private static getHdPath;
+    initFromMnemonic(mnemonic: string, accountIndex?: number): Promise<{
+        success: boolean;
+    }>;
+    private getPrivateKeyInternal;
+    initFromPrivateKey(privateKey: string): Promise<void>;
+    decryptData(data: string): string;
+    encryptData(data: string): string;
+    newWallet(): Promise<FirmaWalletService>;
+    fromMnemonic(mnemonic: string, accountIndex?: number): Promise<FirmaWalletService>;
+    fromPrivateKey(privateKey: string): Promise<FirmaWalletService>;
+    generateMnemonic(): Promise<string>;
+}

package/dist/sdk/FirmaWalletService.js

@@ -0,0 +1,309 @@
+"use strict";
+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.FirmaWalletService = void 0;
+var proto_signing_1 = require("@cosmjs/proto-signing");
+var crypto_1 = require("@cosmjs/crypto");
+var FirmaUtil_1 = require("./FirmaUtil");
+var LedgerWallet_1 = require("./firmachain/common/LedgerWallet");
+var CryptoJS = require("crypto-js");
+var FirmaWalletService = /** @class */ (function () {
+    function FirmaWalletService(config) {
+        this.config = config;
+        this.mnemonic = "";
+        this.privateKey = "";
+        this.accountIndex = 0;
+    }
+    FirmaWalletService.prototype.getHdPath = function () {
+        return this.config.hdPath;
+    };
+    FirmaWalletService.prototype.getPrefix = function () {
+        return this.config.prefix;
+    };
+    FirmaWalletService.prototype.getRawWallet = function () {
+        return this.wallet;
+    };
+    FirmaWalletService.prototype.getPrivateKey = function () {
+        return this.privateKey;
+    };
+    FirmaWalletService.prototype.getMnemonic = function () {
+        return this.mnemonic;
+    };
+    FirmaWalletService.prototype.isLedger = function () {
+        return (this.ledger != null);
+    };
+    FirmaWalletService.prototype.initFromLedger = function (ledger) {
+        return __awaiter(this, void 0, void 0, function () {
+            var wallet;
+            return __generator(this, function (_a) {
+                try {
+                    wallet = new FirmaWalletService(this.config);
+                    wallet.ledger = ledger;
+                    return [2 /*return*/, wallet];
+                }
+                catch (error) {
+                    FirmaUtil_1.FirmaUtil.printLog(error);
+                    throw error;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    FirmaWalletService.prototype.signLedger = function (messages, option, registry) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, LedgerWallet_1.signFromLedger(this.ledger, messages, option, registry)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.getAddress = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var accounts, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        if (!(this.ledger != null)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.ledger.getAddress()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2: return [4 /*yield*/, this.wallet.getAccounts()];
+                    case 3:
+                        accounts = _a.sent();
+                        return [2 /*return*/, accounts[0].address];
+                    case 4:
+                        error_1 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_1);
+                        throw error_1;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.getHdPath = function (hdPath, accountIndex) {
+        try {
+            return [crypto_1.stringToPath(hdPath + accountIndex + "'/0/0")];
+        }
+        catch (error) {
+            FirmaUtil_1.FirmaUtil.printLog(error);
+            throw error;
+        }
+    };
+    FirmaWalletService.prototype.initFromMnemonic = function (mnemonic, accountIndex) {
+        if (accountIndex === void 0) { accountIndex = 0; }
+        return __awaiter(this, void 0, void 0, function () {
+            var privateKey, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        this.mnemonic = mnemonic;
+                        this.accountIndex = accountIndex;
+                        return [4 /*yield*/, this.getPrivateKeyInternal(this.mnemonic, this.accountIndex)];
+                    case 1:
+                        privateKey = _a.sent();
+                        return [4 /*yield*/, this.initFromPrivateKey(privateKey)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, { success: true }];
+                    case 3:
+                        error_2 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_2);
+                        throw error_2;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.getPrivateKeyInternal = function (mnemonic, accountIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mnemonicChecked, seed, hdpath, privkey, privateKey, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        mnemonicChecked = new crypto_1.EnglishMnemonic(mnemonic);
+                        return [4 /*yield*/, crypto_1.Bip39.mnemonicToSeed(mnemonicChecked)];
+                    case 1:
+                        seed = _a.sent();
+                        hdpath = FirmaWalletService.getHdPath(this.getHdPath(), this.accountIndex);
+                        privkey = crypto_1.Slip10.derivePath(crypto_1.Slip10Curve.Secp256k1, seed, hdpath[0]).privkey;
+                        privateKey = "0x" + Buffer.from(privkey).toString("hex");
+                        return [2 /*return*/, privateKey];
+                    case 2:
+                        error_3 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_3);
+                        throw error_3;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.initFromPrivateKey = function (privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tempPrivateKey, _a, error_4;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        tempPrivateKey = Buffer.from(privateKey.replace("0x", ""), "hex");
+                        _a = this;
+                        return [4 /*yield*/, proto_signing_1.DirectSecp256k1Wallet.fromKey(tempPrivateKey, this.getPrefix())];
+                    case 1:
+                        _a.wallet = _b.sent();
+                        this.privateKey = privateKey;
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_4 = _b.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_4);
+                        throw error_4;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.decryptData = function (data) {
+        try {
+            var bytes = CryptoJS.AES.decrypt(data, this.getPrivateKey());
+            return bytes.toString(CryptoJS.enc.Utf8);
+        }
+        catch (error) {
+            FirmaUtil_1.FirmaUtil.printLog(error);
+            throw error;
+        }
+    };
+    FirmaWalletService.prototype.encryptData = function (data) {
+        try {
+            return CryptoJS.AES.encrypt(data, this.getPrivateKey()).toString();
+        }
+        catch (error) {
+            FirmaUtil_1.FirmaUtil.printLog(error);
+            throw error;
+        }
+    };
+    FirmaWalletService.prototype.newWallet = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var mnemonic, wallet, error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, this.generateMnemonic()];
+                    case 1:
+                        mnemonic = _a.sent();
+                        return [4 /*yield*/, this.fromMnemonic(mnemonic)];
+                    case 2:
+                        wallet = _a.sent();
+                        return [2 /*return*/, wallet];
+                    case 3:
+                        error_5 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_5);
+                        throw error_5;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.fromMnemonic = function (mnemonic, accountIndex) {
+        if (accountIndex === void 0) { accountIndex = 0; }
+        return __awaiter(this, void 0, void 0, function () {
+            var wallet, error_6;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        wallet = new FirmaWalletService(this.config);
+                        return [4 /*yield*/, wallet.initFromMnemonic(mnemonic, accountIndex)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, wallet];
+                    case 2:
+                        error_6 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_6);
+                        throw error_6;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.fromPrivateKey = function (privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var wallet, error_7;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        wallet = new FirmaWalletService(this.config);
+                        return [4 /*yield*/, wallet.initFromPrivateKey(privateKey)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, wallet];
+                    case 2:
+                        error_7 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_7);
+                        throw error_7;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FirmaWalletService.prototype.generateMnemonic = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var wallet, error_8;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, proto_signing_1.DirectSecp256k1HdWallet.generate(24)];
+                    case 1:
+                        wallet = _a.sent();
+                        return [2 /*return*/, wallet.mnemonic];
+                    case 2:
+                        error_8 = _a.sent();
+                        FirmaUtil_1.FirmaUtil.printLog(error_8);
+                        throw error_8;
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return FirmaWalletService;
+}());
+exports.FirmaWalletService = FirmaWalletService;

package/dist/sdk/firmachain/amino/addresses.d.ts

@@ -0,0 +1,5 @@
+import { Pubkey } from "./pubkeys";
+export declare function rawEd25519PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array;
+export declare function rawSecp256k1PubkeyToRawAddress(pubkeyData: Uint8Array): Uint8Array;
+export declare function pubkeyToRawAddress(pubkey: Pubkey): Uint8Array;
+export declare function pubkeyToAddress(pubkey: Pubkey, prefix: string): string;

package/dist/sdk/firmachain/amino/addresses.js

@@ -0,0 +1,46 @@
+"use strict";
+// See https://github.com/tendermint/tendermint/blob/f2ada0a604b4c0763bda2f64fac53d506d3beca7/docs/spec/blockchain/encoding.md#public-key-cryptography
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pubkeyToAddress = exports.pubkeyToRawAddress = exports.rawSecp256k1PubkeyToRawAddress = exports.rawEd25519PubkeyToRawAddress = void 0;
+var crypto_1 = require("@cosmjs/crypto");
+var encoding_1 = require("@cosmjs/encoding");
+var encoding_2 = require("./encoding");
+var pubkeys_1 = require("./pubkeys");
+function rawEd25519PubkeyToRawAddress(pubkeyData) {
+    if (pubkeyData.length !== 32) {
+        throw new Error("Invalid Ed25519 pubkey length: " + pubkeyData.length);
+    }
+    return crypto_1.sha256(pubkeyData).slice(0, 20);
+}
+exports.rawEd25519PubkeyToRawAddress = rawEd25519PubkeyToRawAddress;
+function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
+    if (pubkeyData.length !== 33) {
+        throw new Error("Invalid Secp256k1 pubkey length (compressed): " + pubkeyData.length);
+    }
+    return crypto_1.ripemd160(crypto_1.sha256(pubkeyData));
+}
+exports.rawSecp256k1PubkeyToRawAddress = rawSecp256k1PubkeyToRawAddress;
+// For secp256k1 this assumes we already have a compressed pubkey.
+function pubkeyToRawAddress(pubkey) {
+    if (pubkeys_1.isSecp256k1Pubkey(pubkey)) {
+        var pubkeyData = encoding_1.fromBase64(pubkey.value);
+        return rawSecp256k1PubkeyToRawAddress(pubkeyData);
+    }
+    else if (pubkeys_1.isEd25519Pubkey(pubkey)) {
+        var pubkeyData = encoding_1.fromBase64(pubkey.value);
+        return rawEd25519PubkeyToRawAddress(pubkeyData);
+    }
+    else if (pubkeys_1.isMultisigThresholdPubkey(pubkey)) {
+        // https://github.com/tendermint/tendermint/blob/38b401657e4ad7a7eeb3c30a3cbf512037df3740/crypto/multisig/threshold_pubkey.go#L71-L74
+        var pubkeyData = encoding_2.encodeAminoPubkey(pubkey);
+        return crypto_1.sha256(pubkeyData).slice(0, 20);
+    }
+    else {
+        throw new Error("Unsupported public key type");
+    }
+}
+exports.pubkeyToRawAddress = pubkeyToRawAddress;
+function pubkeyToAddress(pubkey, prefix) {
+    return encoding_1.Bech32.encode(prefix, pubkeyToRawAddress(pubkey));
+}
+exports.pubkeyToAddress = pubkeyToAddress;

package/dist/sdk/firmachain/amino/aminomsgs.d.ts

@@ -0,0 +1,281 @@
+import { Coin } from "./coins";
+import { AminoMsg } from "./signdoc";
+/** A high level transaction of the coin module */
+export interface AminoMsgSend extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgSend";
+    readonly value: {
+        /** Bech32 account address */
+        readonly from_address: string;
+        /** Bech32 account address */
+        readonly to_address: string;
+        readonly amount: readonly Coin[];
+    };
+}
+export declare function isAminoMsgSend(msg: AminoMsg): msg is AminoMsgSend;
+interface Input {
+    /** Bech32 account address */
+    readonly address: string;
+    readonly coins: readonly Coin[];
+}
+interface Output {
+    /** Bech32 account address */
+    readonly address: string;
+    readonly coins: readonly Coin[];
+}
+/** A high level transaction of the coin module */
+export interface AminoMsgMultiSend extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgMultiSend";
+    readonly value: {
+        readonly inputs: readonly Input[];
+        readonly outputs: readonly Output[];
+    };
+}
+export declare function isAminoMsgMultiSend(msg: AminoMsg): msg is AminoMsgMultiSend;
+/** Verifies a particular invariance */
+export interface AminoMsgVerifyInvariant extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgVerifyInvariant";
+    readonly value: {
+        /** Bech32 account address */
+        readonly sender: string;
+        readonly invariant_module_name: string;
+        readonly invariant_route: string;
+    };
+}
+export declare function isAminoMsgVerifyInvariant(msg: AminoMsg): msg is AminoMsgVerifyInvariant;
+/** Changes the withdraw address for a delegator (or validator self-delegation) */
+export interface AminoMsgSetWithdrawAddress extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgModifyWithdrawAddress";
+    readonly value: {
+        /** Bech32 account address */
+        readonly delegator_address: string;
+        /** Bech32 account address */
+        readonly withdraw_address: string;
+    };
+}
+export declare function isAminoMsgSetWithdrawAddress(msg: AminoMsg): msg is AminoMsgSetWithdrawAddress;
+/** Message for delegation withdraw from a single validator */
+export interface AminoMsgWithdrawDelegatorReward extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgWithdrawDelegationReward";
+    readonly value: {
+        /** Bech32 account address */
+        readonly delegator_address: string;
+        /** Bech32 account address */
+        readonly validator_address: string;
+    };
+}
+export declare function isAminoMsgWithdrawDelegatorReward(msg: AminoMsg): msg is AminoMsgWithdrawDelegatorReward;
+/** Message for validator withdraw */
+export interface AminoMsgWithdrawValidatorCommission extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgWithdrawValidatorCommission";
+    readonly value: {
+        /** Bech32 account address */
+        readonly validator_address: string;
+    };
+}
+export declare function isAminoMsgWithdrawValidatorCommission(msg: AminoMsg): msg is AminoMsgWithdrawValidatorCommission;
+/** Allows an account to directly fund the community pool. */
+export interface AminoMsgFundCommunityPool extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgFundCommunityPool";
+    readonly value: {
+        readonly amount: readonly Coin[];
+        /** Bech32 account address */
+        readonly depositor: string;
+    };
+}
+export declare function isAminoMsgFundCommunityPool(msg: AminoMsg): msg is AminoMsgFundCommunityPool;
+interface Any {
+    readonly type_url: string;
+    readonly value: Uint8Array;
+}
+/** Supports submitting arbitrary evidence */
+export interface AminoMsgSubmitEvidence extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgSubmitEvidence";
+    readonly value: {
+        /** Bech32 account address */
+        readonly submitter: string;
+        readonly evidence: Any;
+    };
+}
+export declare function isAminoMsgSubmitEvidence(msg: AminoMsg): msg is AminoMsgSubmitEvidence;
+/** Supports submitting arbitrary proposal content. */
+export interface AminoMsgSubmitProposal extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgSubmitProposal";
+    readonly value: {
+        /**
+         * A proposal structure, e.g.
+         *
+         * ```
+         * {
+         *   type: 'cosmos-sdk/TextProposal',
+         *   value: {
+         *     description: 'This proposal proposes to test whether this proposal passes',
+         *     title: 'Test Proposal'
+         *   }
+         * }
+         * ```
+         */
+        readonly content: {
+            readonly type: string;
+            readonly value: any;
+        };
+        readonly initial_deposit: readonly Coin[];
+        /** Bech32 account address */
+        readonly proposer: string;
+    };
+}
+export declare function isAminoMsgSubmitProposal(msg: AminoMsg): msg is AminoMsgSubmitProposal;
+/** Casts a vote */
+export interface AminoMsgVote extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgVote";
+    readonly value: {
+        readonly proposal_id: string;
+        /** Bech32 account address */
+        readonly voter: string;
+        /**
+         * VoteOption as integer from 0 to 4 🤷‍
+         *
+         * @see https://github.com/cosmos/cosmos-sdk/blob/v0.42.9/x/gov/types/gov.pb.go#L38-L49
+         */
+        readonly option: number;
+    };
+}
+export declare function isAminoMsgVote(msg: AminoMsg): msg is AminoMsgVote;
+/** Submits a deposit to an existing proposal */
+export interface AminoMsgDeposit extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgDeposit";
+    readonly value: {
+        readonly proposal_id: string;
+        /** Bech32 account address */
+        readonly depositor: string;
+        readonly amount: readonly Coin[];
+    };
+}
+export declare function isAminoMsgDeposit(msg: AminoMsg): msg is AminoMsgDeposit;
+/** Unjails a jailed validator */
+export interface AminoMsgUnjail extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgUnjail";
+    readonly value: {
+        /** Bech32 account address */
+        readonly validator_addr: string;
+    };
+}
+export declare function isAminoMsgUnjail(msg: AminoMsg): msg is AminoMsgUnjail;
+/** The initial commission rates to be used for creating a validator */
+interface CommissionRates {
+    readonly rate: string;
+    readonly max_rate: string;
+    readonly max_change_rate: string;
+}
+/** A validator description. */
+interface Description {
+    readonly moniker: string;
+    readonly identity: string;
+    readonly website: string;
+    readonly security_contact: string;
+    readonly details: string;
+}
+/** Creates a new validator. */
+export interface AminoMsgCreateValidator extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgCreateValidator";
+    readonly value: {
+        readonly description: Description;
+        readonly commission: CommissionRates;
+        readonly min_self_delegation: string;
+        /** Bech32 encoded delegator address */
+        readonly delegator_address: string;
+        /** Bech32 encoded validator address */
+        readonly validator_address: string;
+        /** Bech32 encoded public key */
+        readonly pubkey: string;
+        readonly value: Coin;
+    };
+}
+export declare function isAminoMsgCreateValidator(msg: AminoMsg): msg is AminoMsgCreateValidator;
+/** Edits an existing validator. */
+export interface AminoMsgEditValidator extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgEditValidator";
+    readonly value: {
+        readonly description: Description;
+        /** Bech32 encoded validator address */
+        readonly validator_address: string;
+        readonly commission_rate: string;
+        readonly min_self_delegation: string;
+    };
+}
+export declare function isAminoMsgEditValidator(msg: AminoMsg): msg is AminoMsgEditValidator;
+/**
+ * Performs a delegation from a delegate to a validator.
+ *
+ * @see https://docs.cosmos.network/master/modules/staking/03_messages.html#msgdelegate
+ */
+export interface AminoMsgDelegate extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgDelegate";
+    readonly value: {
+        /** Bech32 encoded delegator address */
+        readonly delegator_address: string;
+        /** Bech32 encoded validator address */
+        readonly validator_address: string;
+        readonly amount: Coin;
+    };
+}
+export declare function isAminoMsgDelegate(msg: AminoMsg): msg is AminoMsgDelegate;
+/** Performs a redelegation from a delegate and source validator to a destination validator */
+export interface AminoMsgBeginRedelegate extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgBeginRedelegate";
+    readonly value: {
+        /** Bech32 encoded delegator address */
+        readonly delegator_address: string;
+        /** Bech32 encoded source validator address */
+        readonly validator_src_address: string;
+        /** Bech32 encoded destination validator address */
+        readonly validator_dst_address: string;
+        readonly amount: Coin;
+    };
+}
+export declare function isAminoMsgBeginRedelegate(msg: AminoMsg): msg is AminoMsgBeginRedelegate;
+/** Performs an undelegation from a delegate and a validator */
+export interface AminoMsgUndelegate extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgUndelegate";
+    readonly value: {
+        /** Bech32 encoded delegator address */
+        readonly delegator_address: string;
+        /** Bech32 encoded validator address */
+        readonly validator_address: string;
+        readonly amount: Coin;
+    };
+}
+export declare function isAminoMsgUndelegate(msg: AminoMsg): msg is AminoMsgUndelegate;
+interface AminoHeight {
+    /** 0 values must be omitted (https://github.com/cosmos/cosmos-sdk/blob/v0.42.7/x/ibc/core/02-client/types/client.pb.go#L252). */
+    readonly revision_number?: string;
+    /** 0 values must be omitted (https://github.com/cosmos/cosmos-sdk/blob/v0.42.7/x/ibc/core/02-client/types/client.pb.go#L254). */
+    readonly revision_height?: string;
+}
+/** Transfers fungible tokens (i.e Coins) between ICS20 enabled chains */
+export interface AminoMsgTransfer extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgTransfer";
+    readonly value: {
+        readonly source_port: string;
+        readonly source_channel: string;
+        readonly token?: Coin;
+        /** Bech32 account address */
+        readonly sender: string;
+        /** Bech32 account address */
+        readonly receiver: string;
+        /**
+         * The timeout as a (revision_number, revision_height) pair.
+         *
+         * This fied is is non-optional (https://github.com/cosmos/cosmos-sdk/blob/v0.42.7/x/ibc/applications/transfer/types/tx.pb.go#L49).
+         * In order to not set the timeout height, set it to {}.
+         */
+        readonly timeout_height: AminoHeight;
+        /**
+         * Timeout timestamp (in nanoseconds). The timeout is disabled when set to 0.
+         *
+         * 0 values must be omitted (https://github.com/cosmos/cosmos-sdk/blob/v0.42.7/x/ibc/applications/transfer/types/tx.pb.go#L52).
+         */
+        readonly timeout_timestamp?: string;
+    };
+}
+export declare function isAminoMsgTransfer(msg: AminoMsg): msg is AminoMsgTransfer;
+export {};