@gitopia/gitopiajs 0.0.2

package/dist/esm/cosmos/group/v1/query.lcd.js

@@ -0,0 +1,154 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+        this.groupInfo = this.groupInfo.bind(this);
+        this.groupPolicyInfo = this.groupPolicyInfo.bind(this);
+        this.groupMembers = this.groupMembers.bind(this);
+        this.groupsByAdmin = this.groupsByAdmin.bind(this);
+        this.groupPoliciesByGroup = this.groupPoliciesByGroup.bind(this);
+        this.groupPoliciesByAdmin = this.groupPoliciesByAdmin.bind(this);
+        this.proposal = this.proposal.bind(this);
+        this.proposalsByGroupPolicy = this.proposalsByGroupPolicy.bind(this);
+        this.voteByProposalVoter = this.voteByProposalVoter.bind(this);
+        this.votesByProposal = this.votesByProposal.bind(this);
+        this.votesByVoter = this.votesByVoter.bind(this);
+        this.groupsByMember = this.groupsByMember.bind(this);
+        this.tallyResult = this.tallyResult.bind(this);
+        this.groups = this.groups.bind(this);
+    }
+    /* GroupInfo queries group info based on group id. */
+    async groupInfo(params) {
+        const endpoint = `cosmos/group/v1/group_info/${params.groupId}`;
+        return await this.req.get(endpoint);
+    }
+    /* GroupPolicyInfo queries group policy info based on account address of group policy. */
+    async groupPolicyInfo(params) {
+        const endpoint = `cosmos/group/v1/group_policy_info/${params.address}`;
+        return await this.req.get(endpoint);
+    }
+    /* GroupMembers queries members of a group by group id. */
+    async groupMembers(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/group_members/${params.groupId}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupsByAdmin queries groups by admin address. */
+    async groupsByAdmin(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/groups_by_admin/${params.admin}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupPoliciesByGroup queries group policies by group id. */
+    async groupPoliciesByGroup(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/group_policies_by_group/${params.groupId}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupPoliciesByAdmin queries group policies by admin address. */
+    async groupPoliciesByAdmin(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/group_policies_by_admin/${params.admin}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* Proposal queries a proposal based on proposal id. */
+    async proposal(params) {
+        const endpoint = `cosmos/group/v1/proposal/${params.proposalId}`;
+        return await this.req.get(endpoint);
+    }
+    /* ProposalsByGroupPolicy queries proposals based on account address of group policy. */
+    async proposalsByGroupPolicy(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/proposals_by_group_policy/${params.address}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* VoteByProposalVoter queries a vote by proposal id and voter. */
+    async voteByProposalVoter(params) {
+        const endpoint = `cosmos/group/v1/vote_by_proposal_voter/${params.proposalId}/${params.voter}`;
+        return await this.req.get(endpoint);
+    }
+    /* VotesByProposal queries a vote by proposal id. */
+    async votesByProposal(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/votes_by_proposal/${params.proposalId}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* VotesByVoter queries a vote by voter. */
+    async votesByVoter(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/votes_by_voter/${params.voter}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupsByMember queries groups by member address. */
+    async groupsByMember(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/groups_by_member/${params.address}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* TallyResult returns the tally result of a proposal. If the proposal is
+     still in voting period, then this query computes the current tally state,
+     which might not be final. On the other hand, if the proposal is final,
+     then it simply returns the `final_tally_result` state stored in the
+     proposal itself. */
+    async tallyResult(params) {
+        const endpoint = `cosmos/group/v1/proposals/${params.proposalId}/tally`;
+        return await this.req.get(endpoint);
+    }
+    /* Groups queries all groups in state.
+    
+     Since: cosmos-sdk 0.47.1 */
+    async groups(params = {
+        pagination: undefined
+    }) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            setPaginationParams(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/groups`;
+        return await this.req.get(endpoint, options);
+    }
+}

package/dist/esm/cosmos/group/v1/query.rpc.Query.js

@@ -0,0 +1,143 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryGroupInfoRequest, QueryGroupInfoResponse, QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponse, QueryGroupMembersRequest, QueryGroupMembersResponse, QueryGroupsByAdminRequest, QueryGroupsByAdminResponse, QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponse, QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponse, QueryProposalRequest, QueryProposalResponse, QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponse, QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponse, QueryVotesByProposalRequest, QueryVotesByProposalResponse, QueryVotesByVoterRequest, QueryVotesByVoterResponse, QueryGroupsByMemberRequest, QueryGroupsByMemberResponse, QueryTallyResultRequest, QueryTallyResultResponse, QueryGroupsRequest, QueryGroupsResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.groupInfo = this.groupInfo.bind(this);
+        this.groupPolicyInfo = this.groupPolicyInfo.bind(this);
+        this.groupMembers = this.groupMembers.bind(this);
+        this.groupsByAdmin = this.groupsByAdmin.bind(this);
+        this.groupPoliciesByGroup = this.groupPoliciesByGroup.bind(this);
+        this.groupPoliciesByAdmin = this.groupPoliciesByAdmin.bind(this);
+        this.proposal = this.proposal.bind(this);
+        this.proposalsByGroupPolicy = this.proposalsByGroupPolicy.bind(this);
+        this.voteByProposalVoter = this.voteByProposalVoter.bind(this);
+        this.votesByProposal = this.votesByProposal.bind(this);
+        this.votesByVoter = this.votesByVoter.bind(this);
+        this.groupsByMember = this.groupsByMember.bind(this);
+        this.tallyResult = this.tallyResult.bind(this);
+        this.groups = this.groups.bind(this);
+    }
+    groupInfo(request) {
+        const data = QueryGroupInfoRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupInfo", data);
+        return promise.then(data => QueryGroupInfoResponse.decode(new BinaryReader(data)));
+    }
+    groupPolicyInfo(request) {
+        const data = QueryGroupPolicyInfoRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupPolicyInfo", data);
+        return promise.then(data => QueryGroupPolicyInfoResponse.decode(new BinaryReader(data)));
+    }
+    groupMembers(request) {
+        const data = QueryGroupMembersRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupMembers", data);
+        return promise.then(data => QueryGroupMembersResponse.decode(new BinaryReader(data)));
+    }
+    groupsByAdmin(request) {
+        const data = QueryGroupsByAdminRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupsByAdmin", data);
+        return promise.then(data => QueryGroupsByAdminResponse.decode(new BinaryReader(data)));
+    }
+    groupPoliciesByGroup(request) {
+        const data = QueryGroupPoliciesByGroupRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupPoliciesByGroup", data);
+        return promise.then(data => QueryGroupPoliciesByGroupResponse.decode(new BinaryReader(data)));
+    }
+    groupPoliciesByAdmin(request) {
+        const data = QueryGroupPoliciesByAdminRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupPoliciesByAdmin", data);
+        return promise.then(data => QueryGroupPoliciesByAdminResponse.decode(new BinaryReader(data)));
+    }
+    proposal(request) {
+        const data = QueryProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "Proposal", data);
+        return promise.then(data => QueryProposalResponse.decode(new BinaryReader(data)));
+    }
+    proposalsByGroupPolicy(request) {
+        const data = QueryProposalsByGroupPolicyRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "ProposalsByGroupPolicy", data);
+        return promise.then(data => QueryProposalsByGroupPolicyResponse.decode(new BinaryReader(data)));
+    }
+    voteByProposalVoter(request) {
+        const data = QueryVoteByProposalVoterRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "VoteByProposalVoter", data);
+        return promise.then(data => QueryVoteByProposalVoterResponse.decode(new BinaryReader(data)));
+    }
+    votesByProposal(request) {
+        const data = QueryVotesByProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "VotesByProposal", data);
+        return promise.then(data => QueryVotesByProposalResponse.decode(new BinaryReader(data)));
+    }
+    votesByVoter(request) {
+        const data = QueryVotesByVoterRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "VotesByVoter", data);
+        return promise.then(data => QueryVotesByVoterResponse.decode(new BinaryReader(data)));
+    }
+    groupsByMember(request) {
+        const data = QueryGroupsByMemberRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupsByMember", data);
+        return promise.then(data => QueryGroupsByMemberResponse.decode(new BinaryReader(data)));
+    }
+    tallyResult(request) {
+        const data = QueryTallyResultRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "TallyResult", data);
+        return promise.then(data => QueryTallyResultResponse.decode(new BinaryReader(data)));
+    }
+    groups(request = {
+        pagination: undefined
+    }) {
+        const data = QueryGroupsRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "Groups", data);
+        return promise.then(data => QueryGroupsResponse.decode(new BinaryReader(data)));
+    }
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        groupInfo(request) {
+            return queryService.groupInfo(request);
+        },
+        groupPolicyInfo(request) {
+            return queryService.groupPolicyInfo(request);
+        },
+        groupMembers(request) {
+            return queryService.groupMembers(request);
+        },
+        groupsByAdmin(request) {
+            return queryService.groupsByAdmin(request);
+        },
+        groupPoliciesByGroup(request) {
+            return queryService.groupPoliciesByGroup(request);
+        },
+        groupPoliciesByAdmin(request) {
+            return queryService.groupPoliciesByAdmin(request);
+        },
+        proposal(request) {
+            return queryService.proposal(request);
+        },
+        proposalsByGroupPolicy(request) {
+            return queryService.proposalsByGroupPolicy(request);
+        },
+        voteByProposalVoter(request) {
+            return queryService.voteByProposalVoter(request);
+        },
+        votesByProposal(request) {
+            return queryService.votesByProposal(request);
+        },
+        votesByVoter(request) {
+            return queryService.votesByVoter(request);
+        },
+        groupsByMember(request) {
+            return queryService.groupsByMember(request);
+        },
+        tallyResult(request) {
+            return queryService.tallyResult(request);
+        },
+        groups(request) {
+            return queryService.groups(request);
+        }
+    };
+};

package/dist/esm/cosmos/group/v1/tx.amino.js

@@ -0,0 +1,74 @@
+//@ts-nocheck
+import { MsgCreateGroup, MsgUpdateGroupMembers, MsgUpdateGroupAdmin, MsgUpdateGroupMetadata, MsgCreateGroupPolicy, MsgCreateGroupWithPolicy, MsgUpdateGroupPolicyAdmin, MsgUpdateGroupPolicyDecisionPolicy, MsgUpdateGroupPolicyMetadata, MsgSubmitProposal, MsgWithdrawProposal, MsgVote, MsgExec, MsgLeaveGroup } from "./tx";
+export const AminoConverter = {
+    "/cosmos.group.v1.MsgCreateGroup": {
+        aminoType: "cosmos-sdk/MsgCreateGroup",
+        toAmino: MsgCreateGroup.toAmino,
+        fromAmino: MsgCreateGroup.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupMembers": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupMembers",
+        toAmino: MsgUpdateGroupMembers.toAmino,
+        fromAmino: MsgUpdateGroupMembers.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupAdmin": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupAdmin",
+        toAmino: MsgUpdateGroupAdmin.toAmino,
+        fromAmino: MsgUpdateGroupAdmin.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupMetadata": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupMetadata",
+        toAmino: MsgUpdateGroupMetadata.toAmino,
+        fromAmino: MsgUpdateGroupMetadata.fromAmino
+    },
+    "/cosmos.group.v1.MsgCreateGroupPolicy": {
+        aminoType: "cosmos-sdk/MsgCreateGroupPolicy",
+        toAmino: MsgCreateGroupPolicy.toAmino,
+        fromAmino: MsgCreateGroupPolicy.fromAmino
+    },
+    "/cosmos.group.v1.MsgCreateGroupWithPolicy": {
+        aminoType: "cosmos-sdk/MsgCreateGroupWithPolicy",
+        toAmino: MsgCreateGroupWithPolicy.toAmino,
+        fromAmino: MsgCreateGroupWithPolicy.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupPolicyAdmin": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupPolicyAdmin",
+        toAmino: MsgUpdateGroupPolicyAdmin.toAmino,
+        fromAmino: MsgUpdateGroupPolicyAdmin.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupPolicyDecisionPolicy": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupDecisionPolicy",
+        toAmino: MsgUpdateGroupPolicyDecisionPolicy.toAmino,
+        fromAmino: MsgUpdateGroupPolicyDecisionPolicy.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupPolicyMetadata": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupPolicyMetadata",
+        toAmino: MsgUpdateGroupPolicyMetadata.toAmino,
+        fromAmino: MsgUpdateGroupPolicyMetadata.fromAmino
+    },
+    "/cosmos.group.v1.MsgSubmitProposal": {
+        aminoType: "cosmos-sdk/group/MsgSubmitProposal",
+        toAmino: MsgSubmitProposal.toAmino,
+        fromAmino: MsgSubmitProposal.fromAmino
+    },
+    "/cosmos.group.v1.MsgWithdrawProposal": {
+        aminoType: "cosmos-sdk/group/MsgWithdrawProposal",
+        toAmino: MsgWithdrawProposal.toAmino,
+        fromAmino: MsgWithdrawProposal.fromAmino
+    },
+    "/cosmos.group.v1.MsgVote": {
+        aminoType: "cosmos-sdk/group/MsgVote",
+        toAmino: MsgVote.toAmino,
+        fromAmino: MsgVote.fromAmino
+    },
+    "/cosmos.group.v1.MsgExec": {
+        aminoType: "cosmos-sdk/group/MsgExec",
+        toAmino: MsgExec.toAmino,
+        fromAmino: MsgExec.fromAmino
+    },
+    "/cosmos.group.v1.MsgLeaveGroup": {
+        aminoType: "cosmos-sdk/group/MsgLeaveGroup",
+        toAmino: MsgLeaveGroup.toAmino,
+        fromAmino: MsgLeaveGroup.fromAmino
+    }
+};