@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

package/sparkdream/commons/v1/query.lcd.d.ts

@@ -0,0 +1,19 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryParamsRequest, QueryParamsResponse, QueryGetPolicyPermissionsRequest, QueryGetPolicyPermissionsResponse, QueryAllPolicyPermissionsRequest, QueryAllPolicyPermissionsResponse, QueryGetGroupRequest, QueryGetGroupResponse, QueryAllGroupRequest, QueryAllGroupResponse, QueryGetCouncilMembersRequest, QueryGetCouncilMembersResponse, QueryGetProposalRequest, QueryGetProposalResponse, QueryListProposalsRequest, QueryListProposalsResponse, QueryGetProposalVotesRequest, QueryGetProposalVotesResponse, QueryGetCategoryRequest, QueryGetCategoryResponse, QueryAllCategoryRequest, QueryAllCategoryResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    params: (_params?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    getPolicyPermissions: (params: QueryGetPolicyPermissionsRequest) => Promise<QueryGetPolicyPermissionsResponse>;
+    listPolicyPermissions: (params?: QueryAllPolicyPermissionsRequest) => Promise<QueryAllPolicyPermissionsResponse>;
+    getGroup: (params: QueryGetGroupRequest) => Promise<QueryGetGroupResponse>;
+    listGroups: (params?: QueryAllGroupRequest) => Promise<QueryAllGroupResponse>;
+    getCouncilMembers: (params: QueryGetCouncilMembersRequest) => Promise<QueryGetCouncilMembersResponse>;
+    getProposal: (params: QueryGetProposalRequest) => Promise<QueryGetProposalResponse>;
+    listProposals: (params: QueryListProposalsRequest) => Promise<QueryListProposalsResponse>;
+    getProposalVotes: (params: QueryGetProposalVotesRequest) => Promise<QueryGetProposalVotesResponse>;
+    getCategory: (params: QueryGetCategoryRequest) => Promise<QueryGetCategoryResponse>;
+    listCategory: (params?: QueryAllCategoryRequest) => Promise<QueryAllCategoryResponse>;
+}

package/sparkdream/commons/v1/query.lcd.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+//@ts-nocheck
+const helpers_1 = require("../../../helpers");
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (_params = {}) => {
+        const endpoint = `sparkdream/commons/v1/params`;
+        return await this.req.get(endpoint);
+    };
+    /* ListPolicyPermissions Queries a list of PolicyPermissions items. */
+    getPolicyPermissions = async (params) => {
+        const endpoint = `sparkdream/commons/v1/policy_permissions/${params.policyAddress}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListPolicyPermissions defines the ListPolicyPermissions RPC. */
+    listPolicyPermissions = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/commons/v1/policy_permissions`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetGroup queries a specific group by name. */
+    getGroup = async (params) => {
+        const endpoint = `sparkdream/commons/v1/group/${params.index}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListGroups queries all groups. */
+    listGroups = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/commons/v1/group`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetCouncilMembers queries the members of a specific council. */
+    getCouncilMembers = async (params) => {
+        const endpoint = `sparkdream/commons/v1/council_members/${params.councilName}`;
+        return await this.req.get(endpoint);
+    };
+    /* GetProposal queries a specific proposal by ID. */
+    getProposal = async (params) => {
+        const endpoint = `sparkdream/commons/v1/proposal/${params.proposalId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListProposals queries all proposals with optional filtering. */
+    listProposals = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.councilName !== "undefined") {
+            options.params.council_name = params.councilName;
+        }
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/commons/v1/proposals`;
+        return await this.req.get(endpoint, options);
+    };
+    /* GetProposalVotes queries votes for a specific proposal. */
+    getProposalVotes = async (params) => {
+        const endpoint = `sparkdream/commons/v1/proposal/${params.proposalId}/votes`;
+        return await this.req.get(endpoint);
+    };
+    /* GetCategory queries a single shared content category by id. */
+    getCategory = async (params) => {
+        const endpoint = `sparkdream/commons/v1/category/${params.categoryId}`;
+        return await this.req.get(endpoint);
+    };
+    /* ListCategory queries all shared content categories. */
+    listCategory = async (params = {
+        pagination: undefined
+    }) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `sparkdream/commons/v1/category`;
+        return await this.req.get(endpoint, options);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/sparkdream/commons/v1/query.rpc.Query.d.ts

@@ -0,0 +1,56 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryGetPolicyPermissionsRequest, QueryGetPolicyPermissionsResponse, QueryAllPolicyPermissionsRequest, QueryAllPolicyPermissionsResponse, QueryGetGroupRequest, QueryGetGroupResponse, QueryAllGroupRequest, QueryAllGroupResponse, QueryGetCouncilMembersRequest, QueryGetCouncilMembersResponse, QueryGetProposalRequest, QueryGetProposalResponse, QueryListProposalsRequest, QueryListProposalsResponse, QueryGetProposalVotesRequest, QueryGetProposalVotesResponse, QueryGetCategoryRequest, QueryGetCategoryResponse, QueryAllCategoryRequest, QueryAllCategoryResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Parameters queries the parameters of the module. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** ListPolicyPermissions Queries a list of PolicyPermissions items. */
+    getPolicyPermissions(request: QueryGetPolicyPermissionsRequest): Promise<QueryGetPolicyPermissionsResponse>;
+    /** ListPolicyPermissions defines the ListPolicyPermissions RPC. */
+    listPolicyPermissions(request?: QueryAllPolicyPermissionsRequest): Promise<QueryAllPolicyPermissionsResponse>;
+    /** GetGroup queries a specific group by name. */
+    getGroup(request: QueryGetGroupRequest): Promise<QueryGetGroupResponse>;
+    /** ListGroups queries all groups. */
+    listGroups(request?: QueryAllGroupRequest): Promise<QueryAllGroupResponse>;
+    /** GetCouncilMembers queries the members of a specific council. */
+    getCouncilMembers(request: QueryGetCouncilMembersRequest): Promise<QueryGetCouncilMembersResponse>;
+    /** GetProposal queries a specific proposal by ID. */
+    getProposal(request: QueryGetProposalRequest): Promise<QueryGetProposalResponse>;
+    /** ListProposals queries all proposals with optional filtering. */
+    listProposals(request: QueryListProposalsRequest): Promise<QueryListProposalsResponse>;
+    /** GetProposalVotes queries votes for a specific proposal. */
+    getProposalVotes(request: QueryGetProposalVotesRequest): Promise<QueryGetProposalVotesResponse>;
+    /** GetCategory queries a single shared content category by id. */
+    getCategory(request: QueryGetCategoryRequest): Promise<QueryGetCategoryResponse>;
+    /** ListCategory queries all shared content categories. */
+    listCategory(request?: QueryAllCategoryRequest): Promise<QueryAllCategoryResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params: (request?: QueryParamsRequest) => Promise<QueryParamsResponse>;
+    getPolicyPermissions: (request: QueryGetPolicyPermissionsRequest) => Promise<QueryGetPolicyPermissionsResponse>;
+    listPolicyPermissions: (request?: QueryAllPolicyPermissionsRequest) => Promise<QueryAllPolicyPermissionsResponse>;
+    getGroup: (request: QueryGetGroupRequest) => Promise<QueryGetGroupResponse>;
+    listGroups: (request?: QueryAllGroupRequest) => Promise<QueryAllGroupResponse>;
+    getCouncilMembers: (request: QueryGetCouncilMembersRequest) => Promise<QueryGetCouncilMembersResponse>;
+    getProposal: (request: QueryGetProposalRequest) => Promise<QueryGetProposalResponse>;
+    listProposals: (request: QueryListProposalsRequest) => Promise<QueryListProposalsResponse>;
+    getProposalVotes: (request: QueryGetProposalVotesRequest) => Promise<QueryGetProposalVotesResponse>;
+    getCategory: (request: QueryGetCategoryRequest) => Promise<QueryGetCategoryResponse>;
+    listCategory: (request?: QueryAllCategoryRequest) => Promise<QueryAllCategoryResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    getPolicyPermissions(request: QueryGetPolicyPermissionsRequest): Promise<QueryGetPolicyPermissionsResponse>;
+    listPolicyPermissions(request?: QueryAllPolicyPermissionsRequest): Promise<QueryAllPolicyPermissionsResponse>;
+    getGroup(request: QueryGetGroupRequest): Promise<QueryGetGroupResponse>;
+    listGroups(request?: QueryAllGroupRequest): Promise<QueryAllGroupResponse>;
+    getCouncilMembers(request: QueryGetCouncilMembersRequest): Promise<QueryGetCouncilMembersResponse>;
+    getProposal(request: QueryGetProposalRequest): Promise<QueryGetProposalResponse>;
+    listProposals(request: QueryListProposalsRequest): Promise<QueryListProposalsResponse>;
+    getProposalVotes(request: QueryGetProposalVotesRequest): Promise<QueryGetProposalVotesResponse>;
+    getCategory(request: QueryGetCategoryRequest): Promise<QueryGetCategoryResponse>;
+    listCategory(request?: QueryAllCategoryRequest): Promise<QueryAllCategoryResponse>;
+};

package/sparkdream/commons/v1/query.rpc.Query.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Parameters queries the parameters of the module. */
+    params = async (request = {}) => {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListPolicyPermissions Queries a list of PolicyPermissions items. */
+    getPolicyPermissions = async (request) => {
+        const data = query_1.QueryGetPolicyPermissionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "GetPolicyPermissions", data);
+        return promise.then(data => query_1.QueryGetPolicyPermissionsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListPolicyPermissions defines the ListPolicyPermissions RPC. */
+    listPolicyPermissions = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryAllPolicyPermissionsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "ListPolicyPermissions", data);
+        return promise.then(data => query_1.QueryAllPolicyPermissionsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetGroup queries a specific group by name. */
+    getGroup = async (request) => {
+        const data = query_1.QueryGetGroupRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "GetGroup", data);
+        return promise.then(data => query_1.QueryGetGroupResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListGroups queries all groups. */
+    listGroups = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryAllGroupRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "ListGroups", data);
+        return promise.then(data => query_1.QueryAllGroupResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetCouncilMembers queries the members of a specific council. */
+    getCouncilMembers = async (request) => {
+        const data = query_1.QueryGetCouncilMembersRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "GetCouncilMembers", data);
+        return promise.then(data => query_1.QueryGetCouncilMembersResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetProposal queries a specific proposal by ID. */
+    getProposal = async (request) => {
+        const data = query_1.QueryGetProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "GetProposal", data);
+        return promise.then(data => query_1.QueryGetProposalResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListProposals queries all proposals with optional filtering. */
+    listProposals = async (request) => {
+        const data = query_1.QueryListProposalsRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "ListProposals", data);
+        return promise.then(data => query_1.QueryListProposalsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetProposalVotes queries votes for a specific proposal. */
+    getProposalVotes = async (request) => {
+        const data = query_1.QueryGetProposalVotesRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "GetProposalVotes", data);
+        return promise.then(data => query_1.QueryGetProposalVotesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* GetCategory queries a single shared content category by id. */
+    getCategory = async (request) => {
+        const data = query_1.QueryGetCategoryRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "GetCategory", data);
+        return promise.then(data => query_1.QueryGetCategoryResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* ListCategory queries all shared content categories. */
+    listCategory = async (request = {
+        pagination: undefined
+    }) => {
+        const data = query_1.QueryAllCategoryRequest.encode(request).finish();
+        const promise = this.rpc.request("sparkdream.commons.v1.Query", "ListCategory", data);
+        return promise.then(data => query_1.QueryAllCategoryResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        getPolicyPermissions(request) {
+            return queryService.getPolicyPermissions(request);
+        },
+        listPolicyPermissions(request) {
+            return queryService.listPolicyPermissions(request);
+        },
+        getGroup(request) {
+            return queryService.getGroup(request);
+        },
+        listGroups(request) {
+            return queryService.listGroups(request);
+        },
+        getCouncilMembers(request) {
+            return queryService.getCouncilMembers(request);
+        },
+        getProposal(request) {
+            return queryService.getProposal(request);
+        },
+        listProposals(request) {
+            return queryService.listProposals(request);
+        },
+        getProposalVotes(request) {
+            return queryService.getProposalVotes(request);
+        },
+        getCategory(request) {
+            return queryService.getCategory(request);
+        },
+        listCategory(request) {
+            return queryService.listCategory(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/sparkdream/commons/v1/tx.amino.d.ts

@@ -0,0 +1,98 @@
+import { MsgUpdateParams, MsgSpendFromCommons, MsgEmergencyCancelGovProposal, MsgCreatePolicyPermissions, MsgUpdatePolicyPermissions, MsgDeletePolicyPermissions, MsgRegisterGroup, MsgRenewGroup, MsgUpdateGroupMembers, MsgUpdateGroupConfig, MsgForceUpgrade, MsgDeleteGroup, MsgVetoGroupProposals, MsgSubmitProposal, MsgVoteProposal, MsgExecuteProposal, MsgSubmitAnonymousProposal, MsgAnonymousVoteProposal, MsgCreateCategory } from "./tx";
+export declare const AminoConverter: {
+    "/sparkdream.commons.v1.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+    "/sparkdream.commons.v1.MsgSpendFromCommons": {
+        aminoType: string;
+        toAmino: (message: MsgSpendFromCommons) => import("./tx").MsgSpendFromCommonsAmino;
+        fromAmino: (object: import("./tx").MsgSpendFromCommonsAmino) => MsgSpendFromCommons;
+    };
+    "/sparkdream.commons.v1.MsgEmergencyCancelGovProposal": {
+        aminoType: string;
+        toAmino: (message: MsgEmergencyCancelGovProposal) => import("./tx").MsgEmergencyCancelGovProposalAmino;
+        fromAmino: (object: import("./tx").MsgEmergencyCancelGovProposalAmino) => MsgEmergencyCancelGovProposal;
+    };
+    "/sparkdream.commons.v1.MsgCreatePolicyPermissions": {
+        aminoType: string;
+        toAmino: (message: MsgCreatePolicyPermissions) => import("./tx").MsgCreatePolicyPermissionsAmino;
+        fromAmino: (object: import("./tx").MsgCreatePolicyPermissionsAmino) => MsgCreatePolicyPermissions;
+    };
+    "/sparkdream.commons.v1.MsgUpdatePolicyPermissions": {
+        aminoType: string;
+        toAmino: (message: MsgUpdatePolicyPermissions) => import("./tx").MsgUpdatePolicyPermissionsAmino;
+        fromAmino: (object: import("./tx").MsgUpdatePolicyPermissionsAmino) => MsgUpdatePolicyPermissions;
+    };
+    "/sparkdream.commons.v1.MsgDeletePolicyPermissions": {
+        aminoType: string;
+        toAmino: (message: MsgDeletePolicyPermissions) => import("./tx").MsgDeletePolicyPermissionsAmino;
+        fromAmino: (object: import("./tx").MsgDeletePolicyPermissionsAmino) => MsgDeletePolicyPermissions;
+    };
+    "/sparkdream.commons.v1.MsgRegisterGroup": {
+        aminoType: string;
+        toAmino: (message: MsgRegisterGroup) => import("./tx").MsgRegisterGroupAmino;
+        fromAmino: (object: import("./tx").MsgRegisterGroupAmino) => MsgRegisterGroup;
+    };
+    "/sparkdream.commons.v1.MsgRenewGroup": {
+        aminoType: string;
+        toAmino: (message: MsgRenewGroup) => import("./tx").MsgRenewGroupAmino;
+        fromAmino: (object: import("./tx").MsgRenewGroupAmino) => MsgRenewGroup;
+    };
+    "/sparkdream.commons.v1.MsgUpdateGroupMembers": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupMembers) => import("./tx").MsgUpdateGroupMembersAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupMembersAmino) => MsgUpdateGroupMembers;
+    };
+    "/sparkdream.commons.v1.MsgUpdateGroupConfig": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupConfig) => import("./tx").MsgUpdateGroupConfigAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupConfigAmino) => MsgUpdateGroupConfig;
+    };
+    "/sparkdream.commons.v1.MsgForceUpgrade": {
+        aminoType: string;
+        toAmino: (message: MsgForceUpgrade) => import("./tx").MsgForceUpgradeAmino;
+        fromAmino: (object: import("./tx").MsgForceUpgradeAmino) => MsgForceUpgrade;
+    };
+    "/sparkdream.commons.v1.MsgDeleteGroup": {
+        aminoType: string;
+        toAmino: (message: MsgDeleteGroup) => import("./tx").MsgDeleteGroupAmino;
+        fromAmino: (object: import("./tx").MsgDeleteGroupAmino) => MsgDeleteGroup;
+    };
+    "/sparkdream.commons.v1.MsgVetoGroupProposals": {
+        aminoType: string;
+        toAmino: (message: MsgVetoGroupProposals) => import("./tx").MsgVetoGroupProposalsAmino;
+        fromAmino: (object: import("./tx").MsgVetoGroupProposalsAmino) => MsgVetoGroupProposals;
+    };
+    "/sparkdream.commons.v1.MsgSubmitProposal": {
+        aminoType: string;
+        toAmino: (message: MsgSubmitProposal) => import("./tx").MsgSubmitProposalAmino;
+        fromAmino: (object: import("./tx").MsgSubmitProposalAmino) => MsgSubmitProposal;
+    };
+    "/sparkdream.commons.v1.MsgVoteProposal": {
+        aminoType: string;
+        toAmino: (message: MsgVoteProposal) => import("./tx").MsgVoteProposalAmino;
+        fromAmino: (object: import("./tx").MsgVoteProposalAmino) => MsgVoteProposal;
+    };
+    "/sparkdream.commons.v1.MsgExecuteProposal": {
+        aminoType: string;
+        toAmino: (message: MsgExecuteProposal) => import("./tx").MsgExecuteProposalAmino;
+        fromAmino: (object: import("./tx").MsgExecuteProposalAmino) => MsgExecuteProposal;
+    };
+    "/sparkdream.commons.v1.MsgSubmitAnonymousProposal": {
+        aminoType: string;
+        toAmino: (message: MsgSubmitAnonymousProposal) => import("./tx").MsgSubmitAnonymousProposalAmino;
+        fromAmino: (object: import("./tx").MsgSubmitAnonymousProposalAmino) => MsgSubmitAnonymousProposal;
+    };
+    "/sparkdream.commons.v1.MsgAnonymousVoteProposal": {
+        aminoType: string;
+        toAmino: (message: MsgAnonymousVoteProposal) => import("./tx").MsgAnonymousVoteProposalAmino;
+        fromAmino: (object: import("./tx").MsgAnonymousVoteProposalAmino) => MsgAnonymousVoteProposal;
+    };
+    "/sparkdream.commons.v1.MsgCreateCategory": {
+        aminoType: string;
+        toAmino: (message: MsgCreateCategory) => import("./tx").MsgCreateCategoryAmino;
+        fromAmino: (object: import("./tx").MsgCreateCategoryAmino) => MsgCreateCategory;
+    };
+};

package/sparkdream/commons/v1/tx.amino.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/sparkdream.commons.v1.MsgUpdateParams": {
+        aminoType: "sparkdream/x/commons/MsgUpdateParams",
+        toAmino: tx_1.MsgUpdateParams.toAmino,
+        fromAmino: tx_1.MsgUpdateParams.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgSpendFromCommons": {
+        aminoType: "sparkdream/x/commons/MsgSpendFromCommons",
+        toAmino: tx_1.MsgSpendFromCommons.toAmino,
+        fromAmino: tx_1.MsgSpendFromCommons.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgEmergencyCancelGovProposal": {
+        aminoType: "sparkdream/x/commons/MsgEmergencyCancelGovProposal",
+        toAmino: tx_1.MsgEmergencyCancelGovProposal.toAmino,
+        fromAmino: tx_1.MsgEmergencyCancelGovProposal.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgCreatePolicyPermissions": {
+        aminoType: "/sparkdream.commons.v1.MsgCreatePolicyPermissions",
+        toAmino: tx_1.MsgCreatePolicyPermissions.toAmino,
+        fromAmino: tx_1.MsgCreatePolicyPermissions.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgUpdatePolicyPermissions": {
+        aminoType: "/sparkdream.commons.v1.MsgUpdatePolicyPermissions",
+        toAmino: tx_1.MsgUpdatePolicyPermissions.toAmino,
+        fromAmino: tx_1.MsgUpdatePolicyPermissions.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgDeletePolicyPermissions": {
+        aminoType: "/sparkdream.commons.v1.MsgDeletePolicyPermissions",
+        toAmino: tx_1.MsgDeletePolicyPermissions.toAmino,
+        fromAmino: tx_1.MsgDeletePolicyPermissions.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgRegisterGroup": {
+        aminoType: "/sparkdream.commons.v1.MsgRegisterGroup",
+        toAmino: tx_1.MsgRegisterGroup.toAmino,
+        fromAmino: tx_1.MsgRegisterGroup.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgRenewGroup": {
+        aminoType: "/sparkdream.commons.v1.MsgRenewGroup",
+        toAmino: tx_1.MsgRenewGroup.toAmino,
+        fromAmino: tx_1.MsgRenewGroup.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgUpdateGroupMembers": {
+        aminoType: "/sparkdream.commons.v1.MsgUpdateGroupMembers",
+        toAmino: tx_1.MsgUpdateGroupMembers.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupMembers.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgUpdateGroupConfig": {
+        aminoType: "/sparkdream.commons.v1.MsgUpdateGroupConfig",
+        toAmino: tx_1.MsgUpdateGroupConfig.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupConfig.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgForceUpgrade": {
+        aminoType: "/sparkdream.commons.v1.MsgForceUpgrade",
+        toAmino: tx_1.MsgForceUpgrade.toAmino,
+        fromAmino: tx_1.MsgForceUpgrade.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgDeleteGroup": {
+        aminoType: "/sparkdream.commons.v1.MsgDeleteGroup",
+        toAmino: tx_1.MsgDeleteGroup.toAmino,
+        fromAmino: tx_1.MsgDeleteGroup.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgVetoGroupProposals": {
+        aminoType: "/sparkdream.commons.v1.MsgVetoGroupProposals",
+        toAmino: tx_1.MsgVetoGroupProposals.toAmino,
+        fromAmino: tx_1.MsgVetoGroupProposals.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgSubmitProposal": {
+        aminoType: "/sparkdream.commons.v1.MsgSubmitProposal",
+        toAmino: tx_1.MsgSubmitProposal.toAmino,
+        fromAmino: tx_1.MsgSubmitProposal.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgVoteProposal": {
+        aminoType: "/sparkdream.commons.v1.MsgVoteProposal",
+        toAmino: tx_1.MsgVoteProposal.toAmino,
+        fromAmino: tx_1.MsgVoteProposal.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgExecuteProposal": {
+        aminoType: "/sparkdream.commons.v1.MsgExecuteProposal",
+        toAmino: tx_1.MsgExecuteProposal.toAmino,
+        fromAmino: tx_1.MsgExecuteProposal.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgSubmitAnonymousProposal": {
+        aminoType: "sparkdream/x/commons/MsgSubmitAnonymousProposal",
+        toAmino: tx_1.MsgSubmitAnonymousProposal.toAmino,
+        fromAmino: tx_1.MsgSubmitAnonymousProposal.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgAnonymousVoteProposal": {
+        aminoType: "sparkdream/x/commons/MsgAnonymousVoteProposal",
+        toAmino: tx_1.MsgAnonymousVoteProposal.toAmino,
+        fromAmino: tx_1.MsgAnonymousVoteProposal.fromAmino
+    },
+    "/sparkdream.commons.v1.MsgCreateCategory": {
+        aminoType: "sparkdream/x/commons/MsgCreateCategory",
+        toAmino: tx_1.MsgCreateCategory.toAmino,
+        fromAmino: tx_1.MsgCreateCategory.fromAmino
+    }
+};