@firmachain/firma-js 0.2.64 → 0.3.1

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

@@ -0,0 +1,18 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { AminoConverters } from "../../aminotypes";
+interface Any {
+    readonly type_url: string;
+    readonly value: Uint8Array;
+}
+/** Supports submitting arbitrary evidence */
+export interface AminoMsgSubmitEvidence extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgSubmitEvidence";
+    readonly value: {
+        /** Bech32 account address */
+        readonly submitter: string;
+        readonly evidence: Any;
+    };
+}
+export declare function isAminoMsgSubmitEvidence(msg: AminoMsg): msg is AminoMsgSubmitEvidence;
+export declare function createEvidenceAminoConverters(): AminoConverters;
+export {};

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

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

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

@@ -0,0 +1,2 @@
+import { AminoConverters } from "../../aminotypes";
+export declare function createFeegrantAminoConverters(): AminoConverters;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeegrantAminoConverters = void 0;
+function createFeegrantAminoConverters() {
+    return {
+    // For Cosmos SDK < 0.46 the Amino JSON codec was broken on chain and thus inaccessible.
+    // Now this can be implemented for 0.46+ chains, see
+    // https://github.com/cosmos/cosmjs/issues/1092
+    //
+    // "/cosmos.feegrant.v1beta1.MsgGrantAllowance": IMPLEMENT_ME,
+    // "/cosmos.feegrant.v1beta1.MsgRevokeAllowance": IMPLEMENT_ME,
+    };
+}
+exports.createFeegrantAminoConverters = createFeegrantAminoConverters;

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

@@ -0,0 +1,2 @@
+import { GeneratedType } from "@cosmjs/proto-signing";
+export declare const feegrantTypes: ReadonlyArray<[string, GeneratedType]>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feegrantTypes = void 0;
+var tx_1 = require("cosmjs-types/cosmos/feegrant/v1beta1/tx");
+exports.feegrantTypes = [
+    ["/cosmos.feegrant.v1beta1.MsgGrantAllowance", tx_1.MsgGrantAllowance],
+    ["/cosmos.feegrant.v1beta1.MsgRevokeAllowance", tx_1.MsgRevokeAllowance],
+];

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

@@ -0,0 +1,9 @@
+import { QueryAllowanceResponse, QueryAllowancesResponse } from "cosmjs-types/cosmos/feegrant/v1beta1/query";
+import { QueryClient } from "../../queryclient";
+export interface FeegrantExtension {
+    readonly feegrant: {
+        readonly allowance: (granter: string, grantee: string) => Promise<QueryAllowanceResponse>;
+        readonly allowances: (grantee: string, paginationKey?: Uint8Array) => Promise<QueryAllowancesResponse>;
+    };
+}
+export declare function setupFeegrantExtension(base: QueryClient): FeegrantExtension;

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

@@ -0,0 +1,81 @@
+"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.setupFeegrantExtension = void 0;
+var query_1 = require("cosmjs-types/cosmos/feegrant/v1beta1/query");
+var queryclient_1 = require("../../queryclient");
+function setupFeegrantExtension(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 {
+        feegrant: {
+            allowance: function (granter, grantee) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Allowance({
+                                granter: granter,
+                                grantee: grantee,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            allowances: function (grantee, 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.Allowances({
+                                grantee: grantee,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+        },
+    };
+}
+exports.setupFeegrantExtension = setupFeegrantExtension;

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

@@ -0,0 +1,79 @@
+import { AminoMsg, Coin } from "@cosmjs/amino";
+import { AminoConverters } from "../../aminotypes";
+/** Supports submitting arbitrary proposal content. */
+export interface AminoMsgSubmitProposal extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgSubmitProposal";
+    readonly value: {
+        /**
+         * A proposal structure, e.g.
+         *
+         * ```
+         * {
+         *   type: 'cosmos-sdk/TextProposal',
+         *   value: {
+         *     description: 'This proposal proposes to test whether this proposal passes',
+         *     title: 'Test Proposal'
+         *   }
+         * }
+         * ```
+         */
+        readonly content: {
+            readonly type: string;
+            readonly value: any;
+        };
+        readonly initial_deposit: readonly Coin[];
+        /** Bech32 account address */
+        readonly proposer: string;
+    };
+}
+export declare function isAminoMsgSubmitProposal(msg: AminoMsg): msg is AminoMsgSubmitProposal;
+/** Casts a vote */
+export interface AminoMsgVote extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgVote";
+    readonly value: {
+        readonly proposal_id: string;
+        /** Bech32 account address */
+        readonly voter: string;
+        /**
+         * VoteOption as integer from 0 to 4 🤷‍
+         *
+         * @see https://github.com/cosmos/cosmos-sdk/blob/v0.42.9/x/gov/types/gov.pb.go#L38-L49
+         */
+        readonly option: number;
+    };
+}
+export declare function isAminoMsgVote(msg: AminoMsg): msg is AminoMsgVote;
+/**
+ * @see https://github.com/cosmos/cosmos-sdk/blob/v0.44.5/x/gov/types/tx.pb.go#L196-L203
+ * @see https://github.com/cosmos/cosmos-sdk/blob/v0.44.5/x/gov/types/gov.pb.go#L124-L130
+ */
+export interface AminoMsgVoteWeighted extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgVoteWeighted";
+    readonly value: {
+        readonly proposal_id: string;
+        /** Bech32 account address */
+        readonly voter: string;
+        readonly options: Array<{
+            /**
+             * VoteOption as integer from 0 to 4 🤷‍
+             *
+             * @see https://github.com/cosmos/cosmos-sdk/blob/v0.44.5/x/gov/types/gov.pb.go#L35-L49
+             */
+            readonly option: number;
+            readonly weight: string;
+        }>;
+    };
+}
+export declare function isAminoMsgVoteWeighted(msg: AminoMsg): msg is AminoMsgVoteWeighted;
+/** Submits a deposit to an existing proposal */
+export interface AminoMsgDeposit extends AminoMsg {
+    readonly type: "cosmos-sdk/MsgDeposit";
+    readonly value: {
+        readonly proposal_id: string;
+        /** Bech32 account address */
+        readonly depositor: string;
+        readonly amount: readonly Coin[];
+    };
+}
+export declare function isAminoMsgDeposit(msg: AminoMsg): msg is AminoMsgDeposit;
+export declare function createGovAminoConverters(): AminoConverters;

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGovAminoConverters = exports.isAminoMsgDeposit = exports.isAminoMsgVoteWeighted = exports.isAminoMsgVote = exports.isAminoMsgSubmitProposal = void 0;
+var math_1 = require("@cosmjs/math");
+var utils_1 = require("@cosmjs/utils");
+var gov_1 = require("cosmjs-types/cosmos/gov/v1beta1/gov");
+var any_1 = require("cosmjs-types/google/protobuf/any");
+var queryclient_1 = require("../../queryclient");
+function isAminoMsgSubmitProposal(msg) {
+    return msg.type === "cosmos-sdk/MsgSubmitProposal";
+}
+exports.isAminoMsgSubmitProposal = isAminoMsgSubmitProposal;
+function isAminoMsgVote(msg) {
+    return msg.type === "cosmos-sdk/MsgVote";
+}
+exports.isAminoMsgVote = isAminoMsgVote;
+function isAminoMsgVoteWeighted(msg) {
+    return msg.type === "cosmos-sdk/MsgVoteWeighted";
+}
+exports.isAminoMsgVoteWeighted = isAminoMsgVoteWeighted;
+function isAminoMsgDeposit(msg) {
+    return msg.type === "cosmos-sdk/MsgDeposit";
+}
+exports.isAminoMsgDeposit = isAminoMsgDeposit;
+function createGovAminoConverters() {
+    // Gov v1 types missing, see
+    // https://github.com/cosmos/cosmjs/issues/1442
+    return {
+        "/cosmos.gov.v1beta1.MsgDeposit": {
+            aminoType: "cosmos-sdk/MsgDeposit",
+            toAmino: function (_a) {
+                var amount = _a.amount, depositor = _a.depositor, proposalId = _a.proposalId;
+                return {
+                    amount: amount,
+                    depositor: depositor,
+                    proposal_id: proposalId.toString(),
+                };
+            },
+            fromAmino: function (_a) {
+                var amount = _a.amount, depositor = _a.depositor, proposal_id = _a.proposal_id;
+                return {
+                    amount: Array.from(amount),
+                    depositor: depositor,
+                    proposalId: BigInt(proposal_id),
+                };
+            },
+        },
+        "/cosmos.gov.v1beta1.MsgVote": {
+            aminoType: "cosmos-sdk/MsgVote",
+            toAmino: function (_a) {
+                var option = _a.option, proposalId = _a.proposalId, voter = _a.voter;
+                return {
+                    option: option,
+                    proposal_id: proposalId.toString(),
+                    voter: voter,
+                };
+            },
+            fromAmino: function (_a) {
+                var option = _a.option, proposal_id = _a.proposal_id, voter = _a.voter;
+                return {
+                    option: gov_1.voteOptionFromJSON(option),
+                    proposalId: BigInt(proposal_id),
+                    voter: voter,
+                };
+            },
+        },
+        "/cosmos.gov.v1beta1.MsgVoteWeighted": {
+            aminoType: "cosmos-sdk/MsgVoteWeighted",
+            toAmino: function (_a) {
+                var options = _a.options, proposalId = _a.proposalId, voter = _a.voter;
+                return {
+                    options: options.map(function (o) { return ({
+                        option: o.option,
+                        // Weight is between 0 and 1, so we always have 20 characters when printing all trailing
+                        // zeros (e.g. "0.700000000000000000" or "1.000000000000000000")
+                        weight: queryclient_1.decodeCosmosSdkDecFromProto(o.weight).toString().padEnd(20, "0"),
+                    }); }),
+                    proposal_id: proposalId.toString(),
+                    voter: voter,
+                };
+            },
+            fromAmino: function (_a) {
+                var options = _a.options, proposal_id = _a.proposal_id, voter = _a.voter;
+                return {
+                    proposalId: BigInt(proposal_id),
+                    voter: voter,
+                    options: options.map(function (o) { return ({
+                        option: gov_1.voteOptionFromJSON(o.option),
+                        weight: math_1.Decimal.fromUserInput(o.weight, 18).atomics,
+                    }); }),
+                };
+            },
+        },
+        "/cosmos.gov.v1beta1.MsgSubmitProposal": {
+            aminoType: "cosmos-sdk/MsgSubmitProposal",
+            toAmino: function (_a) {
+                var initialDeposit = _a.initialDeposit, proposer = _a.proposer, content = _a.content;
+                utils_1.assertDefinedAndNotNull(content);
+                var proposal;
+                switch (content.typeUrl) {
+                    case "/cosmos.gov.v1beta1.TextProposal": {
+                        var textProposal = gov_1.TextProposal.decode(content.value);
+                        proposal = {
+                            type: "cosmos-sdk/TextProposal",
+                            value: {
+                                description: textProposal.description,
+                                title: textProposal.title,
+                            },
+                        };
+                        break;
+                    }
+                    default:
+                        throw new Error("Unsupported proposal type: '" + content.typeUrl + "'");
+                }
+                return {
+                    initial_deposit: initialDeposit,
+                    proposer: proposer,
+                    content: proposal,
+                };
+            },
+            fromAmino: function (_a) {
+                var initial_deposit = _a.initial_deposit, proposer = _a.proposer, content = _a.content;
+                var any_content;
+                switch (content.type) {
+                    case "cosmos-sdk/TextProposal": {
+                        var value = content.value;
+                        utils_1.assert(utils_1.isNonNullObject(value));
+                        var _b = value, title = _b.title, description = _b.description;
+                        utils_1.assert(typeof title === "string");
+                        utils_1.assert(typeof description === "string");
+                        any_content = any_1.Any.fromPartial({
+                            typeUrl: "/cosmos.gov.v1beta1.TextProposal",
+                            value: gov_1.TextProposal.encode(gov_1.TextProposal.fromPartial({
+                                title: title,
+                                description: description,
+                            })).finish(),
+                        });
+                        break;
+                    }
+                    default:
+                        throw new Error("Unsupported proposal type: '" + content.type + "'");
+                }
+                return {
+                    initialDeposit: Array.from(initial_deposit),
+                    proposer: proposer,
+                    content: any_content,
+                };
+            },
+        },
+    };
+}
+exports.createGovAminoConverters = createGovAminoConverters;

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

@@ -0,0 +1,29 @@
+import { EncodeObject, GeneratedType } from "@cosmjs/proto-signing";
+import { MsgDeposit, MsgSubmitProposal, MsgVote, MsgVoteWeighted } from "cosmjs-types/cosmos/gov/v1beta1/tx";
+import { MsgCancelProposal } from "@kintsugi-tech/cosmjs-types/cosmos/gov/v1/tx";
+export declare const govTypes: ReadonlyArray<[string, GeneratedType]>;
+export interface MsgDepositEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.gov.v1beta1.MsgDeposit";
+    readonly value: Partial<MsgDeposit>;
+}
+export declare function isMsgDepositEncodeObject(object: EncodeObject): object is MsgSubmitProposalEncodeObject;
+export interface MsgSubmitProposalEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.gov.v1beta1.MsgSubmitProposal";
+    readonly value: Partial<MsgSubmitProposal>;
+}
+export declare function isMsgSubmitProposalEncodeObject(object: EncodeObject): object is MsgSubmitProposalEncodeObject;
+export interface MsgVoteEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.gov.v1beta1.MsgVote";
+    readonly value: Partial<MsgVote>;
+}
+export declare function isMsgVoteEncodeObject(object: EncodeObject): object is MsgVoteEncodeObject;
+export interface MsgVoteWeightedEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.gov.v1beta1.MsgVoteWeighted";
+    readonly value: Partial<MsgVoteWeighted>;
+}
+export declare function isMsgVoteWeightedEncodeObject(object: EncodeObject): object is MsgVoteWeightedEncodeObject;
+export interface MsgCancelProposalEncodeObject extends EncodeObject {
+    readonly typeUrl: "/cosmos.gov.v1.MsgCancelProposal";
+    readonly value: Partial<MsgCancelProposal>;
+}
+export declare function isMsgCancelProposalEncodeObject(object: EncodeObject): object is MsgCancelProposalEncodeObject;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMsgCancelProposalEncodeObject = exports.isMsgVoteWeightedEncodeObject = exports.isMsgVoteEncodeObject = exports.isMsgSubmitProposalEncodeObject = exports.isMsgDepositEncodeObject = exports.govTypes = void 0;
+var tx_1 = require("cosmjs-types/cosmos/gov/v1/tx");
+var tx_2 = require("cosmjs-types/cosmos/gov/v1beta1/tx");
+var tx_3 = require("@kintsugi-tech/cosmjs-types/cosmos/gov/v1/tx");
+exports.govTypes = [
+    ["/cosmos.gov.v1.MsgDeposit", tx_1.MsgDeposit],
+    ["/cosmos.gov.v1.MsgSubmitProposal", tx_1.MsgSubmitProposal],
+    ["/cosmos.gov.v1.MsgUpdateParams", tx_1.MsgUpdateParams],
+    ["/cosmos.gov.v1.MsgVote", tx_1.MsgVote],
+    ["/cosmos.gov.v1.MsgVoteWeighted", tx_1.MsgVoteWeighted],
+    ["/cosmos.gov.v1beta1.MsgDeposit", tx_2.MsgDeposit],
+    ["/cosmos.gov.v1beta1.MsgSubmitProposal", tx_2.MsgSubmitProposal],
+    ["/cosmos.gov.v1beta1.MsgVote", tx_2.MsgVote],
+    ["/cosmos.gov.v1beta1.MsgVoteWeighted", tx_2.MsgVoteWeighted],
+    ["/cosmos.gov.v1.MsgCancelProposal", tx_3.MsgCancelProposal], // Temporary type casting
+];
+function isMsgDepositEncodeObject(object) {
+    return object.typeUrl === "/cosmos.gov.v1beta1.MsgDeposit";
+}
+exports.isMsgDepositEncodeObject = isMsgDepositEncodeObject;
+function isMsgSubmitProposalEncodeObject(object) {
+    return object.typeUrl === "/cosmos.gov.v1beta1.MsgSubmitProposal";
+}
+exports.isMsgSubmitProposalEncodeObject = isMsgSubmitProposalEncodeObject;
+function isMsgVoteEncodeObject(object) {
+    return object.typeUrl === "/cosmos.gov.v1beta1.MsgVote";
+}
+exports.isMsgVoteEncodeObject = isMsgVoteEncodeObject;
+function isMsgVoteWeightedEncodeObject(object) {
+    return object.typeUrl === "/cosmos.gov.v1beta1.MsgVoteWeighted";
+}
+exports.isMsgVoteWeightedEncodeObject = isMsgVoteWeightedEncodeObject;
+function isMsgCancelProposalEncodeObject(object) {
+    return object.typeUrl === "/cosmos.gov.v1.MsgCancelProposal";
+}
+exports.isMsgCancelProposalEncodeObject = isMsgCancelProposalEncodeObject;

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

@@ -0,0 +1,19 @@
+import { Uint64 } from "@cosmjs/math";
+import { ProposalStatus } from "cosmjs-types/cosmos/gov/v1beta1/gov";
+import { QueryDepositResponse, QueryDepositsResponse, QueryParamsResponse, QueryProposalResponse, QueryProposalsResponse, QueryTallyResultResponse, QueryVoteResponse, QueryVotesResponse } from "cosmjs-types/cosmos/gov/v1beta1/query";
+import { QueryClient } from "../../queryclient";
+export declare type GovParamsType = "deposit" | "tallying" | "voting";
+export declare type GovProposalId = string | number | Uint64;
+export interface GovExtension {
+    readonly gov: {
+        readonly params: (parametersType: GovParamsType) => Promise<QueryParamsResponse>;
+        readonly proposals: (proposalStatus: ProposalStatus, depositor: string, voter: string, paginationKey?: Uint8Array) => Promise<QueryProposalsResponse>;
+        readonly proposal: (proposalId: GovProposalId) => Promise<QueryProposalResponse>;
+        readonly deposits: (proposalId: GovProposalId, paginationKey?: Uint8Array) => Promise<QueryDepositsResponse>;
+        readonly deposit: (proposalId: GovProposalId, depositorAddress: string) => Promise<QueryDepositResponse>;
+        readonly tally: (proposalId: GovProposalId) => Promise<QueryTallyResultResponse>;
+        readonly votes: (proposalId: GovProposalId, paginationKey?: Uint8Array) => Promise<QueryVotesResponse>;
+        readonly vote: (proposalId: GovProposalId, voterAddress: string) => Promise<QueryVoteResponse>;
+    };
+}
+export declare function setupGovExtension(base: QueryClient): GovExtension;

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

@@ -0,0 +1,160 @@
+"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.setupGovExtension = void 0;
+var query_1 = require("cosmjs-types/cosmos/gov/v1beta1/query");
+var queryclient_1 = require("../../queryclient");
+function setupGovExtension(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 {
+        gov: {
+            params: function (parametersType) { 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({ paramsType: parametersType })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            proposals: function (proposalStatus, depositorAddress, voterAddress, 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.Proposals({
+                                proposalStatus: proposalStatus,
+                                depositor: depositorAddress,
+                                voter: voterAddress,
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            proposal: function (proposalId) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Proposal({ proposalId: queryclient_1.longify(proposalId) })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            deposits: function (proposalId, 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.Deposits({
+                                proposalId: queryclient_1.longify(proposalId),
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            deposit: function (proposalId, depositorAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Deposit({
+                                proposalId: queryclient_1.longify(proposalId),
+                                depositor: depositorAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            tally: function (proposalId) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.TallyResult({
+                                proposalId: queryclient_1.longify(proposalId),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            votes: function (proposalId, 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.Votes({
+                                proposalId: queryclient_1.longify(proposalId),
+                                pagination: queryclient_1.createPagination(paginationKey),
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+            vote: function (proposalId, voterAddress) { return __awaiter(_this, void 0, void 0, function () {
+                var response;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, queryService.Vote({
+                                proposalId: queryclient_1.longify(proposalId),
+                                voter: voterAddress,
+                            })];
+                        case 1:
+                            response = _a.sent();
+                            return [2 /*return*/, response];
+                    }
+                });
+            }); },
+        },
+    };
+}
+exports.setupGovExtension = setupGovExtension;

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

@@ -0,0 +1,2 @@
+import { AminoConverters } from "../../aminotypes";
+export declare function createGroupAminoConverters(): AminoConverters;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGroupAminoConverters = void 0;
+function createGroupAminoConverters() {
+    // Missing, see https://github.com/cosmos/cosmjs/issues/1441
+    return {};
+}
+exports.createGroupAminoConverters = createGroupAminoConverters;

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

@@ -0,0 +1,2 @@
+import { GeneratedType } from "@cosmjs/proto-signing";
+export declare const groupTypes: ReadonlyArray<[string, GeneratedType]>;