@gitopia/gitopiajs 0.0.4 → 0.0.6

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

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardPool = exports.SeriesAmino = exports.SeriesSDKType = exports.Series = void 0;
+exports.seriesFromJSON = seriesFromJSON;
+exports.seriesToJSON = seriesToJSON;
+//@ts-nocheck
+const coin_1 = require("../../../cosmos/base/v1beta1/coin");
+const timestamp_1 = require("../../../google/protobuf/timestamp");
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+var Series;
+(function (Series) {
+    Series[Series["NONE"] = 0] = "NONE";
+    Series[Series["ONE"] = 1] = "ONE";
+    Series[Series["TWO"] = 2] = "TWO";
+    Series[Series["THREE"] = 3] = "THREE";
+    Series[Series["FOUR"] = 4] = "FOUR";
+    Series[Series["FIVE"] = 5] = "FIVE";
+    Series[Series["SIX"] = 6] = "SIX";
+    Series[Series["SEVEN"] = 7] = "SEVEN";
+    Series[Series["COSMOS"] = 8] = "COSMOS";
+    Series[Series["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Series || (exports.Series = Series = {}));
+exports.SeriesSDKType = Series;
+exports.SeriesAmino = Series;
+function seriesFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "NONE":
+            return Series.NONE;
+        case 1:
+        case "ONE":
+            return Series.ONE;
+        case 2:
+        case "TWO":
+            return Series.TWO;
+        case 3:
+        case "THREE":
+            return Series.THREE;
+        case 4:
+        case "FOUR":
+            return Series.FOUR;
+        case 5:
+        case "FIVE":
+            return Series.FIVE;
+        case 6:
+        case "SIX":
+            return Series.SIX;
+        case 7:
+        case "SEVEN":
+            return Series.SEVEN;
+        case 8:
+        case "COSMOS":
+            return Series.COSMOS;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Series.UNRECOGNIZED;
+    }
+}
+function seriesToJSON(object) {
+    switch (object) {
+        case Series.NONE:
+            return "NONE";
+        case Series.ONE:
+            return "ONE";
+        case Series.TWO:
+            return "TWO";
+        case Series.THREE:
+            return "THREE";
+        case Series.FOUR:
+            return "FOUR";
+        case Series.FIVE:
+            return "FIVE";
+        case Series.SIX:
+            return "SIX";
+        case Series.SEVEN:
+            return "SEVEN";
+        case Series.COSMOS:
+            return "COSMOS";
+        case Series.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseRewardPool() {
+    return {
+        totalAmount: coin_1.Coin.fromPartial({}),
+        claimedAmount: coin_1.Coin.fromPartial({}),
+        startTime: new Date(),
+        endTime: new Date(),
+        series: 0
+    };
+}
+exports.RewardPool = {
+    typeUrl: "/gitopia.gitopia.rewards.RewardPool",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.totalAmount !== undefined) {
+            coin_1.Coin.encode(message.totalAmount, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.claimedAmount !== undefined) {
+            coin_1.Coin.encode(message.claimedAmount, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.startTime !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.toTimestamp)(message.startTime), writer.uint32(26).fork()).ldelim();
+        }
+        if (message.endTime !== undefined) {
+            timestamp_1.Timestamp.encode((0, helpers_1.toTimestamp)(message.endTime), writer.uint32(34).fork()).ldelim();
+        }
+        if (message.series !== 0) {
+            writer.uint32(40).int32(message.series);
+        }
+        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 = createBaseRewardPool();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.totalAmount = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.claimedAmount = coin_1.Coin.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.startTime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.endTime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.series = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRewardPool();
+        message.totalAmount = object.totalAmount !== undefined && object.totalAmount !== null ? coin_1.Coin.fromPartial(object.totalAmount) : undefined;
+        message.claimedAmount = object.claimedAmount !== undefined && object.claimedAmount !== null ? coin_1.Coin.fromPartial(object.claimedAmount) : undefined;
+        message.startTime = object.startTime ?? undefined;
+        message.endTime = object.endTime ?? undefined;
+        message.series = object.series ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRewardPool();
+        if (object.total_amount !== undefined && object.total_amount !== null) {
+            message.totalAmount = coin_1.Coin.fromAmino(object.total_amount);
+        }
+        if (object.claimed_amount !== undefined && object.claimed_amount !== null) {
+            message.claimedAmount = coin_1.Coin.fromAmino(object.claimed_amount);
+        }
+        if (object.start_time !== undefined && object.start_time !== null) {
+            message.startTime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.fromAmino(object.start_time));
+        }
+        if (object.end_time !== undefined && object.end_time !== null) {
+            message.endTime = (0, helpers_1.fromTimestamp)(timestamp_1.Timestamp.fromAmino(object.end_time));
+        }
+        if (object.series !== undefined && object.series !== null) {
+            message.series = object.series;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.total_amount = message.totalAmount ? coin_1.Coin.toAmino(message.totalAmount) : undefined;
+        obj.claimed_amount = message.claimedAmount ? coin_1.Coin.toAmino(message.claimedAmount) : undefined;
+        obj.start_time = message.startTime ? timestamp_1.Timestamp.toAmino((0, helpers_1.toTimestamp)(message.startTime)) : undefined;
+        obj.end_time = message.endTime ? timestamp_1.Timestamp.toAmino((0, helpers_1.toTimestamp)(message.endTime)) : undefined;
+        obj.series = message.series === 0 ? undefined : message.series;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.RewardPool.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.RewardPool.decode(message.value);
+    },
+    toProto(message) {
+        return exports.RewardPool.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.RewardPool",
+            value: exports.RewardPool.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,294 @@
+import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { Task, TaskAmino, TaskSDKType } from "./task";
+import { Series } from "./pool";
+import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import { Reward, RewardAmino, RewardSDKType } from "./rewards";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryParamsRequest";
+    value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestSDKType {
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryParamsResponse";
+    value: Uint8Array;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseAmino {
+    /** params defines the parameters of the module. */
+    params?: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseSDKType {
+    params: ParamsSDKType;
+}
+export interface QueryTasksRequest {
+    address: string;
+}
+export interface QueryTasksRequestProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryTasksRequest";
+    value: Uint8Array;
+}
+export interface QueryTasksRequestAmino {
+    address?: string;
+}
+export interface QueryTasksRequestAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryTasksRequest";
+    value: QueryTasksRequestAmino;
+}
+export interface QueryTasksRequestSDKType {
+    address: string;
+}
+export interface QueryTasksResponse {
+    tasks: Task[];
+}
+export interface QueryTasksResponseProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryTasksResponse";
+    value: Uint8Array;
+}
+export interface QueryTasksResponseAmino {
+    tasks?: TaskAmino[];
+}
+export interface QueryTasksResponseAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryTasksResponse";
+    value: QueryTasksResponseAmino;
+}
+export interface QueryTasksResponseSDKType {
+    tasks: TaskSDKType[];
+}
+export interface QueryGetRewardRequest {
+    recipient: string;
+}
+export interface QueryGetRewardRequestProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryGetRewardRequest";
+    value: Uint8Array;
+}
+export interface QueryGetRewardRequestAmino {
+    recipient?: string;
+}
+export interface QueryGetRewardRequestAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryGetRewardRequest";
+    value: QueryGetRewardRequestAmino;
+}
+export interface QueryGetRewardRequestSDKType {
+    recipient: string;
+}
+export interface QueryGetRewardResponseReward {
+    creator: string;
+    series: Series;
+    amount: Coin;
+    claimedAmount: Coin;
+    claimableAmount: Coin;
+    remainingClaimableAmount: Coin;
+}
+export interface QueryGetRewardResponseRewardProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryGetRewardResponseReward";
+    value: Uint8Array;
+}
+export interface QueryGetRewardResponseRewardAmino {
+    creator?: string;
+    series?: Series;
+    amount?: CoinAmino;
+    claimed_amount?: CoinAmino;
+    claimable_amount?: CoinAmino;
+    remaining_claimable_amount?: CoinAmino;
+}
+export interface QueryGetRewardResponseRewardAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryGetRewardResponseReward";
+    value: QueryGetRewardResponseRewardAmino;
+}
+export interface QueryGetRewardResponseRewardSDKType {
+    creator: string;
+    series: Series;
+    amount: CoinSDKType;
+    claimed_amount: CoinSDKType;
+    claimable_amount: CoinSDKType;
+    remaining_claimable_amount: CoinSDKType;
+}
+export interface QueryGetRewardResponse {
+    recipient: string;
+    rewards: QueryGetRewardResponseReward[];
+}
+export interface QueryGetRewardResponseProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryGetRewardResponse";
+    value: Uint8Array;
+}
+export interface QueryGetRewardResponseAmino {
+    recipient?: string;
+    rewards?: QueryGetRewardResponseRewardAmino[];
+}
+export interface QueryGetRewardResponseAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryGetRewardResponse";
+    value: QueryGetRewardResponseAmino;
+}
+export interface QueryGetRewardResponseSDKType {
+    recipient: string;
+    rewards: QueryGetRewardResponseRewardSDKType[];
+}
+export interface QueryAllRewardsRequest {
+    pagination?: PageRequest;
+}
+export interface QueryAllRewardsRequestProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryAllRewardsRequest";
+    value: Uint8Array;
+}
+export interface QueryAllRewardsRequestAmino {
+    pagination?: PageRequestAmino;
+}
+export interface QueryAllRewardsRequestAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryAllRewardsRequest";
+    value: QueryAllRewardsRequestAmino;
+}
+export interface QueryAllRewardsRequestSDKType {
+    pagination?: PageRequestSDKType;
+}
+export interface QueryAllRewardsResponse {
+    rewards: Reward[];
+    pagination?: PageResponse;
+}
+export interface QueryAllRewardsResponseProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.QueryAllRewardsResponse";
+    value: Uint8Array;
+}
+export interface QueryAllRewardsResponseAmino {
+    rewards?: RewardAmino[];
+    pagination?: PageResponseAmino;
+}
+export interface QueryAllRewardsResponseAminoMsg {
+    type: "/gitopia.gitopia.rewards.QueryAllRewardsResponse";
+    value: QueryAllRewardsResponseAmino;
+}
+export interface QueryAllRewardsResponseSDKType {
+    rewards: RewardSDKType[];
+    pagination?: PageResponseSDKType;
+}
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: Partial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+};
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: Partial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+};
+export declare const QueryTasksRequest: {
+    typeUrl: string;
+    encode(message: QueryTasksRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTasksRequest;
+    fromPartial(object: Partial<QueryTasksRequest>): QueryTasksRequest;
+    fromAmino(object: QueryTasksRequestAmino): QueryTasksRequest;
+    toAmino(message: QueryTasksRequest): QueryTasksRequestAmino;
+    fromAminoMsg(object: QueryTasksRequestAminoMsg): QueryTasksRequest;
+    fromProtoMsg(message: QueryTasksRequestProtoMsg): QueryTasksRequest;
+    toProto(message: QueryTasksRequest): Uint8Array;
+    toProtoMsg(message: QueryTasksRequest): QueryTasksRequestProtoMsg;
+};
+export declare const QueryTasksResponse: {
+    typeUrl: string;
+    encode(message: QueryTasksResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTasksResponse;
+    fromPartial(object: Partial<QueryTasksResponse>): QueryTasksResponse;
+    fromAmino(object: QueryTasksResponseAmino): QueryTasksResponse;
+    toAmino(message: QueryTasksResponse): QueryTasksResponseAmino;
+    fromAminoMsg(object: QueryTasksResponseAminoMsg): QueryTasksResponse;
+    fromProtoMsg(message: QueryTasksResponseProtoMsg): QueryTasksResponse;
+    toProto(message: QueryTasksResponse): Uint8Array;
+    toProtoMsg(message: QueryTasksResponse): QueryTasksResponseProtoMsg;
+};
+export declare const QueryGetRewardRequest: {
+    typeUrl: string;
+    encode(message: QueryGetRewardRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGetRewardRequest;
+    fromPartial(object: Partial<QueryGetRewardRequest>): QueryGetRewardRequest;
+    fromAmino(object: QueryGetRewardRequestAmino): QueryGetRewardRequest;
+    toAmino(message: QueryGetRewardRequest): QueryGetRewardRequestAmino;
+    fromAminoMsg(object: QueryGetRewardRequestAminoMsg): QueryGetRewardRequest;
+    fromProtoMsg(message: QueryGetRewardRequestProtoMsg): QueryGetRewardRequest;
+    toProto(message: QueryGetRewardRequest): Uint8Array;
+    toProtoMsg(message: QueryGetRewardRequest): QueryGetRewardRequestProtoMsg;
+};
+export declare const QueryGetRewardResponseReward: {
+    typeUrl: string;
+    encode(message: QueryGetRewardResponseReward, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGetRewardResponseReward;
+    fromPartial(object: Partial<QueryGetRewardResponseReward>): QueryGetRewardResponseReward;
+    fromAmino(object: QueryGetRewardResponseRewardAmino): QueryGetRewardResponseReward;
+    toAmino(message: QueryGetRewardResponseReward): QueryGetRewardResponseRewardAmino;
+    fromAminoMsg(object: QueryGetRewardResponseRewardAminoMsg): QueryGetRewardResponseReward;
+    fromProtoMsg(message: QueryGetRewardResponseRewardProtoMsg): QueryGetRewardResponseReward;
+    toProto(message: QueryGetRewardResponseReward): Uint8Array;
+    toProtoMsg(message: QueryGetRewardResponseReward): QueryGetRewardResponseRewardProtoMsg;
+};
+export declare const QueryGetRewardResponse: {
+    typeUrl: string;
+    encode(message: QueryGetRewardResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGetRewardResponse;
+    fromPartial(object: Partial<QueryGetRewardResponse>): QueryGetRewardResponse;
+    fromAmino(object: QueryGetRewardResponseAmino): QueryGetRewardResponse;
+    toAmino(message: QueryGetRewardResponse): QueryGetRewardResponseAmino;
+    fromAminoMsg(object: QueryGetRewardResponseAminoMsg): QueryGetRewardResponse;
+    fromProtoMsg(message: QueryGetRewardResponseProtoMsg): QueryGetRewardResponse;
+    toProto(message: QueryGetRewardResponse): Uint8Array;
+    toProtoMsg(message: QueryGetRewardResponse): QueryGetRewardResponseProtoMsg;
+};
+export declare const QueryAllRewardsRequest: {
+    typeUrl: string;
+    encode(message: QueryAllRewardsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllRewardsRequest;
+    fromPartial(object: Partial<QueryAllRewardsRequest>): QueryAllRewardsRequest;
+    fromAmino(object: QueryAllRewardsRequestAmino): QueryAllRewardsRequest;
+    toAmino(message: QueryAllRewardsRequest): QueryAllRewardsRequestAmino;
+    fromAminoMsg(object: QueryAllRewardsRequestAminoMsg): QueryAllRewardsRequest;
+    fromProtoMsg(message: QueryAllRewardsRequestProtoMsg): QueryAllRewardsRequest;
+    toProto(message: QueryAllRewardsRequest): Uint8Array;
+    toProtoMsg(message: QueryAllRewardsRequest): QueryAllRewardsRequestProtoMsg;
+};
+export declare const QueryAllRewardsResponse: {
+    typeUrl: string;
+    encode(message: QueryAllRewardsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAllRewardsResponse;
+    fromPartial(object: Partial<QueryAllRewardsResponse>): QueryAllRewardsResponse;
+    fromAmino(object: QueryAllRewardsResponseAmino): QueryAllRewardsResponse;
+    toAmino(message: QueryAllRewardsResponse): QueryAllRewardsResponseAmino;
+    fromAminoMsg(object: QueryAllRewardsResponseAminoMsg): QueryAllRewardsResponse;
+    fromProtoMsg(message: QueryAllRewardsResponseProtoMsg): QueryAllRewardsResponse;
+    toProto(message: QueryAllRewardsResponse): Uint8Array;
+    toProtoMsg(message: QueryAllRewardsResponse): QueryAllRewardsResponseProtoMsg;
+};