@firmachain/firma-js 0.2.37 → 0.2.40

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

@@ -0,0 +1,79 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonTxClient = void 0;
+var proto_signing_1 = require("@cosmjs/proto-signing");
+var tx_1 = require("cosmjs-types/cosmos/bank/v1beta1/tx");
+var tx_2 = require("cosmjs-types/cosmos/distribution/v1beta1/tx");
+var tx_3 = require("cosmjs-types/cosmos/gov/v1beta1/tx");
+var tx_4 = require("cosmjs-types/cosmos/staking/v1beta1/tx");
+var tx_5 = require("cosmjs-types/cosmwasm/wasm/v1/tx");
+var AuthzTxTypes_1 = require("../authz/AuthzTxTypes");
+var ContractTxTypes_1 = require("../contract/ContractTxTypes");
+var FeeGrantTxTypes_1 = require("../feegrant/FeeGrantTxTypes");
+var NftTxTypes_1 = require("../nft/NftTxTypes");
+var TokenTxTypes_1 = require("../token/TokenTxTypes");
+var ITxClient_1 = require("./ITxClient");
+var types = [
+    ["/cosmos.authz.v1beta1.MsgExec", AuthzTxTypes_1.MsgExec],
+    ["/cosmos.authz.v1beta1.MsgGrant", AuthzTxTypes_1.MsgGrant],
+    ["/cosmos.authz.v1beta1.MsgRevoke", AuthzTxTypes_1.MsgRevoke],
+    ["/cosmos.bank.v1beta1.MsgSend", tx_1.MsgSend],
+    ["/cosmos.bank.v1beta1.MsgMultiSend", tx_1.MsgMultiSend],
+    ["/firmachain.firmachain.contract.MsgCreateContractFile", ContractTxTypes_1.MsgCreateContractFile],
+    ["/firmachain.firmachain.contract.MsgAddContractLog", ContractTxTypes_1.MsgAddContractLog],
+    ["/cosmwasm.wasm.v1.MsgStoreCode", tx_5.MsgStoreCode],
+    ["/cosmwasm.wasm.v1.MsgInstantiateContract", tx_5.MsgInstantiateContract],
+    ["/cosmwasm.wasm.v1.MsgExecuteContract", tx_5.MsgExecuteContract],
+    ["/cosmwasm.wasm.v1.MsgUpdateAdmin", tx_5.MsgUpdateAdmin],
+    ["/cosmwasm.wasm.v1.MsgClearAdmin", tx_5.MsgClearAdmin],
+    ["/cosmwasm.wasm.v1.MsgMigrateContract", tx_5.MsgMigrateContract],
+    ["/cosmos.distribution.v1beta1.MsgFundCommunityPool", tx_2.MsgFundCommunityPool],
+    ["/cosmos.distribution.v1beta1.MsgSetWithdrawAddress", tx_2.MsgSetWithdrawAddress],
+    ["/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward", tx_2.MsgWithdrawDelegatorReward],
+    ["/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission", tx_2.MsgWithdrawValidatorCommission],
+    ["/cosmos.feegrant.v1beta1.MsgGrantAllowance", FeeGrantTxTypes_1.MsgGrantAllowance],
+    ["/cosmos.feegrant.v1beta1.MsgRevokeAllowance", FeeGrantTxTypes_1.MsgRevokeAllowance],
+    ["/cosmos.gov.v1beta1.MsgDeposit", tx_3.MsgDeposit],
+    ["/cosmos.gov.v1beta1.MsgSubmitProposal", tx_3.MsgSubmitProposal],
+    ["/cosmos.gov.v1beta1.MsgVote", tx_3.MsgVote],
+    ["/ibc.applications.transfer.v1.MsgTransfer", NftTxTypes_1.MsgTransfer],
+    ["/firmachain.firmachain.nft.MsgTransfer", NftTxTypes_1.MsgTransfer],
+    ["/firmachain.firmachain.nft.MsgMint", NftTxTypes_1.MsgMint],
+    ["/firmachain.firmachain.nft.MsgBurn", NftTxTypes_1.MsgBurn],
+    ["/cosmos.staking.v1beta1.MsgDelegate", tx_4.MsgDelegate],
+    ["/cosmos.staking.v1beta1.MsgUndelegate", tx_4.MsgUndelegate],
+    ["/cosmos.staking.v1beta1.MsgBeginRedelegate", tx_4.MsgBeginRedelegate],
+    ["/cosmos.staking.v1beta1.MsgEditValidator", tx_4.MsgEditValidator],
+    ["/cosmos.staking.v1beta1.MsgCreateValidator", tx_4.MsgCreateValidator],
+    ["/firmachain.firmachain.token.MsgCreateToken", TokenTxTypes_1.MsgCreateToken],
+    ["/firmachain.firmachain.token.MsgUpdateTokenURI", TokenTxTypes_1.MsgUpdateTokenURI],
+    ["/firmachain.firmachain.token.MsgMint", NftTxTypes_1.MsgMint],
+    ["/firmachain.firmachain.token.MsgBurn", NftTxTypes_1.MsgBurn]
+];
+var registry = new proto_signing_1.Registry(types);
+var CommonTxClient = /** @class */ (function (_super) {
+    __extends(CommonTxClient, _super);
+    function CommonTxClient(wallet, address) {
+        return _super.call(this, wallet, address, registry) || this;
+    }
+    CommonTxClient.getRegistry = function () {
+        return registry;
+    };
+    return CommonTxClient;
+}(ITxClient_1.ITxClient));
+exports.CommonTxClient = CommonTxClient;

package/dist/sdk/firmachain/common/ITxClient.d.ts

@@ -0,0 +1,18 @@
+import { Registry, EncodeObject } from "@cosmjs/proto-signing";
+import { SignAndBroadcastOptions } from ".";
+import { SignDoc, TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { TxRawExt } from "./signingstargateclient";
+import { BroadcastTxResponse } from "./stargateclient";
+import { FirmaWalletService } from "../../FirmaWalletService";
+export declare class ITxClient {
+    private readonly wallet;
+    private readonly serverUrl;
+    private readonly registry;
+    private rawWallet;
+    constructor(wallet: FirmaWalletService, serverUrl: string, registry: Registry);
+    getRegistry(): Registry;
+    sign(msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions): Promise<TxRaw>;
+    broadcast(txRaw: TxRaw): Promise<BroadcastTxResponse>;
+    signAndBroadcast(msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions): Promise<BroadcastTxResponse>;
+    signDirectForSignDoc(signerAddress: string, signDoc: SignDoc): Promise<TxRawExt>;
+}

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

@@ -0,0 +1,117 @@
+"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.ITxClient = void 0;
+var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+var signingstargateclient_1 = require("./signingstargateclient");
+var ITxClient = /** @class */ (function () {
+    function ITxClient(wallet, serverUrl, registry) {
+        this.wallet = wallet;
+        this.serverUrl = serverUrl;
+        this.registry = registry;
+        this.rawWallet = wallet.getRawWallet();
+    }
+    ITxClient.prototype.getRegistry = function () { return this.registry; };
+    ITxClient.prototype.sign = function (msgs, _a) {
+        var fee = _a.fee, memo = _a.memo;
+        return __awaiter(this, void 0, void 0, function () {
+            var client, address;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.wallet.isLedger()) return [3 /*break*/, 1];
+                        return [2 /*return*/, this.wallet.signLedger(msgs, { fee: fee, memo: memo }, this.registry)];
+                    case 1: return [4 /*yield*/, signingstargateclient_1.SigningStargateClient.connectWithSigner(this.serverUrl, this.rawWallet, this.registry)];
+                    case 2:
+                        client = _b.sent();
+                        return [4 /*yield*/, this.rawWallet.getAccounts()];
+                    case 3:
+                        address = (_b.sent())[0].address;
+                        return [4 /*yield*/, client.sign(address, msgs, fee, memo)];
+                    case 4: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    ITxClient.prototype.broadcast = function (txRaw) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client, txBytes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, signingstargateclient_1.SigningStargateClient.connectWithSigner(this.serverUrl, this.rawWallet, this.registry)];
+                    case 1:
+                        client = _a.sent();
+                        txBytes = tx_1.TxRaw.encode(txRaw).finish();
+                        return [4 /*yield*/, client.broadcastTx(txBytes)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    ITxClient.prototype.signAndBroadcast = function (msgs, _a) {
+        var fee = _a.fee, memo = _a.memo;
+        return __awaiter(this, void 0, void 0, function () {
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = this.broadcast;
+                        return [4 /*yield*/, this.sign(msgs, { fee: fee, memo: memo })];
+                    case 1: return [4 /*yield*/, _b.apply(this, [_c.sent()])];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    ITxClient.prototype.signDirectForSignDoc = function (signerAddress, signDoc) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, signingstargateclient_1.SigningStargateClient.connectWithSigner(this.serverUrl, this.rawWallet, this.registry)];
+                    case 1:
+                        client = _a.sent();
+                        return [4 /*yield*/, client.signDirectForSignDoc(signerAddress, signDoc)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return ITxClient;
+}());
+exports.ITxClient = ITxClient;

package/dist/sdk/firmachain/common/LedgerSigningStargateClient.d.ts

@@ -0,0 +1,27 @@
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { Account } from "./accounts";
+import { StargateClient } from "./stargateclient";
+export interface SignerData {
+    readonly account_number: string;
+    readonly sequence: string;
+    readonly chain_id: string;
+}
+export interface SequenceResponse {
+    readonly account_number: string;
+    readonly sequence: string;
+}
+export declare class LedgerSigningStargateClient extends StargateClient {
+    private chainId;
+    private static _endpoint;
+    static connectWithSigner(endpoint: string): Promise<LedgerSigningStargateClient>;
+    protected constructor(tmClient: Tendermint34Client);
+    getSignerData(address: string): Promise<SignerData>;
+    getChainId(): Promise<string>;
+    /**
+   * 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.
+   */
+    private toAccAddress;
+    getAccount(address: string): Promise<Account | undefined>;
+}

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

@@ -0,0 +1,165 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerSigningStargateClient = void 0;
+var encoding_1 = require("@cosmjs/encoding");
+var tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+var accounts_1 = require("./accounts");
+var stargateclient_1 = require("./stargateclient");
+var axios_1 = __importDefault(require("axios"));
+var any_1 = require("../google/protobuf/any");
+var LedgerSigningStargateClient = /** @class */ (function (_super) {
+    __extends(LedgerSigningStargateClient, _super);
+    function LedgerSigningStargateClient(tmClient) {
+        return _super.call(this, tmClient) || this;
+    }
+    LedgerSigningStargateClient.connectWithSigner = function (endpoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tmClient;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._endpoint = endpoint;
+                        return [4 /*yield*/, tendermint_rpc_1.Tendermint34Client.connect(endpoint)];
+                    case 1:
+                        tmClient = _a.sent();
+                        return [2 /*return*/, new LedgerSigningStargateClient(tmClient)];
+                }
+            });
+        });
+    };
+    LedgerSigningStargateClient.prototype.getSignerData = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chainID, account;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getChainId()];
+                    case 1:
+                        chainID = _a.sent();
+                        return [4 /*yield*/, this.getAccount(address)];
+                    case 2:
+                        account = _a.sent();
+                        if (account == null)
+                            throw new Error("account is null");
+                        return [2 /*return*/, { account_number: account.accountNumber.toString(), sequence: account.sequence.toString(), chain_id: chainID }];
+                }
+            });
+        });
+    };
+    LedgerSigningStargateClient.prototype.getChainId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var response, chainId;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.chainId) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.forceGetTmClient().status()];
+                    case 1:
+                        response = _a.sent();
+                        chainId = response.nodeInfo.network;
+                        if (!chainId)
+                            throw new Error("Chain ID must not be empty");
+                        this.chainId = chainId;
+                        _a.label = 2;
+                    case 2: return [2 /*return*/, this.chainId];
+                }
+            });
+        });
+    };
+    /**
+   * 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.
+   */
+    LedgerSigningStargateClient.prototype.toAccAddress = function (address) {
+        return encoding_1.Bech32.decode(address).data;
+    };
+    LedgerSigningStargateClient.prototype.getAccount = function (address) {
+        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) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        accAddress = this.toAccAddress(address);
+                        hexAccAddress = "0x01".concat(Buffer.from(accAddress).toString("hex"));
+                        axios = axios_1.default.create({
+                            baseURL: LedgerSigningStargateClient._endpoint,
+                            headers: {
+                                Accept: "application/json",
+                            },
+                            timeout: 15000
+                        });
+                        path = "/abci_query?path=\"/store/acc/key\"";
+                        return [4 /*yield*/, axios.get(path, { params: { data: hexAccAddress } })];
+                    case 1:
+                        result = _a.sent();
+                        finalData = result.data.result.response.value;
+                        account = any_1.Any.decode(Buffer.from(finalData, "base64"));
+                        finalAccount = (0, accounts_1.accountFromAny)(account);
+                        return [2 /*return*/, finalAccount];
+                    case 2:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, undefined];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LedgerSigningStargateClient._endpoint = "";
+    return LedgerSigningStargateClient;
+}(stargateclient_1.StargateClient));
+exports.LedgerSigningStargateClient = LedgerSigningStargateClient;

package/dist/sdk/firmachain/common/LedgerWallet.d.ts

@@ -0,0 +1,14 @@
+import { EncodeObject, Registry } from "@cosmjs/proto-signing";
+import { TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { SignAndBroadcastOptions } from "../common";
+export interface LedgerWalletInterface {
+    getAddress(): Promise<string>;
+    sign(message: string): Promise<Uint8Array>;
+    getPublicKey(): Promise<Uint8Array>;
+    getAddressAndPublicKey(): Promise<{
+        address: string;
+        publicKey: Uint8Array;
+    }>;
+    showAddressOnDevice(): Promise<void>;
+}
+export declare function signFromLedger(ledger: LedgerWalletInterface, messages: EncodeObject[], option: SignAndBroadcastOptions, registry: Registry): Promise<TxRaw>;

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

@@ -0,0 +1,151 @@
+"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 };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signFromLedger = void 0;
+var proto_signing_1 = require("@cosmjs/proto-signing");
+var tx_1 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+var long_1 = __importDefault(require("long"));
+var math_1 = require("@cosmjs/math");
+var encoding_1 = require("@cosmjs/encoding");
+var aminotypes_1 = require("../amino/aminotypes");
+var signdoc_1 = require("../amino/signdoc");
+var encoding_2 = require("../amino/encoding");
+var signdoc_2 = require("../amino/signdoc");
+var encoding_3 = require("@cosmjs/encoding");
+var signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
+var tx_2 = require("cosmjs-types/cosmos/tx/v1beta1/tx");
+var FirmaUtil_1 = require("../../FirmaUtil");
+function makeSignerInfos(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),
+        });
+    });
+}
+function makeAuthInfoBytes(signers, feeAmount, gasLimit, granter, signMode) {
+    if (signMode === void 0) { signMode = signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON; }
+    var authInfo = {
+        signerInfos: makeSignerInfos(signers, signMode),
+        fee: {
+            amount: __spreadArray([], __read(feeAmount), false),
+            gasLimit: long_1.default.fromNumber(gasLimit),
+            granter: granter,
+        },
+    };
+    return tx_1.AuthInfo.encode(tx_1.AuthInfo.fromPartial(authInfo)).finish();
+}
+function signFromLedger(ledger, messages, option, registry) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, address, publicKey, signerData, pubkey, aminoTypes, msgs, chainId, accountNumber, sequence, memo, fee, signDoc, signMessage, ledgerSignature, signedTxBody, signedTxBodyEncodeObject, signedTxBodyBytes, signedGasLimit, signedAuthInfoBytes, txRaw;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, ledger.getAddressAndPublicKey()];
+                case 1:
+                    _a = _b.sent(), address = _a.address, publicKey = _a.publicKey;
+                    return [4 /*yield*/, FirmaUtil_1.FirmaUtil.getSignerDataForLedger(address)];
+                case 2:
+                    signerData = _b.sent();
+                    pubkey = (0, proto_signing_1.encodePubkey)((0, encoding_2.encodeSecp256k1Pubkey)(publicKey));
+                    aminoTypes = new aminotypes_1.AminoTypes({});
+                    msgs = messages.map(function (msg) { return aminoTypes.toAmino(msg); });
+                    chainId = signerData.chain_id;
+                    accountNumber = Number.parseInt(signerData.account_number);
+                    sequence = Number.parseInt(signerData.sequence);
+                    memo = option.memo;
+                    fee = { amount: option.fee.amount, gas: option.fee.gas };
+                    signDoc = (0, signdoc_2.makeSignDoc)(msgs, fee, chainId, memo, accountNumber, sequence);
+                    signMessage = (0, signdoc_1.serializeSignDoc)(signDoc);
+                    return [4 /*yield*/, ledger.sign((0, encoding_3.fromUtf8)(signMessage))];
+                case 3:
+                    ledgerSignature = _b.sent();
+                    ;
+                    signedTxBody = {
+                        messages: signDoc.msgs.map(function (msg) { return aminoTypes.fromAmino(msg); }),
+                        memo: memo,
+                    };
+                    signedTxBodyEncodeObject = {
+                        typeUrl: "/cosmos.tx.v1beta1.TxBody",
+                        value: signedTxBody,
+                    };
+                    signedTxBodyBytes = registry.encode(signedTxBodyEncodeObject);
+                    signedGasLimit = math_1.Int53.fromString(option.fee.gas).toNumber();
+                    signedAuthInfoBytes = makeAuthInfoBytes([{ pubkey: pubkey, sequence: sequence }], option.fee.amount, signedGasLimit, option.fee.granter, signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON);
+                    txRaw = tx_2.TxRaw.fromPartial({
+                        bodyBytes: signedTxBodyBytes,
+                        authInfoBytes: signedAuthInfoBytes,
+                        signatures: [(0, encoding_1.fromBase64)(Buffer.from(ledgerSignature).toString('base64'))],
+                    });
+                    return [2 /*return*/, txRaw];
+            }
+        });
+    });
+}
+exports.signFromLedger = signFromLedger;

package/dist/sdk/firmachain/common/QueryCommon.d.ts

@@ -0,0 +1,4 @@
+export interface Pagination {
+    next_key: string;
+    total: number;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/firmachain/common/TendermintQueryClient.d.ts

@@ -0,0 +1,42 @@
+export interface ChainSyncInfo {
+    latest_block_hash: string;
+    latest_app_hash: string;
+    latest_block_height: string;
+    latest_block_time: string;
+    earliest_block_hash: string;
+    earliest_app_hash: string;
+    earliest_block_height: string;
+    earliest_block_time: string;
+    catching_up: boolean;
+}
+export interface TransactionEvent {
+    type: string;
+    attributes: {
+        key: string;
+        value: string;
+        index: boolean;
+    }[];
+}
+export interface TransactionHash {
+    hash: string;
+    height: string;
+    index: number;
+    tx_result: {
+        code: number;
+        data: string;
+        log: string;
+        info: string;
+        gas_wanted: string;
+        gas_used: string;
+        events: TransactionEvent[];
+        codespace: string;
+    };
+    tx: string;
+}
+export declare class TendermintQueryClient {
+    private readonly axios;
+    constructor(baseUrl: string);
+    queryEstimateGas(hexTx: string): Promise<number>;
+    queryChainSyncInfo(): Promise<ChainSyncInfo>;
+    queryTransactionHash(txHash: string): Promise<TransactionHash>;
+}