@firmachain/firma-js 0.2.64 → 0.3.1

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

@@ -0,0 +1,85 @@
+"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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBankAminoConverters = exports.isAminoMsgMultiSend = exports.isAminoMsgSend = void 0;
+function isAminoMsgSend(msg) {
+    return msg.type === "cosmos-sdk/MsgSend";
+}
+exports.isAminoMsgSend = isAminoMsgSend;
+function isAminoMsgMultiSend(msg) {
+    return msg.type === "cosmos-sdk/MsgMultiSend";
+}
+exports.isAminoMsgMultiSend = isAminoMsgMultiSend;
+function createBankAminoConverters() {
+    return {
+        "/cosmos.bank.v1beta1.MsgSend": {
+            aminoType: "cosmos-sdk/MsgSend",
+            toAmino: function (_a) {
+                var fromAddress = _a.fromAddress, toAddress = _a.toAddress, amount = _a.amount;
+                return ({
+                    from_address: fromAddress,
+                    to_address: toAddress,
+                    amount: __spreadArray([], __read(amount)),
+                });
+            },
+            fromAmino: function (_a) {
+                var from_address = _a.from_address, to_address = _a.to_address, amount = _a.amount;
+                return ({
+                    fromAddress: from_address,
+                    toAddress: to_address,
+                    amount: __spreadArray([], __read(amount)),
+                });
+            },
+        },
+        "/cosmos.bank.v1beta1.MsgMultiSend": {
+            aminoType: "cosmos-sdk/MsgMultiSend",
+            toAmino: function (_a) {
+                var inputs = _a.inputs, outputs = _a.outputs;
+                return ({
+                    inputs: inputs.map(function (input) { return ({
+                        address: input.address,
+                        coins: __spreadArray([], __read(input.coins)),
+                    }); }),
+                    outputs: outputs.map(function (output) { return ({
+                        address: output.address,
+                        coins: __spreadArray([], __read(output.coins)),
+                    }); }),
+                });
+            },
+            fromAmino: function (_a) {
+                var inputs = _a.inputs, outputs = _a.outputs;
+                return ({
+                    inputs: inputs.map(function (input) { return ({
+                        address: input.address,
+                        coins: __spreadArray([], __read(input.coins)),
+                    }); }),
+                    outputs: outputs.map(function (output) { return ({
+                        address: output.address,
+                        coins: __spreadArray([], __read(output.coins)),
+                    }); }),
+                });
+            },
+        },
+    };
+}
+exports.createBankAminoConverters = createBankAminoConverters;

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

@@ -0,0 +1,8 @@
+import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing";
+import { MsgSend } from "cosmjs-types/cosmos/bank/v1beta1/tx";
+export declare const bankTypes: ReadonlyArray<[string, GeneratedType]>;
+export interface MsgSendEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.bank.v1beta1.MsgSend";
+    readonly value: Partial<MsgSend>;
+}
+export declare function isMsgSendEncodeObject(encodeObject: EncodeObject): encodeObject is MsgSendEncodeObject;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMsgSendEncodeObject = exports.bankTypes = void 0;
+var tx_1 = require("cosmjs-types/cosmos/bank/v1beta1/tx");
+exports.bankTypes = [
+    ["/cosmos.bank.v1beta1.MsgMultiSend", tx_1.MsgMultiSend],
+    ["/cosmos.bank.v1beta1.MsgSend", tx_1.MsgSend],
+];
+function isMsgSendEncodeObject(encodeObject) {
+    return encodeObject.typeUrl === "/cosmos.bank.v1beta1.MsgSend";
+}
+exports.isMsgSendEncodeObject = isMsgSendEncodeObject;

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

@@ -0,0 +1,15 @@
+import { Metadata } from "cosmjs-types/cosmos/bank/v1beta1/bank";
+import { QueryTotalSupplyResponse } from "cosmjs-types/cosmos/bank/v1beta1/query";
+import { Coin } from "cosmjs-types/cosmos/base/v1beta1/coin";
+import { QueryClient } from "../../queryclient";
+export interface BankExtension {
+    readonly bank: {
+        readonly balance: (address: string, denom: string) => Promise<Coin>;
+        readonly allBalances: (address: string) => Promise<Coin[]>;
+        readonly totalSupply: (paginationKey?: Uint8Array) => Promise<QueryTotalSupplyResponse>;
+        readonly supplyOf: (denom: string) => Promise<Coin>;
+        readonly denomMetadata: (denom: string) => Promise<Metadata>;
+        readonly denomsMetadata: () => Promise<Metadata[]>;
+    };
+}
+export declare function setupBankExtension(base: QueryClient): BankExtension;

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

@@ -0,0 +1,128 @@
+"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.setupBankExtension = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var utils_1 = require("@cosmjs/utils");
+var query_1 = require("cosmjs-types/cosmos/bank/v1beta1/query");
+var queryclient_1 = require("../../queryclient");
+function setupBankExtension(base) {
+    var _this = this;
+    var rpc = queryclient_1.createProtobufRpcClient(base);
+    // Use this service to get easy typed access to query methods
+    // This cannot be used for proof verification
+    var queryService = new query_1.QueryClientImpl(rpc);
+    return {
+        bank: {
+            balance: function (address, denom) { return __awaiter(_this, void 0, void 0, function () {
+                var balance;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Balance({ address: address, denom: denom })];
+                        case 1:
+                            balance = (_a.sent()).balance;
+                            utils_1.assert(balance);
+                            return [2 /*return*/, balance];
+                    }
+                });
+            }); },
+            allBalances: function (address) { return __awaiter(_this, void 0, void 0, function () {
+                var balances;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.AllBalances(query_1.QueryAllBalancesRequest.fromPartial({ address: address }))];
+                        case 1:
+                            balances = (_a.sent()).balances;
+                            return [2 /*return*/, balances];
+                    }
+                });
+            }); },
+            totalSupply: function (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.TotalSupply({
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            supplyOf: function (denom) { return __awaiter(_this, void 0, void 0, function () {
+                var amount;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.SupplyOf({ denom: denom })];
+                        case 1:
+                            amount = (_a.sent()).amount;
+                            utils_1.assert(amount);
+                            return [2 /*return*/, amount];
+                    }
+                });
+            }); },
+            denomMetadata: function (denom) { return __awaiter(_this, void 0, void 0, function () {
+                var metadata;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DenomMetadata({ denom: denom })];
+                        case 1:
+                            metadata = (_a.sent()).metadata;
+                            utils_1.assert(metadata);
+                            return [2 /*return*/, metadata];
+                    }
+                });
+            }); },
+            denomsMetadata: function () { return __awaiter(_this, void 0, void 0, function () {
+                var metadatas;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DenomsMetadata(query_1.QueryDenomsMetadataRequest.fromPartial({
+                                pagination: undefined, // Not implemented
+                            }))];
+                        case 1:
+                            metadatas = (_a.sent()).metadatas;
+                            return [2 /*return*/, metadatas];
+                    }
+                });
+            }); },
+        },
+    };
+}
+exports.setupBankExtension = setupBankExtension;

package/dist/sdk/firmachain/common/modules/crisis/aminomessages.d.ts

@@ -0,0 +1,14 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { AminoConverters } from "../../aminotypes";
+/** Verifies a particular invariance */
+export interface AminoMsgVerifyInvariant extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgVerifyInvariant";
+    readonly value: {
+        /** Bech32 account address */
+        readonly sender: string;
+        readonly invariant_module_name: string;
+        readonly invariant_route: string;
+    };
+}
+export declare function isAminoMsgVerifyInvariant(msg: AminoMsg): msg is AminoMsgVerifyInvariant;
+export declare function createCrysisAminoConverters(): AminoConverters;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCrysisAminoConverters = exports.isAminoMsgVerifyInvariant = void 0;
+function isAminoMsgVerifyInvariant(msg) {
+    return msg.type === "cosmos-sdk/MsgVerifyInvariant";
+}
+exports.isAminoMsgVerifyInvariant = isAminoMsgVerifyInvariant;
+function createCrysisAminoConverters() {
+    throw new Error("Not implemented");
+}
+exports.createCrysisAminoConverters = createCrysisAminoConverters;

package/dist/sdk/firmachain/common/modules/distribution/aminomessages.d.ts

@@ -0,0 +1,44 @@
+import { AminoMsg, Coin } from "@cosmjs/amino";
+import { AminoConverter } from "../..";
+/** Changes the withdraw address for a delegator (or validator self-delegation) */
+export interface AminoMsgSetWithdrawAddress extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgModifyWithdrawAddress";
+    readonly value: {
+        /** Bech32 account address */
+        readonly delegator_address: string;
+        /** Bech32 account address */
+        readonly withdraw_address: string;
+    };
+}
+export declare function isAminoMsgSetWithdrawAddress(msg: AminoMsg): msg is AminoMsgSetWithdrawAddress;
+/** Message for delegation withdraw from a single validator */
+export interface AminoMsgWithdrawDelegatorReward extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgWithdrawDelegationReward";
+    readonly value: {
+        /** Bech32 account address */
+        readonly delegator_address: string;
+        /** Bech32 account address */
+        readonly validator_address: string;
+    };
+}
+export declare function isAminoMsgWithdrawDelegatorReward(msg: AminoMsg): msg is AminoMsgWithdrawDelegatorReward;
+/** Message for validator withdraw */
+export interface AminoMsgWithdrawValidatorCommission extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgWithdrawValidatorCommission";
+    readonly value: {
+        /** Bech32 account address */
+        readonly validator_address: string;
+    };
+}
+export declare function isAminoMsgWithdrawValidatorCommission(msg: AminoMsg): msg is AminoMsgWithdrawValidatorCommission;
+/** Allows an account to directly fund the community pool. */
+export interface AminoMsgFundCommunityPool extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgFundCommunityPool";
+    readonly value: {
+        readonly amount: readonly Coin[];
+        /** Bech32 account address */
+        readonly depositor: string;
+    };
+}
+export declare function isAminoMsgFundCommunityPool(msg: AminoMsg): msg is AminoMsgFundCommunityPool;
+export declare function createDistributionAminoConverters(): Record<string, AminoConverter>;

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

@@ -0,0 +1,113 @@
+"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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDistributionAminoConverters = exports.isAminoMsgFundCommunityPool = exports.isAminoMsgWithdrawValidatorCommission = exports.isAminoMsgWithdrawDelegatorReward = exports.isAminoMsgSetWithdrawAddress = void 0;
+function isAminoMsgSetWithdrawAddress(msg) {
+    // NOTE: Type string and names diverge here!
+    return msg.type === "cosmos-sdk/MsgModifyWithdrawAddress";
+}
+exports.isAminoMsgSetWithdrawAddress = isAminoMsgSetWithdrawAddress;
+function isAminoMsgWithdrawDelegatorReward(msg) {
+    // NOTE: Type string and names diverge here!
+    return msg.type === "cosmos-sdk/MsgWithdrawDelegationReward";
+}
+exports.isAminoMsgWithdrawDelegatorReward = isAminoMsgWithdrawDelegatorReward;
+function isAminoMsgWithdrawValidatorCommission(msg) {
+    return msg.type === "cosmos-sdk/MsgWithdrawValidatorCommission";
+}
+exports.isAminoMsgWithdrawValidatorCommission = isAminoMsgWithdrawValidatorCommission;
+function isAminoMsgFundCommunityPool(msg) {
+    return msg.type === "cosmos-sdk/MsgFundCommunityPool";
+}
+exports.isAminoMsgFundCommunityPool = isAminoMsgFundCommunityPool;
+function createDistributionAminoConverters() {
+    return {
+        "/cosmos.distribution.v1beta1.MsgFundCommunityPool": {
+            aminoType: "cosmos-sdk/MsgFundCommunityPool",
+            toAmino: function (_a) {
+                var amount = _a.amount, depositor = _a.depositor;
+                return ({
+                    amount: __spreadArray([], __read(amount)),
+                    depositor: depositor,
+                });
+            },
+            fromAmino: function (_a) {
+                var amount = _a.amount, depositor = _a.depositor;
+                return ({
+                    amount: __spreadArray([], __read(amount)),
+                    depositor: depositor,
+                });
+            },
+        },
+        "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress": {
+            aminoType: "cosmos-sdk/MsgModifyWithdrawAddress",
+            toAmino: function (_a) {
+                var delegatorAddress = _a.delegatorAddress, withdrawAddress = _a.withdrawAddress;
+                return ({
+                    delegator_address: delegatorAddress,
+                    withdraw_address: withdrawAddress,
+                });
+            },
+            fromAmino: function (_a) {
+                var delegator_address = _a.delegator_address, withdraw_address = _a.withdraw_address;
+                return ({
+                    delegatorAddress: delegator_address,
+                    withdrawAddress: withdraw_address,
+                });
+            },
+        },
+        "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward": {
+            aminoType: "cosmos-sdk/MsgWithdrawDelegationReward",
+            toAmino: function (_a) {
+                var delegatorAddress = _a.delegatorAddress, validatorAddress = _a.validatorAddress;
+                return ({
+                    delegator_address: delegatorAddress,
+                    validator_address: validatorAddress,
+                });
+            },
+            fromAmino: function (_a) {
+                var delegator_address = _a.delegator_address, validator_address = _a.validator_address;
+                return ({
+                    delegatorAddress: delegator_address,
+                    validatorAddress: validator_address,
+                });
+            },
+        },
+        "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": {
+            aminoType: "cosmos-sdk/MsgWithdrawValidatorCommission",
+            toAmino: function (_a) {
+                var validatorAddress = _a.validatorAddress;
+                return ({
+                    validator_address: validatorAddress,
+                });
+            },
+            fromAmino: function (_a) {
+                var validator_address = _a.validator_address;
+                return ({
+                    validatorAddress: validator_address,
+                });
+            },
+        },
+    };
+}
+exports.createDistributionAminoConverters = createDistributionAminoConverters;

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

@@ -0,0 +1,8 @@
+import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing";
+import { MsgWithdrawDelegatorReward } from "cosmjs-types/cosmos/distribution/v1beta1/tx";
+export declare const distributionTypes: ReadonlyArray<[string, GeneratedType]>;
+export interface MsgWithdrawDelegatorRewardEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward";
+    readonly value: Partial<MsgWithdrawDelegatorReward>;
+}
+export declare function isMsgWithdrawDelegatorRewardEncodeObject(object: EncodeObject): object is MsgWithdrawDelegatorRewardEncodeObject;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMsgWithdrawDelegatorRewardEncodeObject = exports.distributionTypes = void 0;
+var tx_1 = require("cosmjs-types/cosmos/distribution/v1beta1/tx");
+exports.distributionTypes = [
+    ["/cosmos.distribution.v1beta1.MsgFundCommunityPool", tx_1.MsgFundCommunityPool],
+    ["/cosmos.distribution.v1beta1.MsgSetWithdrawAddress", tx_1.MsgSetWithdrawAddress],
+    ["/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward", tx_1.MsgWithdrawDelegatorReward],
+    ["/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission", tx_1.MsgWithdrawValidatorCommission],
+];
+function isMsgWithdrawDelegatorRewardEncodeObject(object) {
+    return (object.typeUrl ===
+        "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward");
+}
+exports.isMsgWithdrawDelegatorRewardEncodeObject = isMsgWithdrawDelegatorRewardEncodeObject;

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

@@ -0,0 +1,16 @@
+import { QueryCommunityPoolResponse, QueryDelegationRewardsResponse, QueryDelegationTotalRewardsResponse, QueryDelegatorValidatorsResponse, QueryDelegatorWithdrawAddressResponse, QueryParamsResponse, QueryValidatorCommissionResponse, QueryValidatorOutstandingRewardsResponse, QueryValidatorSlashesResponse } from "cosmjs-types/cosmos/distribution/v1beta1/query";
+import { QueryClient } from "../../queryclient";
+export interface DistributionExtension {
+    readonly distribution: {
+        communityPool: () => Promise<QueryCommunityPoolResponse>;
+        delegationRewards: (delegatorAddress: string, validatorAddress: string) => Promise<QueryDelegationRewardsResponse>;
+        delegationTotalRewards: (delegatorAddress: string) => Promise<QueryDelegationTotalRewardsResponse>;
+        delegatorValidators: (delegatorAddress: string) => Promise<QueryDelegatorValidatorsResponse>;
+        delegatorWithdrawAddress: (delegatorAddress: string) => Promise<QueryDelegatorWithdrawAddressResponse>;
+        params: () => Promise<QueryParamsResponse>;
+        validatorCommission: (validatorAddress: string) => Promise<QueryValidatorCommissionResponse>;
+        validatorOutstandingRewards: (validatorAddress: string) => Promise<QueryValidatorOutstandingRewardsResponse>;
+        validatorSlashes: (validatorAddress: string, startingHeight: number, endingHeight: number, paginationKey?: Uint8Array) => Promise<QueryValidatorSlashesResponse>;
+    };
+}
+export declare function setupDistributionExtension(base: QueryClient): DistributionExtension;

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

@@ -0,0 +1,171 @@
+"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.setupDistributionExtension = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var query_1 = require("cosmjs-types/cosmos/distribution/v1beta1/query");
+var queryclient_1 = require("../../queryclient");
+function setupDistributionExtension(base) {
+    var _this = this;
+    var rpc = queryclient_1.createProtobufRpcClient(base);
+    // Use this service to get easy typed access to query methods
+    // This cannot be used for proof verification
+    var queryService = new query_1.QueryClientImpl(rpc);
+    return {
+        distribution: {
+            communityPool: 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.CommunityPool({})];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegationRewards: 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.DelegationRewards({
+                                delegatorAddress: delegatorAddress,
+                                validatorAddress: validatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegationTotalRewards: function (delegatorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DelegationTotalRewards({
+                                delegatorAddress: delegatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegatorValidators: function (delegatorAddress) { 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({
+                                delegatorAddress: delegatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            delegatorWithdrawAddress: function (delegatorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.DelegatorWithdrawAddress({
+                                delegatorAddress: delegatorAddress,
+                            })];
+                        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];
+                    }
+                });
+            }); },
+            validatorCommission: 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.ValidatorCommission({
+                                validatorAddress: validatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            validatorOutstandingRewards: 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.ValidatorOutstandingRewards({
+                                validatorAddress: validatorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            validatorSlashes: function (validatorAddress, startingHeight, endingHeight, 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.ValidatorSlashes({
+                                validatorAddress: validatorAddress,
+                                startingHeight: BigInt(startingHeight),
+                                endingHeight: BigInt(endingHeight),
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+        },
+    };
+}
+exports.setupDistributionExtension = setupDistributionExtension;