@gitopia/gitopiajs 0.0.4 → 0.0.5

package/dist/esm/gitopia/gitopia/rewards/tx.js

@@ -0,0 +1,525 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseMsgCreateReward() {
+    return {
+        creator: "",
+        recipient: "",
+        amount: Coin.fromPartial({}),
+        series: 0
+    };
+}
+export const MsgCreateReward = {
+    typeUrl: "/gitopia.gitopia.rewards.MsgCreateReward",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.recipient !== "") {
+            writer.uint32(18).string(message.recipient);
+        }
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.series !== 0) {
+            writer.uint32(32).int32(message.series);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgCreateReward();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.recipient = reader.string();
+                    break;
+                case 3:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.series = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateReward();
+        message.creator = object.creator ?? "";
+        message.recipient = object.recipient ?? "";
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        message.series = object.series ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateReward();
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.recipient !== undefined && object.recipient !== null) {
+            message.recipient = object.recipient;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        if (object.series !== undefined && object.series !== null) {
+            message.series = object.series;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.recipient = message.recipient === "" ? undefined : message.recipient;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        obj.series = message.series === 0 ? undefined : message.series;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateReward.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCreateReward.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateReward.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.MsgCreateReward",
+            value: MsgCreateReward.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgCreateRewardResponse() {
+    return {
+        amount: Coin.fromPartial({})
+    };
+}
+export const MsgCreateRewardResponse = {
+    typeUrl: "/gitopia.gitopia.rewards.MsgCreateRewardResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgCreateRewardResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgCreateRewardResponse();
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgCreateRewardResponse();
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgCreateRewardResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgCreateRewardResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgCreateRewardResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.MsgCreateRewardResponse",
+            value: MsgCreateRewardResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgClaim() {
+    return {
+        creator: ""
+    };
+}
+export const MsgClaim = {
+    typeUrl: "/gitopia.gitopia.rewards.MsgClaim",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgClaim();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgClaim();
+        message.creator = object.creator ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgClaim();
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClaim.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgClaim.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClaim.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.MsgClaim",
+            value: MsgClaim.encode(message).finish()
+        };
+    }
+};
+function createBaseClaimResponseReward() {
+    return {
+        series: 0,
+        amount: Coin.fromPartial({})
+    };
+}
+export const ClaimResponseReward = {
+    typeUrl: "/gitopia.gitopia.rewards.ClaimResponseReward",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.series !== 0) {
+            writer.uint32(8).int32(message.series);
+        }
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseClaimResponseReward();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.series = reader.int32();
+                    break;
+                case 2:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseClaimResponseReward();
+        message.series = object.series ?? 0;
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseClaimResponseReward();
+        if (object.series !== undefined && object.series !== null) {
+            message.series = object.series;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.series = message.series === 0 ? undefined : message.series;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ClaimResponseReward.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ClaimResponseReward.decode(message.value);
+    },
+    toProto(message) {
+        return ClaimResponseReward.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.ClaimResponseReward",
+            value: ClaimResponseReward.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgClaimResponse() {
+    return {
+        claimedRewards: [],
+        expiredRewards: [],
+        allClaimedRewards: []
+    };
+}
+export const MsgClaimResponse = {
+    typeUrl: "/gitopia.gitopia.rewards.MsgClaimResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.claimedRewards) {
+            ClaimResponseReward.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.expiredRewards) {
+            ClaimResponseReward.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.allClaimedRewards) {
+            ClaimResponseReward.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgClaimResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.claimedRewards.push(ClaimResponseReward.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.expiredRewards.push(ClaimResponseReward.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.allClaimedRewards.push(ClaimResponseReward.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgClaimResponse();
+        message.claimedRewards = object.claimedRewards?.map(e => ClaimResponseReward.fromPartial(e)) || [];
+        message.expiredRewards = object.expiredRewards?.map(e => ClaimResponseReward.fromPartial(e)) || [];
+        message.allClaimedRewards = object.allClaimedRewards?.map(e => ClaimResponseReward.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgClaimResponse();
+        message.claimedRewards = object.claimed_rewards?.map(e => ClaimResponseReward.fromAmino(e)) || [];
+        message.expiredRewards = object.expired_rewards?.map(e => ClaimResponseReward.fromAmino(e)) || [];
+        message.allClaimedRewards = object.all_claimed_rewards?.map(e => ClaimResponseReward.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.claimedRewards) {
+            obj.claimed_rewards = message.claimedRewards.map(e => e ? ClaimResponseReward.toAmino(e) : undefined);
+        }
+        else {
+            obj.claimed_rewards = message.claimedRewards;
+        }
+        if (message.expiredRewards) {
+            obj.expired_rewards = message.expiredRewards.map(e => e ? ClaimResponseReward.toAmino(e) : undefined);
+        }
+        else {
+            obj.expired_rewards = message.expiredRewards;
+        }
+        if (message.allClaimedRewards) {
+            obj.all_claimed_rewards = message.allClaimedRewards.map(e => e ? ClaimResponseReward.toAmino(e) : undefined);
+        }
+        else {
+            obj.all_claimed_rewards = message.allClaimedRewards;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgClaimResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgClaimResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgClaimResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.MsgClaimResponse",
+            value: MsgClaimResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+export const MsgUpdateParams = {
+    typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParams",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgUpdateParams();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParams.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParamsResponse",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MsgUpdateParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    }
+};

package/dist/esm/gitopia/gitopia/rewards/tx.registry.js

@@ -0,0 +1,69 @@
+import { MsgClaim, MsgCreateReward, MsgUpdateParams } from "./tx";
+export const registry = [["/gitopia.gitopia.rewards.MsgClaim", MsgClaim], ["/gitopia.gitopia.rewards.MsgCreateReward", MsgCreateReward], ["/gitopia.gitopia.rewards.MsgUpdateParams", MsgUpdateParams]];
+export const load = (protoRegistry) => {
+    registry.forEach(([typeUrl, mod]) => {
+        protoRegistry.register(typeUrl, mod);
+    });
+};
+export const MessageComposer = {
+    encoded: {
+        claim(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgClaim",
+                value: MsgClaim.encode(value).finish()
+            };
+        },
+        createReward(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgCreateReward",
+                value: MsgCreateReward.encode(value).finish()
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParams",
+                value: MsgUpdateParams.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        claim(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgClaim",
+                value
+            };
+        },
+        createReward(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgCreateReward",
+                value
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParams",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        claim(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgClaim",
+                value: MsgClaim.fromPartial(value)
+            };
+        },
+        createReward(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgCreateReward",
+                value: MsgCreateReward.fromPartial(value)
+            };
+        },
+        updateParams(value) {
+            return {
+                typeUrl: "/gitopia.gitopia.rewards.MsgUpdateParams",
+                value: MsgUpdateParams.fromPartial(value)
+            };
+        }
+    }
+};

package/dist/esm/gitopia/gitopia/rewards/tx.rpc.msg.js

@@ -0,0 +1,26 @@
+import { BinaryReader } from "../../../binary";
+import { MsgClaim, MsgClaimResponse, MsgCreateReward, MsgCreateRewardResponse, MsgUpdateParams, MsgUpdateParamsResponse } from "./tx";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.claim = this.claim.bind(this);
+        this.createReward = this.createReward.bind(this);
+        this.updateParams = this.updateParams.bind(this);
+    }
+    claim(request) {
+        const data = MsgClaim.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Msg", "Claim", data);
+        return promise.then(data => MsgClaimResponse.decode(new BinaryReader(data)));
+    }
+    createReward(request) {
+        const data = MsgCreateReward.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Msg", "CreateReward", data);
+        return promise.then(data => MsgCreateRewardResponse.decode(new BinaryReader(data)));
+    }
+    updateParams(request) {
+        const data = MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Msg", "UpdateParams", data);
+        return promise.then(data => MsgUpdateParamsResponse.decode(new BinaryReader(data)));
+    }
+}

package/dist/esm/gitopia/rpc.query.js

@@ -0,0 +1,29 @@
+//@ts-nocheck
+import { Tendermint34Client } from "@cosmjs/tendermint-rpc";
+import { QueryClient } from "@cosmjs/stargate";
+export const createRPCQueryClient = async ({ rpcEndpoint }) => {
+    const tmClient = await Tendermint34Client.connect(rpcEndpoint);
+    const client = new QueryClient(tmClient);
+    return {
+        cosmos: {
+            bank: {
+                v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            feegrant: {
+                v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            gov: {
+                v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client)
+            },
+            group: {
+                v1: (await import("../cosmos/group/v1/query.rpc.Query")).createRpcQueryExtension(client)
+            }
+        },
+        gitopia: {
+            gitopia: {
+                gitopia: (await import("./gitopia/gitopia/query.rpc.Query")).createRpcQueryExtension(client),
+                rewards: (await import("./gitopia/rewards/query.rpc.Query")).createRpcQueryExtension(client)
+            }
+        }
+    };
+};

package/dist/esm/gitopia/rpc.tx.js

@@ -0,0 +1,13 @@
+export const createRPCMsgClient = async ({ rpc }) => ({
+    cosmos: {
+        group: {
+            v1: new (await import("../cosmos/group/v1/tx.rpc.msg")).MsgClientImpl(rpc)
+        }
+    },
+    gitopia: {
+        gitopia: {
+            gitopia: new (await import("./gitopia/gitopia/tx.rpc.msg")).MsgClientImpl(rpc),
+            rewards: new (await import("./gitopia/rewards/tx.rpc.msg")).MsgClientImpl(rpc)
+        }
+    }
+});

package/dist/esm/gogoproto/bundle.js

@@ -0,0 +1,5 @@
+//@ts-nocheck
+import * as _42 from "./gogo";
+export const gogoproto = {
+    ..._42
+};

package/dist/esm/gogoproto/gogo.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/google/api/annotations.js

@@ -0,0 +1 @@
+export {};