@firmachain/firma-js 0.2.64 → 0.3.1

package/dist/sdk/firmachain/common/signingstargateclient.js

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -75,78 +86,316 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SigningStargateClient = void 0;
+exports.SigningStargateClient = exports.isMsgSignData = exports.createDefaultAminoConverters = exports.defaultRegistryTypes = void 0;
+var amino_1 = require("@cosmjs/amino");
+var crypto_1 = require("@cosmjs/crypto");
 var encoding_1 = require("@cosmjs/encoding");
-var encoding_2 = require("@cosmjs/encoding");
+var math_1 = require("@cosmjs/math");
 var proto_signing_1 = require("@cosmjs/proto-signing");
 var tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+var utils_1 = require("@cosmjs/utils");
+var coin_1 = require("cosmjs-types/cosmos/base/v1beta1/coin");
+var tx_1 = require("cosmjs-types/cosmos/distribution/v1beta1/tx");
+var tx_2 = require("cosmjs-types/cosmos/staking/v1beta1/tx");
 var signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
-var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
-var accounts_1 = require("./accounts");
+var tx_3 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+var tx_4 = require("cosmjs-types/ibc/applications/transfer/v1/tx");
+var fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+var aminotypes_1 = require("./aminotypes");
+var fee_1 = require("./fee");
+var modules_1 = require("./modules");
+var modules_2 = require("./modules");
 var stargateclient_1 = require("./stargateclient");
-var axios_1 = __importDefault(require("axios"));
-var math_1 = require("@cosmjs/math");
-var any_1 = require("../google/protobuf/any");
-var long_1 = __importDefault(require("long"));
-var encoding_3 = require("../amino/encoding");
+var FirmaUtil_1 = require("../../FirmaUtil");
+exports.defaultRegistryTypes = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+    ["/cosmos.base.v1beta1.Coin", coin_1.Coin]
+], __read(modules_1.authzTypes)), __read(modules_1.bankTypes)), __read(modules_1.distributionTypes)), __read(modules_1.feegrantTypes)), __read(modules_1.govTypes)), __read(modules_1.groupTypes)), __read(modules_1.stakingTypes)), __read(modules_1.ibcTypes)), __read(modules_1.vestingTypes));
+function createDefaultAminoConverters() {
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({}, modules_2.createAuthzAminoConverters()), modules_2.createBankAminoConverters()), modules_2.createDistributionAminoConverters()), modules_2.createGovAminoConverters()), modules_2.createStakingAminoConverters()), modules_2.createIbcAminoConverters()), modules_2.createFeegrantAminoConverters()), modules_2.createVestingAminoConverters());
+}
+exports.createDefaultAminoConverters = createDefaultAminoConverters;
+function isMsgSignData(msg) {
+    var castedMsg = msg;
+    if (castedMsg.type !== "sign/MsgSignData")
+        return false;
+    if (!utils_1.isNonNullObject(castedMsg.value))
+        return false;
+    if (typeof castedMsg.value.signer !== "string")
+        return false;
+    if (typeof castedMsg.value.data !== "string")
+        return false;
+    return true;
+}
+exports.isMsgSignData = isMsgSignData;
 var SigningStargateClient = /** @class */ (function (_super) {
     __extends(SigningStargateClient, _super);
-    function SigningStargateClient(tmClient, signer, registry) {
-        var _this = _super.call(this, tmClient) || this;
+    function SigningStargateClient(cometClient, signer, options) {
+        var _this = _super.call(this, cometClient, options) || this;
+        // Starting with Cosmos SDK 0.47, we see many cases in which 1.3 is not enough anymore
+        // E.g. https://github.com/cosmos/cosmos-sdk/issues/16020
+        _this.defaultGasMultiplier = 1.4;
+        var _a = options.registry, registry = _a === void 0 ? new proto_signing_1.Registry(exports.defaultRegistryTypes) : _a, _b = options.aminoTypes, aminoTypes = _b === void 0 ? new aminotypes_1.AminoTypes(createDefaultAminoConverters()) : _b;
         _this.registry = registry;
+        _this.aminoTypes = aminoTypes;
         _this.signer = signer;
+        _this.broadcastTimeoutMs = options.broadcastTimeoutMs;
+        _this.broadcastPollIntervalMs = options.broadcastPollIntervalMs;
+        _this.gasPrice = options.gasPrice;
         return _this;
     }
-    SigningStargateClient.prototype.getSigner = function () {
-        return this.signer;
+    /**
+     * Creates an instance by connecting to the given CometBFT RPC endpoint.
+     *
+     * This uses auto-detection to decide between a CometBFT 0.38, Tendermint 0.37 and 0.34 client.
+     * To set the Comet client explicitly, use `createWithSigner`.
+     */
+    SigningStargateClient.connectWithSigner = function (endpoint, signer, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var cometClient;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, tendermint_rpc_1.connectComet(endpoint)];
+                    case 1:
+                        cometClient = _a.sent();
+                        return [2 /*return*/, SigningStargateClient.createWithSigner(cometClient, signer, options)];
+                }
+            });
+        });
+    };
+    /**
+     * Creates an instance from a manually created Comet client.
+     * Use this to use `Comet38Client` or `Tendermint37Client` instead of `Tendermint34Client`.
+     */
+    SigningStargateClient.createWithSigner = function (cometClient, signer, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new SigningStargateClient(cometClient, signer, options)];
+            });
+        });
+    };
+    /**
+     * Creates a client in offline mode.
+     *
+     * This should only be used in niche cases where you know exactly what you're doing,
+     * e.g. when building an offline signing application.
+     *
+     * When you try to use online functionality with such a signer, an
+     * exception will be raised.
+     */
+    SigningStargateClient.offline = function (signer, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new SigningStargateClient(undefined, signer, options)];
+            });
+        });
+    };
+    SigningStargateClient.prototype.simulate = function (signerAddress, messages, memo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var anyMsgs, accountFromSigner, pubkey, sequence, gasInfo;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        anyMsgs = messages.map(function (m) { return _this.registry.encodeAsAny(m); });
+                        return [4 /*yield*/, this.signer.getAccounts()];
+                    case 1:
+                        accountFromSigner = (_a.sent()).find(function (account) { return account.address === signerAddress; });
+                        if (!accountFromSigner) {
+                            throw new Error("Failed to retrieve account from signer");
+                        }
+                        pubkey = amino_1.encodeSecp256k1Pubkey(accountFromSigner.pubkey);
+                        return [4 /*yield*/, this.getSequence(signerAddress)];
+                    case 2:
+                        sequence = (_a.sent()).sequence;
+                        return [4 /*yield*/, this.forceGetQueryClient().tx.simulate(anyMsgs, memo, pubkey, sequence)];
+                    case 3:
+                        gasInfo = (_a.sent()).gasInfo;
+                        utils_1.assertDefined(gasInfo);
+                        return [2 /*return*/, math_1.Uint53.fromString(gasInfo.gasUsed.toString()).toNumber()];
+                }
+            });
+        });
+    };
+    SigningStargateClient.prototype.sendTokens = function (senderAddress, recipientAddress, amount, fee, memo) {
+        if (memo === void 0) { memo = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var sendMsg;
+            return __generator(this, function (_a) {
+                sendMsg = {
+                    typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+                    value: {
+                        fromAddress: senderAddress,
+                        toAddress: recipientAddress,
+                        amount: __spreadArray([], __read(amount)),
+                    },
+                };
+                return [2 /*return*/, this.signAndBroadcast(senderAddress, [sendMsg], fee, memo)];
+            });
+        });
+    };
+    SigningStargateClient.prototype.delegateTokens = function (delegatorAddress, validatorAddress, amount, fee, memo) {
+        if (memo === void 0) { memo = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var delegateMsg;
+            return __generator(this, function (_a) {
+                delegateMsg = {
+                    typeUrl: "/cosmos.staking.v1beta1.MsgDelegate",
+                    value: tx_2.MsgDelegate.fromPartial({
+                        delegatorAddress: delegatorAddress,
+                        validatorAddress: validatorAddress,
+                        amount: amount,
+                    }),
+                };
+                return [2 /*return*/, this.signAndBroadcast(delegatorAddress, [delegateMsg], fee, memo)];
+            });
+        });
+    };
+    SigningStargateClient.prototype.undelegateTokens = function (delegatorAddress, validatorAddress, amount, fee, memo) {
+        if (memo === void 0) { memo = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var undelegateMsg;
+            return __generator(this, function (_a) {
+                undelegateMsg = {
+                    typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate",
+                    value: tx_2.MsgUndelegate.fromPartial({
+                        delegatorAddress: delegatorAddress,
+                        validatorAddress: validatorAddress,
+                        amount: amount,
+                    }),
+                };
+                return [2 /*return*/, this.signAndBroadcast(delegatorAddress, [undelegateMsg], fee, memo)];
+            });
+        });
+    };
+    SigningStargateClient.prototype.withdrawRewards = function (delegatorAddress, validatorAddress, fee, memo) {
+        if (memo === void 0) { memo = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var withdrawMsg;
+            return __generator(this, function (_a) {
+                withdrawMsg = {
+                    typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward",
+                    value: tx_1.MsgWithdrawDelegatorReward.fromPartial({
+                        delegatorAddress: delegatorAddress,
+                        validatorAddress: validatorAddress,
+                    }),
+                };
+                return [2 /*return*/, this.signAndBroadcast(delegatorAddress, [withdrawMsg], fee, memo)];
+            });
+        });
+    };
+    /**
+     * @deprecated This API does not support setting the memo field of `MsgTransfer` (only the transaction memo).
+     * We'll remove this method at some point because trying to wrap the various message types is a losing strategy.
+     * Please migrate to `signAndBroadcast` with an `MsgTransferEncodeObject` created in the caller code instead.
+     * @see https://github.com/cosmos/cosmjs/issues/1493
+     */
+    SigningStargateClient.prototype.sendIbcTokens = function (senderAddress, recipientAddress, transferAmount, sourcePort, sourceChannel, timeoutHeight, 
+    /** timeout in seconds */
+    timeoutTimestamp, fee, memo) {
+        if (memo === void 0) { memo = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var timeoutTimestampNanoseconds, transferMsg;
+            return __generator(this, function (_a) {
+                timeoutTimestampNanoseconds = timeoutTimestamp
+                    ? BigInt(timeoutTimestamp) * BigInt(1000000000)
+                    : undefined;
+                transferMsg = {
+                    typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
+                    value: tx_4.MsgTransfer.fromPartial({
+                        sourcePort: sourcePort,
+                        sourceChannel: sourceChannel,
+                        sender: senderAddress,
+                        receiver: recipientAddress,
+                        token: transferAmount,
+                        timeoutHeight: timeoutHeight,
+                        timeoutTimestamp: timeoutTimestampNanoseconds,
+                    }),
+                };
+                return [2 /*return*/, this.signAndBroadcast(senderAddress, [transferMsg], fee, memo)];
+            });
+        });
     };
-    SigningStargateClient.connectWithSigner = function (endpoint, signer, registry) {
+    SigningStargateClient.prototype.signAndBroadcast = function (signerAddress, messages, fee, memo, timeoutHeight) {
+        if (memo === void 0) { memo = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var tmClient;
+            var usedFee, gasEstimation, multiplier, txRaw, txBytes;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this._endpoint = endpoint;
-                        return [4 /*yield*/, tendermint_rpc_1.Tendermint34Client.connect(endpoint)];
+                        if (!(fee == "auto" || typeof fee === "number")) return [3 /*break*/, 2];
+                        utils_1.assertDefined(this.gasPrice, "Gas price must be set in the client options when auto gas is used.");
+                        return [4 /*yield*/, this.simulate(signerAddress, messages, memo)];
                     case 1:
-                        tmClient = _a.sent();
-                        return [2 /*return*/, new SigningStargateClient(tmClient, signer, registry)];
+                        gasEstimation = _a.sent();
+                        multiplier = typeof fee === "number" ? fee : this.defaultGasMultiplier;
+                        usedFee = fee_1.calculateFee(Math.round(gasEstimation * multiplier), this.gasPrice);
+                        return [3 /*break*/, 3];
+                    case 2:
+                        usedFee = fee;
+                        _a.label = 3;
+                    case 3: return [4 /*yield*/, this.sign(signerAddress, messages, usedFee, memo, undefined, timeoutHeight)];
+                    case 4:
+                        txRaw = _a.sent();
+                        txBytes = tx_3.TxRaw.encode(txRaw).finish();
+                        return [2 /*return*/, this.broadcastTx(txBytes, this.broadcastTimeoutMs, this.broadcastPollIntervalMs)];
                 }
             });
         });
     };
-    SigningStargateClient.prototype.signAndBroadcast = function (signerAddress, messages, fee, memo) {
+    /**
+     * This method is useful if you want to send a transaction in broadcast,
+     * without waiting for it to be placed inside a block, because for example
+     * I would like to receive the hash to later track the transaction with another tool.
+     * @returns Returns the hash of the transaction
+     */
+    SigningStargateClient.prototype.signAndBroadcastSync = function (signerAddress, messages, fee, memo, timeoutHeight) {
         if (memo === void 0) { memo = ""; }
         return __awaiter(this, void 0, void 0, function () {
-            var txRaw, txBytes;
+            var usedFee, gasEstimation, multiplier, txRaw, txBytes;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.sign(signerAddress, messages, fee, memo)];
+                    case 0:
+                        if (!(fee == "auto" || typeof fee === "number")) return [3 /*break*/, 2];
+                        utils_1.assertDefined(this.gasPrice, "Gas price must be set in the client options when auto gas is used.");
+                        return [4 /*yield*/, this.simulate(signerAddress, messages, memo)];
                     case 1:
+                        gasEstimation = _a.sent();
+                        multiplier = typeof fee === "number" ? fee : this.defaultGasMultiplier;
+                        usedFee = fee_1.calculateFee(Math.round(gasEstimation * multiplier), this.gasPrice);
+                        return [3 /*break*/, 3];
+                    case 2:
+                        usedFee = fee;
+                        _a.label = 3;
+                    case 3: return [4 /*yield*/, this.sign(signerAddress, messages, usedFee, memo, undefined, timeoutHeight)];
+                    case 4:
                         txRaw = _a.sent();
-                        txBytes = tx_1.TxRaw.encode(txRaw).finish();
-                        return [2 /*return*/, this.broadcastTx(txBytes)];
+                        txBytes = tx_3.TxRaw.encode(txRaw).finish();
+                        return [2 /*return*/, this.broadcastTxSync(txBytes)];
                 }
             });
         });
     };
     SigningStargateClient.makeSignDocForSend = function (signerAddress, pubkeyStr, messages, fee, memo, serverUrl, chainId, registry) {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, accountNumber, sequence, account, rawSecp256k1Pubkey, pubkey, txBodyEncodeObject, txBodyBytes, gasLimit, authInfoBytes;
+            var client, _a, accountNumber, sequence, account, rawSecp256k1Pubkey, pubkey, txBodyEncodeObject, txBodyBytes, gasLimit, feePayer, authInfoBytes;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0:
-                        SigningStargateClient._endpoint = serverUrl;
-                        return [4 /*yield*/, SigningStargateClient.getSequence(signerAddress)];
+                    case 0: return [4 /*yield*/, SigningStargateClient.connect(serverUrl)];
                     case 1:
-                        _a = _b.sent(), accountNumber = _a.accountNumber, sequence = _a.sequence;
-                        return [4 /*yield*/, SigningStargateClient.getAccount(signerAddress)];
+                        client = _b.sent();
+                        return [4 /*yield*/, client.getSequence(signerAddress)];
                     case 2:
+                        _a = _b.sent(), accountNumber = _a.accountNumber, sequence = _a.sequence;
+                        return [4 /*yield*/, client.getAccount(signerAddress)];
+                    case 3:
                         account = _b.sent();
                         if (account == null)
                             throw new Error("Failed to retrieve account from signer");
                         rawSecp256k1Pubkey = encoding_1.fromBase64(pubkeyStr);
-                        pubkey = proto_signing_1.encodePubkey(encoding_3.encodeSecp256k1Pubkey(rawSecp256k1Pubkey));
+                        pubkey = proto_signing_1.encodePubkey(amino_1.encodeSecp256k1Pubkey(rawSecp256k1Pubkey));
                         txBodyEncodeObject = {
                             typeUrl: "/cosmos.tx.v1beta1.TxBody",
                             value: {
@@ -156,13 +405,24 @@ var SigningStargateClient = /** @class */ (function (_super) {
                         };
                         txBodyBytes = registry.encode(txBodyEncodeObject);
                         gasLimit = math_1.Int53.fromString(fee.gas).toNumber();
-                        authInfoBytes = this.makeAuthInfoBytes([{ pubkey: pubkey, sequence: sequence }], fee.amount, gasLimit, fee.granter);
+                        feePayer = signerAddress;
+                        authInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey: pubkey, sequence: sequence }], fee.amount, gasLimit, fee.granter, feePayer);
                         return [2 /*return*/, proto_signing_1.makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber)];
                 }
             });
         });
     };
-    SigningStargateClient.prototype.sign = function (signerAddress, messages, fee, memo, explicitSignerData) {
+    /**
+     * Gets account number and sequence from the API, creates a sign doc,
+     * creates a single signature and assembles the signed transaction.
+     *
+     * The sign mode (SIGN_MODE_DIRECT or SIGN_MODE_LEGACY_AMINO_JSON) is determined by this client's signer.
+     *
+     * You can pass signer data (account number, sequence and chain ID) explicitly instead of querying them
+     * from the chain. This is needed when signing for a multisig account, but it also allows for offline signing
+     * (See the SigningStargateClient.offline constructor).
+     */
+    SigningStargateClient.prototype.sign = function (signerAddress, messages, fee, memo, explicitSignerData, timeoutHeight) {
         return __awaiter(this, void 0, void 0, function () {
             var signerData, _a, accountNumber, sequence, chainId;
             return __generator(this, function (_b) {
@@ -171,7 +431,7 @@ var SigningStargateClient = /** @class */ (function (_super) {
                         if (!explicitSignerData) return [3 /*break*/, 1];
                         signerData = explicitSignerData;
                         return [3 /*break*/, 4];
-                    case 1: return [4 /*yield*/, SigningStargateClient.getSequence(signerAddress)];
+                    case 1: return [4 /*yield*/, this.getSequence(signerAddress)];
                     case 2:
                         _a = _b.sent(), accountNumber = _a.accountNumber, sequence = _a.sequence;
                         return [4 /*yield*/, this.getChainId()];
@@ -183,7 +443,9 @@ var SigningStargateClient = /** @class */ (function (_super) {
                             chainId: chainId,
                         };
                         _b.label = 4;
-                    case 4: return [2 /*return*/, this.signDirect(signerAddress, messages, fee, memo, signerData)];
+                    case 4: return [2 /*return*/, proto_signing_1.isOfflineDirectSigner(this.signer)
+                            ? this.signDirect(signerAddress, messages, fee, memo, signerData, timeoutHeight)
+                            : this.signAmino(signerAddress, messages, fee, memo, signerData, timeoutHeight)];
                 }
             });
         });
@@ -195,7 +457,7 @@ var SigningStargateClient = /** @class */ (function (_super) {
                 switch (_a.label) {
                     case 0:
                         if (!!this.chainId) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.forceGetTmClient().status()];
+                        return [4 /*yield*/, this.forceGetCometClient().status()];
                     case 1:
                         response = _a.sent();
                         chainId = response.nodeInfo.network;
@@ -208,117 +470,81 @@ var SigningStargateClient = /** @class */ (function (_super) {
             });
         });
     };
-    /**
-   * Takes a bech32 encoded address and returns the data part. The prefix is ignored and discarded.
-   * This is called AccAddress in Cosmos SDK, which is basically an alias for raw binary data.
-   * The result is typically 20 bytes long but not restricted to that.
-   */
-    SigningStargateClient.toAccAddress = function (address) {
-        return encoding_2.Bech32.decode(address).data;
-    };
-    SigningStargateClient.getAccount = function (address) {
+    SigningStargateClient.prototype.signAmino = function (signerAddress, messages, fee, memo, _a, timeoutHeight) {
+        var accountNumber = _a.accountNumber, sequence = _a.sequence, chainId = _a.chainId;
         return __awaiter(this, void 0, void 0, function () {
-            var accAddress, hexAccAddress, axios, path, result, finalData, account, finalAccount, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            var accountFromSigner, pubkey, signMode, msgs, signDoc, _b, signature, signed, signedTxBody, signedTxBodyEncodeObject, signedTxBodyBytes, signedGasLimit, signedSequence, signedAuthInfoBytes;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        accAddress = this.toAccAddress(address);
-                        hexAccAddress = "0x01" + Buffer.from(accAddress).toString("hex");
-                        axios = axios_1.default.create({
-                            baseURL: SigningStargateClient._endpoint,
-                            headers: {
-                                Accept: "application/json",
-                            },
-                            timeout: 15000
-                        });
-                        path = "/abci_query?path=\"/store/acc/key\"";
-                        return [4 /*yield*/, axios.get(path, { params: { data: hexAccAddress } })];
+                        utils_1.assert(!proto_signing_1.isOfflineDirectSigner(this.signer));
+                        return [4 /*yield*/, this.signer.getAccounts()];
                     case 1:
-                        result = _a.sent();
-                        finalData = result.data.result.response.value;
-                        account = any_1.Any.decode(Buffer.from(finalData, "base64"));
-                        finalAccount = accounts_1.accountFromAny(account);
-                        return [2 /*return*/, finalAccount];
-                    case 2:
-                        error_1 = _a.sent();
-                        return [2 /*return*/, undefined];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SigningStargateClient.getSequence = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var account;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAccount(address)];
-                    case 1:
-                        account = _a.sent();
-                        if (!account) {
-                            throw new Error("Account does not exist on chain. Send some tokens there before trying to query sequence.");
+                        accountFromSigner = (_c.sent()).find(function (account) { return account.address === signerAddress; });
+                        if (!accountFromSigner) {
+                            throw new Error("Failed to retrieve account from signer");
                         }
-                        return [2 /*return*/, {
-                                accountNumber: account.accountNumber,
-                                sequence: account.sequence,
-                            }];
+                        pubkey = proto_signing_1.encodePubkey(amino_1.encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+                        signMode = signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
+                        msgs = messages.map(function (msg) { return _this.aminoTypes.toAmino(msg); });
+                        signDoc = amino_1.makeSignDoc(msgs, fee, chainId, memo, accountNumber, sequence, timeoutHeight);
+                        return [4 /*yield*/, this.signer.signAmino(signerAddress, signDoc)];
+                    case 2:
+                        _b = _c.sent(), signature = _b.signature, signed = _b.signed;
+                        signedTxBody = {
+                            messages: signed.msgs.map(function (msg) { return _this.aminoTypes.fromAmino(msg); }),
+                            memo: signed.memo,
+                            timeoutHeight: timeoutHeight,
+                        };
+                        signedTxBodyEncodeObject = {
+                            typeUrl: "/cosmos.tx.v1beta1.TxBody",
+                            value: signedTxBody,
+                        };
+                        signedTxBodyBytes = this.registry.encode(signedTxBodyEncodeObject);
+                        signedGasLimit = math_1.Int53.fromString(signed.fee.gas).toNumber();
+                        signedSequence = math_1.Int53.fromString(signed.sequence).toNumber();
+                        signedAuthInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey: pubkey, sequence: signedSequence }], signed.fee.amount, signedGasLimit, signed.fee.granter, signed.fee.payer, signMode);
+                        return [2 /*return*/, tx_3.TxRaw.fromPartial({
+                                bodyBytes: signedTxBodyBytes,
+                                authInfoBytes: signedAuthInfoBytes,
+                                signatures: [encoding_1.fromBase64(signature.signature)],
+                            })];
                 }
             });
         });
     };
-    SigningStargateClient.makeSignerInfos = function (signers, signMode) {
-        return signers.map(function (_a) {
-            var pubkey = _a.pubkey, sequence = _a.sequence;
-            return ({
-                publicKey: pubkey,
-                modeInfo: {
-                    single: { mode: signMode },
-                },
-                sequence: long_1.default.fromNumber(sequence),
-            });
-        });
-    };
-    SigningStargateClient.makeAuthInfoBytes = function (signers, feeAmount, gasLimit, granter, signMode) {
-        if (signMode === void 0) { signMode = signing_1.SignMode.SIGN_MODE_DIRECT; }
-        var authInfo = {
-            signerInfos: this.makeSignerInfos(signers, signMode),
-            fee: {
-                amount: __spreadArray([], __read(feeAmount)),
-                gasLimit: long_1.default.fromNumber(gasLimit),
-                granter: granter,
-            },
-        };
-        return tx_1.AuthInfo.encode(tx_1.AuthInfo.fromPartial(authInfo)).finish();
-    };
-    SigningStargateClient.prototype.signDirect = function (signerAddress, messages, fee, memo, _a) {
+    SigningStargateClient.prototype.signDirect = function (signerAddress, messages, fee, memo, _a, timeoutHeight) {
         var accountNumber = _a.accountNumber, sequence = _a.sequence, chainId = _a.chainId;
         return __awaiter(this, void 0, void 0, function () {
             var accountFromSigner, pubkey, txBodyEncodeObject, txBodyBytes, gasLimit, authInfoBytes, signDoc, _b, signature, signed;
             return __generator(this, function (_c) {
                 switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.getSigner().getAccounts()];
+                    case 0:
+                        utils_1.assert(proto_signing_1.isOfflineDirectSigner(this.signer));
+                        return [4 /*yield*/, this.signer.getAccounts()];
                     case 1:
                         accountFromSigner = (_c.sent()).find(function (account) { return account.address === signerAddress; });
                         if (!accountFromSigner) {
                             throw new Error("Failed to retrieve account from signer");
                         }
-                        pubkey = proto_signing_1.encodePubkey(encoding_3.encodeSecp256k1Pubkey(accountFromSigner.pubkey));
+                        pubkey = proto_signing_1.encodePubkey(amino_1.encodeSecp256k1Pubkey(accountFromSigner.pubkey));
                         txBodyEncodeObject = {
                             typeUrl: "/cosmos.tx.v1beta1.TxBody",
                             value: {
                                 messages: messages,
                                 memo: memo,
+                                timeoutHeight: timeoutHeight,
                             },
                         };
                         txBodyBytes = this.registry.encode(txBodyEncodeObject);
                         gasLimit = math_1.Int53.fromString(fee.gas).toNumber();
-                        authInfoBytes = SigningStargateClient.makeAuthInfoBytes([{ pubkey: pubkey, sequence: sequence }], fee.amount, gasLimit, fee.granter);
+                        authInfoBytes = proto_signing_1.makeAuthInfoBytes([{ pubkey: pubkey, sequence: sequence }], fee.amount, gasLimit, fee.granter, fee.payer);
                         signDoc = proto_signing_1.makeSignDoc(txBodyBytes, authInfoBytes, chainId, accountNumber);
-                        return [4 /*yield*/, this.getSigner().signDirect(signerAddress, signDoc)];
+                        return [4 /*yield*/, this.signer.signDirect(signerAddress, signDoc)];
                     case 2:
                         _b = _c.sent(), signature = _b.signature, signed = _b.signed;
-                        return [2 /*return*/, tx_1.TxRaw.fromPartial({
+                        return [2 /*return*/, tx_3.TxRaw.fromPartial({
                                 bodyBytes: signed.bodyBytes,
                                 authInfoBytes: signed.authInfoBytes,
                                 signatures: [encoding_1.fromBase64(signature.signature)],
@@ -327,31 +553,122 @@ var SigningStargateClient = /** @class */ (function (_super) {
             });
         });
     };
-    SigningStargateClient.prototype.signDirectForSignDoc = function (signerAddress, signDoc) {
+    SigningStargateClient.experimentalAdr36Verify = function (data, checkMsg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var newSignature, signed, accountNumber, sequence, chainId, signedMessages, sourceMsg, signatures, signature, signBytes, prehashed, secpSignature, rawSecp256k1Pubkey, rawSignerAddress, ok;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        newSignature = amino_1.encodeSecp256k1Signature(FirmaUtil_1.FirmaUtil.base64ToArrayBuffer(data.pubkey), FirmaUtil_1.FirmaUtil.base64ToArrayBuffer(data.signature));
+                        signed = {
+                            fee: {
+                                gas: "0",
+                                amount: [],
+                            },
+                            msg: [{
+                                    type: data.type,
+                                    value: { signer: data.signer, data: data.data }
+                                }],
+                            signatures: [newSignature],
+                            memo: ""
+                        };
+                        // Restrictions from ADR-036
+                        if (signed.memo !== "")
+                            throw new Error("Memo must be empty.");
+                        if (signed.fee.gas !== "0")
+                            throw new Error("Fee gas must 0.");
+                        if (signed.fee.amount.length !== 0)
+                            throw new Error("Fee amount must be an empty array.");
+                        accountNumber = 0;
+                        sequence = 0;
+                        chainId = "";
+                        signedMessages = signed.msg;
+                        if (!signedMessages.every(isMsgSignData)) {
+                            throw new Error("Found message that is not the expected type.");
+                        }
+                        if (signedMessages.length === 0) {
+                            throw new Error("No message found. Without messages we cannot determine the signer address.");
+                        }
+                        sourceMsg = Buffer.from(signedMessages[0].value.data, 'base64').toString();
+                        if (sourceMsg !== checkMsg) {
+                            throw new Error("Different Msg error. source:" + sourceMsg + ", target:" + checkMsg);
+                        }
+                        signatures = signed.signatures;
+                        if (signatures.length !== 1)
+                            throw new Error("Must have exactly one signature to be supported.");
+                        signature = signatures[0];
+                        if (!amino_1.isSecp256k1Pubkey(signature.pub_key)) {
+                            throw new Error("Only secp256k1 signatures are supported.");
+                        }
+                        signBytes = amino_1.serializeSignDoc(amino_1.makeSignDoc(signed.msg, signed.fee, chainId, signed.memo, accountNumber, sequence));
+                        prehashed = crypto_1.sha256(signBytes);
+                        secpSignature = crypto_1.Secp256k1Signature.fromFixedLength(encoding_1.fromBase64(signature.signature));
+                        rawSecp256k1Pubkey = encoding_1.fromBase64(signature.pub_key.value);
+                        rawSignerAddress = amino_1.rawSecp256k1PubkeyToRawAddress(rawSecp256k1Pubkey);
+                        if (signedMessages.some(function (msg) { return !utils_1.arrayContentEquals(encoding_1.fromBech32(msg.value.signer).data, rawSignerAddress); })) {
+                            throw new Error("Found mismatch between signer in message and public key");
+                        }
+                        return [4 /*yield*/, crypto_1.Secp256k1.verifySignature(secpSignature, prehashed, rawSecp256k1Pubkey)];
+                    case 1:
+                        ok = _a.sent();
+                        return [2 /*return*/, ok];
+                }
+            });
+        });
+    };
+    SigningStargateClient.prototype.experimentalAdr36Sign = function (signerAddress, data) {
         return __awaiter(this, void 0, void 0, function () {
-            var accountFromSigner, _a, signature, signed, txRaw;
+            var accountNumber, sequence, chainId, fee, memo, datas, msgs, accountFromSigner, signDoc, _a, signature, signed, signatureResult, decodeData, jsonData;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getSigner().getAccounts()];
+                    case 0:
+                        accountNumber = 0;
+                        sequence = 0;
+                        chainId = "";
+                        fee = {
+                            gas: "0",
+                            amount: [],
+                            //granter: "" // added by DH
+                        };
+                        memo = "";
+                        datas = Array.isArray(data) ? data : [data];
+                        msgs = datas.map(function (d) { return ({
+                            type: "sign/MsgSignData",
+                            value: {
+                                signer: signerAddress,
+                                data: encoding_1.toBase64(d),
+                            },
+                        }); });
+                        return [4 /*yield*/, this.signer.getAccounts()];
                     case 1:
                         accountFromSigner = (_b.sent()).find(function (account) { return account.address === signerAddress; });
                         if (!accountFromSigner) {
                             throw new Error("Failed to retrieve account from signer");
                         }
-                        return [4 /*yield*/, this.getSigner().signDirect(signerAddress, signDoc)];
+                        if (!("signAmino" in this.signer)) {
+                            throw new Error("The signer does not support signAmino. Please use an OfflineAminoSigner instance.");
+                        }
+                        signDoc = amino_1.makeSignDoc(msgs, fee, chainId, memo, accountNumber, sequence);
+                        return [4 /*yield*/, this.signer.signAmino(signerAddress, signDoc)];
                     case 2:
                         _a = _b.sent(), signature = _a.signature, signed = _a.signed;
-                        txRaw = tx_1.TxRaw.fromPartial({
-                            bodyBytes: signed.bodyBytes,
-                            authInfoBytes: signed.authInfoBytes,
-                            signatures: [encoding_1.fromBase64(signature.signature)],
-                        });
-                        return [2 /*return*/, { txRaw: txRaw, signature: signature.signature }];
+                        if (!fast_deep_equal_1.default(signDoc, signed)) {
+                            throw new Error("The signed document differs from the signing instruction. This is not supported for ADR-036.");
+                        }
+                        signatureResult = amino_1.makeStdTx(signDoc, signature);
+                        decodeData = amino_1.decodeSignature(signatureResult.signatures[0]);
+                        jsonData = {
+                            type: "sign/MsgSignData",
+                            signer: signatureResult.msg[0].value.signer,
+                            data: signatureResult.msg[0].value.data,
+                            pubkey: FirmaUtil_1.FirmaUtil.arrayBufferToBase64(decodeData.pubkey),
+                            signature: FirmaUtil_1.FirmaUtil.arrayBufferToBase64(decodeData.signature)
+                        };
+                        return [2 /*return*/, jsonData];
                 }
             });
         });
     };
-    SigningStargateClient._endpoint = "";
     return SigningStargateClient;
 }(stargateclient_1.StargateClient));
 exports.SigningStargateClient = SigningStargateClient;