@gitopia/gitopiajs 0.0.4 → 0.0.6

package/dist/gitopia/gitopia/rewards/query.lcd.js

@@ -0,0 +1,44 @@
+"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;
+        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 returns the total set of rewards parameters. */
+    async params(_params = {}) {
+        const endpoint = `gitopia/gitopia/rewards/params`;
+        return await this.req.get(endpoint);
+    }
+    /* Queries a list of tasks items. */
+    async tasks(params) {
+        const endpoint = `gitopia/gitopia/rewards/tasks/${params.address}`;
+        return await this.req.get(endpoint);
+    }
+    /* Queries a Rewards by index. */
+    async reward(params) {
+        const endpoint = `gitopia/gitopia/rewards/rewards/${params.recipient}`;
+        return await this.req.get(endpoint);
+    }
+    /* Queries a list of Rewards items. */
+    async rewardsAll(params = {
+        pagination: undefined
+    }) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `gitopia/gitopia/rewards/rewards`;
+        return await this.req.get(endpoint, options);
+    }
+}
+exports.LCDQueryClient = LCDQueryClient;

package/dist/gitopia/gitopia/rewards/query.rpc.Query.d.ts

@@ -0,0 +1,28 @@
+import { Rpc } from "../../../helpers";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryTasksRequest, QueryTasksResponse, QueryGetRewardRequest, QueryGetRewardResponse, QueryAllRewardsRequest, QueryAllRewardsResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Params returns the total set of rewards parameters. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** Queries a list of tasks items. */
+    tasks(request: QueryTasksRequest): Promise<QueryTasksResponse>;
+    /** Queries a Rewards by index. */
+    reward(request: QueryGetRewardRequest): Promise<QueryGetRewardResponse>;
+    /** Queries a list of Rewards items. */
+    rewardsAll(request?: QueryAllRewardsRequest): Promise<QueryAllRewardsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    tasks(request: QueryTasksRequest): Promise<QueryTasksResponse>;
+    reward(request: QueryGetRewardRequest): Promise<QueryGetRewardResponse>;
+    rewardsAll(request?: QueryAllRewardsRequest): Promise<QueryAllRewardsResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    tasks(request: QueryTasksRequest): Promise<QueryTasksResponse>;
+    reward(request: QueryGetRewardRequest): Promise<QueryGetRewardResponse>;
+    rewardsAll(request?: QueryAllRewardsRequest): Promise<QueryAllRewardsResponse>;
+};

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

@@ -0,0 +1,58 @@
+"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;
+        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 = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    tasks(request) {
+        const data = query_1.QueryTasksRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "Tasks", data);
+        return promise.then(data => query_1.QueryTasksResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    reward(request) {
+        const data = query_1.QueryGetRewardRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "Reward", data);
+        return promise.then(data => query_1.QueryGetRewardResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    rewardsAll(request = {
+        pagination: undefined
+    }) {
+        const data = query_1.QueryAllRewardsRequest.encode(request).finish();
+        const promise = this.rpc.request("gitopia.gitopia.rewards.Query", "RewardsAll", data);
+        return promise.then(data => query_1.QueryAllRewardsResponse.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);
+        },
+        tasks(request) {
+            return queryService.tasks(request);
+        },
+        reward(request) {
+            return queryService.reward(request);
+        },
+        rewardsAll(request) {
+            return queryService.rewardsAll(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/dist/gitopia/gitopia/rewards/rewards.d.ts

@@ -0,0 +1,79 @@
+import { Series } from "./pool";
+import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** a map from recipient to all her rewards */
+export interface Reward {
+    recipient: string;
+    rewards: RecipientReward[];
+}
+export interface RewardProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.Reward";
+    value: Uint8Array;
+}
+/** a map from recipient to all her rewards */
+export interface RewardAmino {
+    recipient?: string;
+    rewards?: RecipientRewardAmino[];
+}
+export interface RewardAminoMsg {
+    type: "/gitopia.gitopia.rewards.Reward";
+    value: RewardAmino;
+}
+/** a map from recipient to all her rewards */
+export interface RewardSDKType {
+    recipient: string;
+    rewards: RecipientRewardSDKType[];
+}
+export interface RecipientReward {
+    series: Series;
+    amount: Coin;
+    creator: string;
+    claimedAmount: Coin;
+    claimedAmountWithDecay: Coin;
+}
+export interface RecipientRewardProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.RecipientReward";
+    value: Uint8Array;
+}
+export interface RecipientRewardAmino {
+    series?: Series;
+    amount?: CoinAmino;
+    creator?: string;
+    claimed_amount?: CoinAmino;
+    claimed_amount_with_decay?: CoinAmino;
+}
+export interface RecipientRewardAminoMsg {
+    type: "/gitopia.gitopia.rewards.RecipientReward";
+    value: RecipientRewardAmino;
+}
+export interface RecipientRewardSDKType {
+    series: Series;
+    amount: CoinSDKType;
+    creator: string;
+    claimed_amount: CoinSDKType;
+    claimed_amount_with_decay: CoinSDKType;
+}
+export declare const Reward: {
+    typeUrl: string;
+    encode(message: Reward, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Reward;
+    fromPartial(object: Partial<Reward>): Reward;
+    fromAmino(object: RewardAmino): Reward;
+    toAmino(message: Reward): RewardAmino;
+    fromAminoMsg(object: RewardAminoMsg): Reward;
+    fromProtoMsg(message: RewardProtoMsg): Reward;
+    toProto(message: Reward): Uint8Array;
+    toProtoMsg(message: Reward): RewardProtoMsg;
+};
+export declare const RecipientReward: {
+    typeUrl: string;
+    encode(message: RecipientReward, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RecipientReward;
+    fromPartial(object: Partial<RecipientReward>): RecipientReward;
+    fromAmino(object: RecipientRewardAmino): RecipientReward;
+    toAmino(message: RecipientReward): RecipientRewardAmino;
+    fromAminoMsg(object: RecipientRewardAminoMsg): RecipientReward;
+    fromProtoMsg(message: RecipientRewardProtoMsg): RecipientReward;
+    toProto(message: RecipientReward): Uint8Array;
+    toProtoMsg(message: RecipientReward): RecipientRewardProtoMsg;
+};

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

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipientReward = exports.Reward = void 0;
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const binary_1 = require("../../../binary");
+function createBaseReward() {
+    return {
+        recipient: "",
+        rewards: []
+    };
+}
+exports.Reward = {
+    typeUrl: "/gitopia.gitopia.rewards.Reward",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.recipient !== "") {
+            writer.uint32(10).string(message.recipient);
+        }
+        for (const v of message.rewards) {
+            exports.RecipientReward.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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(exports.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 => exports.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 => exports.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 ? exports.RecipientReward.toAmino(e) : undefined);
+        }
+        else {
+            obj.rewards = message.rewards;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Reward.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Reward.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Reward.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.Reward",
+            value: exports.Reward.encode(message).finish()
+        };
+    }
+};
+function createBaseRecipientReward() {
+    return {
+        series: 0,
+        amount: coin_1.Coin.fromPartial({}),
+        creator: "",
+        claimedAmount: coin_1.Coin.fromPartial({}),
+        claimedAmountWithDecay: coin_1.Coin.fromPartial({})
+    };
+}
+exports.RecipientReward = {
+    typeUrl: "/gitopia.gitopia.rewards.RecipientReward",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.series !== 0) {
+            writer.uint32(8).int32(message.series);
+        }
+        if (message.amount !== undefined) {
+            coin_1.Coin.encode(message.amount, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.creator !== "") {
+            writer.uint32(26).string(message.creator);
+        }
+        if (message.claimedAmount !== undefined) {
+            coin_1.Coin.encode(message.claimedAmount, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.claimedAmountWithDecay !== undefined) {
+            coin_1.Coin.encode(message.claimedAmountWithDecay, writer.uint32(42).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.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_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.creator = reader.string();
+                    break;
+                case 4:
+                    message.claimedAmount = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.claimedAmountWithDecay = coin_1.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_1.Coin.fromPartial(object.amount) : undefined;
+        message.creator = object.creator ?? "";
+        message.claimedAmount = object.claimedAmount !== undefined && object.claimedAmount !== null ? coin_1.Coin.fromPartial(object.claimedAmount) : undefined;
+        message.claimedAmountWithDecay = object.claimedAmountWithDecay !== undefined && object.claimedAmountWithDecay !== null ? coin_1.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_1.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_1.Coin.fromAmino(object.claimed_amount);
+        }
+        if (object.claimed_amount_with_decay !== undefined && object.claimed_amount_with_decay !== null) {
+            message.claimedAmountWithDecay = coin_1.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_1.Coin.toAmino(message.amount) : undefined;
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.claimed_amount = message.claimedAmount ? coin_1.Coin.toAmino(message.claimedAmount) : undefined;
+        obj.claimed_amount_with_decay = message.claimedAmountWithDecay ? coin_1.Coin.toAmino(message.claimedAmountWithDecay) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.RecipientReward.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.RecipientReward.decode(message.value);
+    },
+    toProto(message) {
+        return exports.RecipientReward.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.RecipientReward",
+            value: exports.RecipientReward.encode(message).finish()
+        };
+    }
+};

package/dist/gitopia/gitopia/rewards/task.d.ts

@@ -0,0 +1,54 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export declare enum taskType {
+    UNKNOWN = 0,
+    CREATE_USER = 1,
+    CREATE_NON_EMPTY_REPO = 2,
+    CREATE_ISSUE = 3,
+    CREATE_ISSUE_WITH_BOUNTY = 4,
+    CREATE_ISSUE_WITH_BOUNTY_VERIFIED = 5,
+    PR_TO_REPO_MERGED = 6,
+    PR_TO_VERIFIED_REPO_MERGED = 7,
+    PR_TO_VERIFIED_REPO_MERGED_WITH_BOUNTY = 8,
+    LORE_STAKED = 9,
+    VOTE_PROPOSAL = 10,
+    UNRECOGNIZED = -1
+}
+export declare const taskTypeSDKType: typeof taskType;
+export declare const taskTypeAmino: typeof taskType;
+export declare function taskTypeFromJSON(object: any): taskType;
+export declare function taskTypeToJSON(object: taskType): string;
+export interface Task {
+    type: taskType;
+    isComplete: boolean;
+    weight: number;
+}
+export interface TaskProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.Task";
+    value: Uint8Array;
+}
+export interface TaskAmino {
+    type?: taskType;
+    isComplete?: boolean;
+    weight?: number;
+}
+export interface TaskAminoMsg {
+    type: "/gitopia.gitopia.rewards.Task";
+    value: TaskAmino;
+}
+export interface TaskSDKType {
+    type: taskType;
+    isComplete: boolean;
+    weight: number;
+}
+export declare const Task: {
+    typeUrl: string;
+    encode(message: Task, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Task;
+    fromPartial(object: Partial<Task>): Task;
+    fromAmino(object: TaskAmino): Task;
+    toAmino(message: Task): TaskAmino;
+    fromAminoMsg(object: TaskAminoMsg): Task;
+    fromProtoMsg(message: TaskProtoMsg): Task;
+    toProto(message: Task): Uint8Array;
+    toProtoMsg(message: Task): TaskProtoMsg;
+};

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

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = exports.taskTypeAmino = exports.taskTypeSDKType = exports.taskType = void 0;
+exports.taskTypeFromJSON = taskTypeFromJSON;
+exports.taskTypeToJSON = taskTypeToJSON;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+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 || (exports.taskType = taskType = {}));
+exports.taskTypeSDKType = taskType;
+exports.taskTypeAmino = taskType;
+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;
+    }
+}
+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
+    };
+}
+exports.Task = {
+    typeUrl: "/gitopia.gitopia.rewards.Task",
+    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 exports.Task.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Task.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Task.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.Task",
+            value: exports.Task.encode(message).finish()
+        };
+    }
+};

package/dist/gitopia/gitopia/rewards/tx.amino.d.ts

@@ -0,0 +1,18 @@
+import { MsgClaim, MsgCreateReward, MsgUpdateParams } from "./tx";
+export declare const AminoConverter: {
+    "/gitopia.gitopia.rewards.MsgClaim": {
+        aminoType: string;
+        toAmino: (message: MsgClaim) => import("./tx").MsgClaimAmino;
+        fromAmino: (object: import("./tx").MsgClaimAmino) => MsgClaim;
+    };
+    "/gitopia.gitopia.rewards.MsgCreateReward": {
+        aminoType: string;
+        toAmino: (message: MsgCreateReward) => import("./tx").MsgCreateRewardAmino;
+        fromAmino: (object: import("./tx").MsgCreateRewardAmino) => MsgCreateReward;
+    };
+    "/gitopia.gitopia.rewards.MsgUpdateParams": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateParams) => import("./tx").MsgUpdateParamsAmino;
+        fromAmino: (object: import("./tx").MsgUpdateParamsAmino) => MsgUpdateParams;
+    };
+};

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/gitopia.gitopia.rewards.MsgClaim": {
+        aminoType: "/gitopia.gitopia.rewards.MsgClaim",
+        toAmino: tx_1.MsgClaim.toAmino,
+        fromAmino: tx_1.MsgClaim.fromAmino
+    },
+    "/gitopia.gitopia.rewards.MsgCreateReward": {
+        aminoType: "/gitopia.gitopia.rewards.MsgCreateReward",
+        toAmino: tx_1.MsgCreateReward.toAmino,
+        fromAmino: tx_1.MsgCreateReward.fromAmino
+    },
+    "/gitopia.gitopia.rewards.MsgUpdateParams": {
+        aminoType: "/gitopia.gitopia.rewards.MsgUpdateParams",
+        toAmino: tx_1.MsgUpdateParams.toAmino,
+        fromAmino: tx_1.MsgUpdateParams.fromAmino
+    }
+};