@firmachain/firma-js 0.2.64 → 0.3.0-beta1

package/dist/sdk/firmachain/common/modules/staking/aminomessages.js

@@ -0,0 +1,234 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStakingAminoConverters = exports.isAminoMsgCancelUnbondingDelegation = exports.isAminoMsgUndelegate = exports.isAminoMsgBeginRedelegate = exports.isAminoMsgDelegate = exports.isAminoMsgEditValidator = exports.isAminoMsgCreateValidator = exports.protoDecimalToJson = void 0;
+var math_1 = require("@cosmjs/math");
+var proto_signing_1 = require("@cosmjs/proto-signing");
+var utils_1 = require("@cosmjs/utils");
+function protoDecimalToJson(decimal) {
+    var parsed = math_1.Decimal.fromAtomics(decimal, 18);
+    var _a = __read(parsed.toString().split("."), 2), whole = _a[0], fractional = _a[1];
+    return whole + "." + (fractional !== null && fractional !== void 0 ? fractional : "").padEnd(18, "0");
+}
+exports.protoDecimalToJson = protoDecimalToJson;
+function jsonDecimalToProto(decimal) {
+    var parsed = math_1.Decimal.fromUserInput(decimal, 18);
+    return parsed.atomics;
+}
+function isAminoMsgCreateValidator(msg) {
+    return msg.type === "cosmos-sdk/MsgCreateValidator";
+}
+exports.isAminoMsgCreateValidator = isAminoMsgCreateValidator;
+function isAminoMsgEditValidator(msg) {
+    return msg.type === "cosmos-sdk/MsgEditValidator";
+}
+exports.isAminoMsgEditValidator = isAminoMsgEditValidator;
+function isAminoMsgDelegate(msg) {
+    return msg.type === "cosmos-sdk/MsgDelegate";
+}
+exports.isAminoMsgDelegate = isAminoMsgDelegate;
+function isAminoMsgBeginRedelegate(msg) {
+    return msg.type === "cosmos-sdk/MsgBeginRedelegate";
+}
+exports.isAminoMsgBeginRedelegate = isAminoMsgBeginRedelegate;
+function isAminoMsgUndelegate(msg) {
+    return msg.type === "cosmos-sdk/MsgUndelegate";
+}
+exports.isAminoMsgUndelegate = isAminoMsgUndelegate;
+function isAminoMsgCancelUnbondingDelegation(msg) {
+    return msg.type === "cosmos-sdk/MsgCancelUnbondingDelegation";
+}
+exports.isAminoMsgCancelUnbondingDelegation = isAminoMsgCancelUnbondingDelegation;
+function createStakingAminoConverters() {
+    return {
+        "/cosmos.staking.v1beta1.MsgBeginRedelegate": {
+            aminoType: "cosmos-sdk/MsgBeginRedelegate",
+            toAmino: function (_a) {
+                var delegatorAddress = _a.delegatorAddress, validatorSrcAddress = _a.validatorSrcAddress, validatorDstAddress = _a.validatorDstAddress, amount = _a.amount;
+                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                return {
+                    delegator_address: delegatorAddress,
+                    validator_src_address: validatorSrcAddress,
+                    validator_dst_address: validatorDstAddress,
+                    amount: amount,
+                };
+            },
+            fromAmino: function (_a) {
+                var delegator_address = _a.delegator_address, validator_src_address = _a.validator_src_address, validator_dst_address = _a.validator_dst_address, amount = _a.amount;
+                return ({
+                    delegatorAddress: delegator_address,
+                    validatorSrcAddress: validator_src_address,
+                    validatorDstAddress: validator_dst_address,
+                    amount: amount,
+                });
+            },
+        },
+        "/cosmos.staking.v1beta1.MsgCreateValidator": {
+            aminoType: "cosmos-sdk/MsgCreateValidator",
+            toAmino: function (_a) {
+                var description = _a.description, commission = _a.commission, minSelfDelegation = _a.minSelfDelegation, delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, pubkey = _a.pubkey, value = _a.value;
+                utils_1.assertDefinedAndNotNull(description, "missing description");
+                utils_1.assertDefinedAndNotNull(commission, "missing commission");
+                utils_1.assertDefinedAndNotNull(pubkey, "missing pubkey");
+                utils_1.assertDefinedAndNotNull(value, "missing value");
+                return {
+                    description: {
+                        moniker: description.moniker,
+                        identity: description.identity,
+                        website: description.website,
+                        security_contact: description.securityContact,
+                        details: description.details,
+                    },
+                    commission: {
+                        rate: protoDecimalToJson(commission.rate),
+                        max_rate: protoDecimalToJson(commission.maxRate),
+                        max_change_rate: protoDecimalToJson(commission.maxChangeRate),
+                    },
+                    min_self_delegation: minSelfDelegation,
+                    delegator_address: delegatorAddress,
+                    validator_address: validatorAddress,
+                    pubkey: proto_signing_1.decodePubkey(pubkey),
+                    value: value,
+                };
+            },
+            fromAmino: function (_a) {
+                var description = _a.description, commission = _a.commission, min_self_delegation = _a.min_self_delegation, delegator_address = _a.delegator_address, validator_address = _a.validator_address, pubkey = _a.pubkey, value = _a.value;
+                return {
+                    description: {
+                        moniker: description.moniker,
+                        identity: description.identity,
+                        website: description.website,
+                        securityContact: description.security_contact,
+                        details: description.details,
+                    },
+                    commission: {
+                        rate: jsonDecimalToProto(commission.rate),
+                        maxRate: jsonDecimalToProto(commission.max_rate),
+                        maxChangeRate: jsonDecimalToProto(commission.max_change_rate),
+                    },
+                    minSelfDelegation: min_self_delegation,
+                    delegatorAddress: delegator_address,
+                    validatorAddress: validator_address,
+                    pubkey: proto_signing_1.encodePubkey(pubkey),
+                    value: value,
+                };
+            },
+        },
+        "/cosmos.staking.v1beta1.MsgDelegate": {
+            aminoType: "cosmos-sdk/MsgDelegate",
+            toAmino: function (_a) {
+                var delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, amount = _a.amount;
+                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                return {
+                    delegator_address: delegatorAddress,
+                    validator_address: validatorAddress,
+                    amount: amount,
+                };
+            },
+            fromAmino: function (_a) {
+                var delegator_address = _a.delegator_address, validator_address = _a.validator_address, amount = _a.amount;
+                return ({
+                    delegatorAddress: delegator_address,
+                    validatorAddress: validator_address,
+                    amount: amount,
+                });
+            },
+        },
+        "/cosmos.staking.v1beta1.MsgEditValidator": {
+            aminoType: "cosmos-sdk/MsgEditValidator",
+            toAmino: function (_a) {
+                var description = _a.description, commissionRate = _a.commissionRate, minSelfDelegation = _a.minSelfDelegation, validatorAddress = _a.validatorAddress;
+                utils_1.assertDefinedAndNotNull(description, "missing description");
+                return {
+                    description: {
+                        moniker: description.moniker,
+                        identity: description.identity,
+                        website: description.website,
+                        security_contact: description.securityContact,
+                        details: description.details,
+                    },
+                    // empty string in the protobuf document means "do not change"
+                    commission_rate: commissionRate ? protoDecimalToJson(commissionRate) : undefined,
+                    // empty string in the protobuf document means "do not change"
+                    min_self_delegation: minSelfDelegation ? minSelfDelegation : undefined,
+                    validator_address: validatorAddress,
+                };
+            },
+            fromAmino: function (_a) {
+                var description = _a.description, commission_rate = _a.commission_rate, min_self_delegation = _a.min_self_delegation, validator_address = _a.validator_address;
+                return ({
+                    description: {
+                        moniker: description.moniker,
+                        identity: description.identity,
+                        website: description.website,
+                        securityContact: description.security_contact,
+                        details: description.details,
+                    },
+                    // empty string in the protobuf document means "do not change"
+                    commissionRate: commission_rate ? jsonDecimalToProto(commission_rate) : "",
+                    // empty string in the protobuf document means "do not change"
+                    minSelfDelegation: min_self_delegation !== null && min_self_delegation !== void 0 ? min_self_delegation : "",
+                    validatorAddress: validator_address,
+                });
+            },
+        },
+        "/cosmos.staking.v1beta1.MsgUndelegate": {
+            aminoType: "cosmos-sdk/MsgUndelegate",
+            toAmino: function (_a) {
+                var delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, amount = _a.amount;
+                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                return {
+                    delegator_address: delegatorAddress,
+                    validator_address: validatorAddress,
+                    amount: amount,
+                };
+            },
+            fromAmino: function (_a) {
+                var delegator_address = _a.delegator_address, validator_address = _a.validator_address, amount = _a.amount;
+                return ({
+                    delegatorAddress: delegator_address,
+                    validatorAddress: validator_address,
+                    amount: amount,
+                });
+            },
+        },
+        "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation": {
+            aminoType: "cosmos-sdk/MsgCancelUnbondingDelegation",
+            toAmino: function (_a) {
+                var delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress, amount = _a.amount, creationHeight = _a.creationHeight;
+                utils_1.assertDefinedAndNotNull(amount, "missing amount");
+                return {
+                    delegator_address: delegatorAddress,
+                    validator_address: validatorAddress,
+                    amount: amount,
+                    creation_height: creationHeight.toString(),
+                };
+            },
+            fromAmino: function (_a) {
+                var delegator_address = _a.delegator_address, validator_address = _a.validator_address, amount = _a.amount, creation_height = _a.creation_height;
+                return ({
+                    delegatorAddress: delegator_address,
+                    validatorAddress: validator_address,
+                    amount: amount,
+                    creationHeight: BigInt(creation_height),
+                });
+            },
+        },
+    };
+}
+exports.createStakingAminoConverters = createStakingAminoConverters;

package/dist/sdk/firmachain/common/modules/staking/messages.d.ts

@@ -0,0 +1,33 @@
+import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing";
+import { MsgBeginRedelegate, MsgCancelUnbondingDelegation, MsgCreateValidator, MsgDelegate, MsgEditValidator, MsgUndelegate } from "cosmjs-types/cosmos/staking/v1beta1/tx";
+export declare const stakingTypes: ReadonlyArray<[string, GeneratedType]>;
+export interface MsgBeginRedelegateEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.staking.v1beta1.MsgBeginRedelegate";
+    readonly value: Partial<MsgBeginRedelegate>;
+}
+export declare function isMsgBeginRedelegateEncodeObject(o: EncodeObject): o is MsgBeginRedelegateEncodeObject;
+export interface MsgCreateValidatorEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.staking.v1beta1.MsgCreateValidator";
+    readonly value: Partial<MsgCreateValidator>;
+}
+export declare function isMsgCreateValidatorEncodeObject(o: EncodeObject): o is MsgCreateValidatorEncodeObject;
+export interface MsgDelegateEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.staking.v1beta1.MsgDelegate";
+    readonly value: Partial<MsgDelegate>;
+}
+export declare function isMsgDelegateEncodeObject(object: EncodeObject): object is MsgDelegateEncodeObject;
+export interface MsgEditValidatorEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.staking.v1beta1.MsgEditValidator";
+    readonly value: Partial<MsgEditValidator>;
+}
+export declare function isMsgEditValidatorEncodeObject(o: EncodeObject): o is MsgEditValidatorEncodeObject;
+export interface MsgUndelegateEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.staking.v1beta1.MsgUndelegate";
+    readonly value: Partial<MsgUndelegate>;
+}
+export declare function isMsgUndelegateEncodeObject(object: EncodeObject): object is MsgUndelegateEncodeObject;
+export interface MsgCancelUnbondingDelegationEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation";
+    readonly value: Partial<MsgCancelUnbondingDelegation>;
+}
+export declare function isMsgCancelUnbondingDelegationEncodeObject(object: EncodeObject): object is MsgCancelUnbondingDelegationEncodeObject;

package/dist/sdk/firmachain/common/modules/staking/messages.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMsgCancelUnbondingDelegationEncodeObject = exports.isMsgUndelegateEncodeObject = exports.isMsgEditValidatorEncodeObject = exports.isMsgDelegateEncodeObject = exports.isMsgCreateValidatorEncodeObject = exports.isMsgBeginRedelegateEncodeObject = exports.stakingTypes = void 0;
+var tx_1 = require("cosmjs-types/cosmos/staking/v1beta1/tx");
+exports.stakingTypes = [
+    ["/cosmos.staking.v1beta1.MsgBeginRedelegate", tx_1.MsgBeginRedelegate],
+    ["/cosmos.staking.v1beta1.MsgCreateValidator", tx_1.MsgCreateValidator],
+    ["/cosmos.staking.v1beta1.MsgDelegate", tx_1.MsgDelegate],
+    ["/cosmos.staking.v1beta1.MsgEditValidator", tx_1.MsgEditValidator],
+    ["/cosmos.staking.v1beta1.MsgUndelegate", tx_1.MsgUndelegate],
+    ["/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation", tx_1.MsgCancelUnbondingDelegation],
+];
+function isMsgBeginRedelegateEncodeObject(o) {
+    return o.typeUrl === "/cosmos.staking.v1beta1.MsgBeginRedelegate";
+}
+exports.isMsgBeginRedelegateEncodeObject = isMsgBeginRedelegateEncodeObject;
+function isMsgCreateValidatorEncodeObject(o) {
+    return o.typeUrl === "/cosmos.staking.v1beta1.MsgCreateValidator";
+}
+exports.isMsgCreateValidatorEncodeObject = isMsgCreateValidatorEncodeObject;
+function isMsgDelegateEncodeObject(object) {
+    return object.typeUrl === "/cosmos.staking.v1beta1.MsgDelegate";
+}
+exports.isMsgDelegateEncodeObject = isMsgDelegateEncodeObject;
+function isMsgEditValidatorEncodeObject(o) {
+    return o.typeUrl === "/cosmos.staking.v1beta1.MsgEditValidator";
+}
+exports.isMsgEditValidatorEncodeObject = isMsgEditValidatorEncodeObject;
+function isMsgUndelegateEncodeObject(object) {
+    return object.typeUrl === "/cosmos.staking.v1beta1.MsgUndelegate";
+}
+exports.isMsgUndelegateEncodeObject = isMsgUndelegateEncodeObject;
+function isMsgCancelUnbondingDelegationEncodeObject(object) {
+    return (object.typeUrl ===
+        "/cosmos.staking.v1beta1.MsgCancelUnbondingDelegation");
+}
+exports.isMsgCancelUnbondingDelegationEncodeObject = isMsgCancelUnbondingDelegationEncodeObject;

package/dist/sdk/firmachain/common/modules/staking/queries.d.ts

@@ -0,0 +1,23 @@
+import { QueryDelegationResponse, QueryDelegatorDelegationsResponse, QueryDelegatorUnbondingDelegationsResponse, QueryDelegatorValidatorResponse, QueryDelegatorValidatorsResponse, QueryHistoricalInfoResponse, QueryParamsResponse, QueryPoolResponse, QueryRedelegationsResponse, QueryUnbondingDelegationResponse, QueryValidatorDelegationsResponse, QueryValidatorResponse, QueryValidatorsResponse, QueryValidatorUnbondingDelegationsResponse } from "cosmjs-types/cosmos/staking/v1beta1/query";
+import { BondStatus } from "cosmjs-types/cosmos/staking/v1beta1/staking";
+import { QueryClient } from "../../queryclient";
+export declare type BondStatusString = keyof Pick<typeof BondStatus, "BOND_STATUS_BONDED" | "BOND_STATUS_UNBONDED" | "BOND_STATUS_UNBONDING"> | "";
+export interface StakingExtension {
+    readonly staking: {
+        delegation: (delegatorAddress: string, validatorAddress: string) => Promise<QueryDelegationResponse>;
+        delegatorDelegations: (delegatorAddress: string, paginationKey?: Uint8Array) => Promise<QueryDelegatorDelegationsResponse>;
+        delegatorUnbondingDelegations: (delegatorAddress: string, paginationKey?: Uint8Array) => Promise<QueryDelegatorUnbondingDelegationsResponse>;
+        delegatorValidator: (delegatorAddress: string, validatorAddress: string) => Promise<QueryDelegatorValidatorResponse>;
+        delegatorValidators: (delegatorAddress: string, paginationKey?: Uint8Array) => Promise<QueryDelegatorValidatorsResponse>;
+        historicalInfo: (height: number) => Promise<QueryHistoricalInfoResponse>;
+        params: () => Promise<QueryParamsResponse>;
+        pool: () => Promise<QueryPoolResponse>;
+        redelegations: (delegatorAddress: string, sourceValidatorAddress: string, destinationValidatorAddress: string, paginationKey?: Uint8Array) => Promise<QueryRedelegationsResponse>;
+        unbondingDelegation: (delegatorAddress: string, validatorAddress: string) => Promise<QueryUnbondingDelegationResponse>;
+        validator: (validatorAddress: string) => Promise<QueryValidatorResponse>;
+        validatorDelegations: (validatorAddress: string, paginationKey?: Uint8Array) => Promise<QueryValidatorDelegationsResponse>;
+        validators: (status: BondStatusString, paginationKey?: Uint8Array) => Promise<QueryValidatorsResponse>;
+        validatorUnbondingDelegations: (validatorAddress: string, paginationKey?: Uint8Array) => Promise<QueryValidatorUnbondingDelegationsResponse>;
+    };
+}
+export declare function setupStakingExtension(base: QueryClient): StakingExtension;

package/dist/sdk/firmachain/common/modules/staking/queries.js

@@ -0,0 +1,242 @@
+"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.setupStakingExtension = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var query_1 = require("cosmjs-types/cosmos/staking/v1beta1/query");
+var queryclient_1 = require("../../queryclient");
+function setupStakingExtension(base) {
+    var _this = this;
+    // Use this service to get easy typed access to query methods
+    // This cannot be used for proof verification
+    var rpc = queryclient_1.createProtobufRpcClient(base);
+    var queryService = new query_1.QueryClientImpl(rpc);
+    return {
+        staking: {
+            delegation: function (delegatorAddress, validatorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Delegation({
+                                delegatorAddr: delegatorAddress,
+                                validatorAddr: validatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegatorDelegations: function (delegatorAddress, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DelegatorDelegations({
+                                delegatorAddr: delegatorAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegatorUnbondingDelegations: function (delegatorAddress, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DelegatorUnbondingDelegations({
+                                delegatorAddr: delegatorAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegatorValidator: function (delegatorAddress, validatorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DelegatorValidator({
+                                delegatorAddr: delegatorAddress,
+                                validatorAddr: validatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegatorValidators: function (delegatorAddress, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DelegatorValidators({
+                                delegatorAddr: delegatorAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            historicalInfo: function (height) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.HistoricalInfo({
+                                height: BigInt(height),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            params: function () { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Params({})];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            pool: function () { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Pool({})];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            redelegations: function (delegatorAddress, sourceValidatorAddress, destinationValidatorAddress, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Redelegations({
+                                delegatorAddr: delegatorAddress,
+                                srcValidatorAddr: sourceValidatorAddress,
+                                dstValidatorAddr: destinationValidatorAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            unbondingDelegation: function (delegatorAddress, validatorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.UnbondingDelegation({
+                                delegatorAddr: delegatorAddress,
+                                validatorAddr: validatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            validator: function (validatorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Validator({ validatorAddr: validatorAddress })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            validatorDelegations: function (validatorAddress, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.ValidatorDelegations({
+                                validatorAddr: validatorAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            validators: function (status, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Validators({
+                                status: status,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            validatorUnbondingDelegations: function (validatorAddress, paginationKey) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.ValidatorUnbondingDelegations({
+                                validatorAddr: validatorAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+        },
+    };
+}
+exports.setupStakingExtension = setupStakingExtension;

package/dist/sdk/firmachain/common/modules/tx/queries.d.ts

@@ -0,0 +1,11 @@
+import { Pubkey } from "@cosmjs/amino";
+import { GetTxResponse, SimulateResponse } from "cosmjs-types/cosmos/tx/v1beta1/service";
+import { Any } from "cosmjs-types/google/protobuf/any";
+import { QueryClient } from "../../queryclient";
+export interface TxExtension {
+    readonly tx: {
+        getTx: (txId: string) => Promise<GetTxResponse>;
+        simulate: (messages: readonly Any[], memo: string | undefined, signer: Pubkey, sequence: number) => Promise<SimulateResponse>;
+    };
+}
+export declare function setupTxExtension(base: QueryClient): TxExtension;