@gitopia/gitopiajs 0.0.4 → 0.0.6

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

@@ -0,0 +1,53 @@
+import { BinaryReader } from "../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryTasksRequest, QueryTasksResponse, QueryGetRewardRequest, QueryGetRewardResponse, QueryAllRewardsRequest, QueryAllRewardsResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.params = this.params.bind(this);
+        this.tasks = this.tasks.bind(this);
+        this.reward = this.reward.bind(this);
+        this.rewardsAll = this.rewardsAll.bind(this);
+    }
+    params(request = {}) {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+    }
+    tasks(request) {
+        const data = QueryTasksRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "Tasks", data);
+        return promise.then(data => QueryTasksResponse.decode(new BinaryReader(data)));
+    }
+    reward(request) {
+        const data = QueryGetRewardRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "Reward", data);
+        return promise.then(data => QueryGetRewardResponse.decode(new BinaryReader(data)));
+    }
+    rewardsAll(request = {
+        pagination: undefined
+    }) {
+        const data = QueryAllRewardsRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "RewardsAll", data);
+        return promise.then(data => QueryAllRewardsResponse.decode(new BinaryReader(data)));
+    }
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        tasks(request) {
+            return queryService.tasks(request);
+        },
+        reward(request) {
+            return queryService.reward(request);
+        },
+        rewardsAll(request) {
+            return queryService.rewardsAll(request);
+        }
+    };
+};

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

@@ -0,0 +1,191 @@
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseReward() {
+    return {
+        recipient: "",
+        rewards: []
+    };
+}
+export const Reward = {
+    typeUrl: "/gitopia.gitopia.rewards.Reward",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.recipient !== "") {
+            writer.uint32(10).string(message.recipient);
+        }
+        for (const v of message.rewards) {
+            RecipientReward.encode(v, 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 = createBaseReward();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.recipient = reader.string();
+                    break;
+                case 2:
+                    message.rewards.push(RecipientReward.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReward();
+        message.recipient = object.recipient ?? "";
+        message.rewards = object.rewards?.map(e => RecipientReward.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReward();
+        if (object.recipient !== undefined && object.recipient !== null) {
+            message.recipient = object.recipient;
+        }
+        message.rewards = object.rewards?.map(e => RecipientReward.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.recipient = message.recipient === "" ? undefined : message.recipient;
+        if (message.rewards) {
+            obj.rewards = message.rewards.map(e => e ? RecipientReward.toAmino(e) : undefined);
+        }
+        else {
+            obj.rewards = message.rewards;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Reward.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Reward.decode(message.value);
+    },
+    toProto(message) {
+        return Reward.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.Reward",
+            value: Reward.encode(message).finish()
+        };
+    }
+};
+function createBaseRecipientReward() {
+    return {
+        series: 0,
+        amount: Coin.fromPartial({}),
+        creator: "",
+        claimedAmount: Coin.fromPartial({}),
+        claimedAmountWithDecay: Coin.fromPartial({})
+    };
+}
+export const RecipientReward = {
+    typeUrl: "/gitopia.gitopia.rewards.RecipientReward",
+    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();
+        }
+        if (message.creator !== "") {
+            writer.uint32(26).string(message.creator);
+        }
+        if (message.claimedAmount !== undefined) {
+            Coin.encode(message.claimedAmount, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.claimedAmountWithDecay !== undefined) {
+            Coin.encode(message.claimedAmountWithDecay, writer.uint32(42).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 = createBaseRecipientReward();
+        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;
+                case 3:
+                    message.creator = reader.string();
+                    break;
+                case 4:
+                    message.claimedAmount = Coin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.claimedAmountWithDecay = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRecipientReward();
+        message.series = object.series ?? 0;
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        message.creator = object.creator ?? "";
+        message.claimedAmount = object.claimedAmount !== undefined && object.claimedAmount !== null ? Coin.fromPartial(object.claimedAmount) : undefined;
+        message.claimedAmountWithDecay = object.claimedAmountWithDecay !== undefined && object.claimedAmountWithDecay !== null ? Coin.fromPartial(object.claimedAmountWithDecay) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRecipientReward();
+        if (object.series !== undefined && object.series !== null) {
+            message.series = object.series;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.claimed_amount !== undefined && object.claimed_amount !== null) {
+            message.claimedAmount = Coin.fromAmino(object.claimed_amount);
+        }
+        if (object.claimed_amount_with_decay !== undefined && object.claimed_amount_with_decay !== null) {
+            message.claimedAmountWithDecay = Coin.fromAmino(object.claimed_amount_with_decay);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.series = message.series === 0 ? undefined : message.series;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.claimed_amount = message.claimedAmount ? Coin.toAmino(message.claimedAmount) : undefined;
+        obj.claimed_amount_with_decay = message.claimedAmountWithDecay ? Coin.toAmino(message.claimedAmountWithDecay) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RecipientReward.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RecipientReward.decode(message.value);
+    },
+    toProto(message) {
+        return RecipientReward.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.RecipientReward",
+            value: RecipientReward.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,176 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export var taskType;
+(function (taskType) {
+    taskType[taskType["UNKNOWN"] = 0] = "UNKNOWN";
+    taskType[taskType["CREATE_USER"] = 1] = "CREATE_USER";
+    taskType[taskType["CREATE_NON_EMPTY_REPO"] = 2] = "CREATE_NON_EMPTY_REPO";
+    taskType[taskType["CREATE_ISSUE"] = 3] = "CREATE_ISSUE";
+    taskType[taskType["CREATE_ISSUE_WITH_BOUNTY"] = 4] = "CREATE_ISSUE_WITH_BOUNTY";
+    taskType[taskType["CREATE_ISSUE_WITH_BOUNTY_VERIFIED"] = 5] = "CREATE_ISSUE_WITH_BOUNTY_VERIFIED";
+    taskType[taskType["PR_TO_REPO_MERGED"] = 6] = "PR_TO_REPO_MERGED";
+    taskType[taskType["PR_TO_VERIFIED_REPO_MERGED"] = 7] = "PR_TO_VERIFIED_REPO_MERGED";
+    taskType[taskType["PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY"] = 8] = "PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY";
+    taskType[taskType["LORE_STAKED"] = 9] = "LORE_STAKED";
+    taskType[taskType["VOTE_PROPOSAL"] = 10] = "VOTE_PROPOSAL";
+    taskType[taskType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(taskType || (taskType = {}));
+export const taskTypeSDKType = taskType;
+export const taskTypeAmino = taskType;
+export function taskTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "UNKNOWN":
+            return taskType.UNKNOWN;
+        case 1:
+        case "CREATE_USER":
+            return taskType.CREATE_USER;
+        case 2:
+        case "CREATE_NON_EMPTY_REPO":
+            return taskType.CREATE_NON_EMPTY_REPO;
+        case 3:
+        case "CREATE_ISSUE":
+            return taskType.CREATE_ISSUE;
+        case 4:
+        case "CREATE_ISSUE_WITH_BOUNTY":
+            return taskType.CREATE_ISSUE_WITH_BOUNTY;
+        case 5:
+        case "CREATE_ISSUE_WITH_BOUNTY_VERIFIED":
+            return taskType.CREATE_ISSUE_WITH_BOUNTY_VERIFIED;
+        case 6:
+        case "PR_TO_REPO_MERGED":
+            return taskType.PR_TO_REPO_MERGED;
+        case 7:
+        case "PR_TO_VERIFIED_REPO_MERGED":
+            return taskType.PR_TO_VERIFIED_REPO_MERGED;
+        case 8:
+        case "PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY":
+            return taskType.PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY;
+        case 9:
+        case "LORE_STAKED":
+            return taskType.LORE_STAKED;
+        case 10:
+        case "VOTE_PROPOSAL":
+            return taskType.VOTE_PROPOSAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return taskType.UNRECOGNIZED;
+    }
+}
+export function taskTypeToJSON(object) {
+    switch (object) {
+        case taskType.UNKNOWN:
+            return "UNKNOWN";
+        case taskType.CREATE_USER:
+            return "CREATE_USER";
+        case taskType.CREATE_NON_EMPTY_REPO:
+            return "CREATE_NON_EMPTY_REPO";
+        case taskType.CREATE_ISSUE:
+            return "CREATE_ISSUE";
+        case taskType.CREATE_ISSUE_WITH_BOUNTY:
+            return "CREATE_ISSUE_WITH_BOUNTY";
+        case taskType.CREATE_ISSUE_WITH_BOUNTY_VERIFIED:
+            return "CREATE_ISSUE_WITH_BOUNTY_VERIFIED";
+        case taskType.PR_TO_REPO_MERGED:
+            return "PR_TO_REPO_MERGED";
+        case taskType.PR_TO_VERIFIED_REPO_MERGED:
+            return "PR_TO_VERIFIED_REPO_MERGED";
+        case taskType.PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY:
+            return "PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY";
+        case taskType.LORE_STAKED:
+            return "LORE_STAKED";
+        case taskType.VOTE_PROPOSAL:
+            return "VOTE_PROPOSAL";
+        case taskType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseTask() {
+    return {
+        type: 0,
+        isComplete: false,
+        weight: 0
+    };
+}
+export const Task = {
+    typeUrl: "/gitopia.gitopia.rewards.Task",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== 0) {
+            writer.uint32(8).int32(message.type);
+        }
+        if (message.isComplete === true) {
+            writer.uint32(16).bool(message.isComplete);
+        }
+        if (message.weight !== 0) {
+            writer.uint32(24).int32(message.weight);
+        }
+        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 = createBaseTask();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.int32();
+                    break;
+                case 2:
+                    message.isComplete = reader.bool();
+                    break;
+                case 3:
+                    message.weight = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTask();
+        message.type = object.type ?? 0;
+        message.isComplete = object.isComplete ?? false;
+        message.weight = object.weight ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTask();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        if (object.isComplete !== undefined && object.isComplete !== null) {
+            message.isComplete = object.isComplete;
+        }
+        if (object.weight !== undefined && object.weight !== null) {
+            message.weight = object.weight;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type === 0 ? undefined : message.type;
+        obj.isComplete = message.isComplete === false ? undefined : message.isComplete;
+        obj.weight = message.weight === 0 ? undefined : message.weight;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Task.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Task.decode(message.value);
+    },
+    toProto(message) {
+        return Task.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.Task",
+            value: Task.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,19 @@
+//@ts-nocheck
+import { MsgClaim, MsgCreateReward, MsgUpdateParams } from "./tx";
+export const AminoConverter = {
+    "/gitopia.gitopia.rewards.MsgClaim": {
+        aminoType: "/gitopia.gitopia.rewards.MsgClaim",
+        toAmino: MsgClaim.toAmino,
+        fromAmino: MsgClaim.fromAmino
+    },
+    "/gitopia.gitopia.rewards.MsgCreateReward": {
+        aminoType: "/gitopia.gitopia.rewards.MsgCreateReward",
+        toAmino: MsgCreateReward.toAmino,
+        fromAmino: MsgCreateReward.fromAmino
+    },
+    "/gitopia.gitopia.rewards.MsgUpdateParams": {
+        aminoType: "/gitopia.gitopia.rewards.MsgUpdateParams",
+        toAmino: MsgUpdateParams.toAmino,
+        fromAmino: MsgUpdateParams.fromAmino
+    }
+};