@gitopia/gitopiajs 0.0.2

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

@@ -0,0 +1,82 @@
+//@ts-nocheck
+import { Reward } from "./rewards";
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        rewardsList: [],
+        params: Params.fromPartial({})
+    };
+}
+export const GenesisState = {
+    typeUrl: "/gitopia.gitopia.rewards.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.rewardsList) {
+            Reward.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, 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 = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    message.rewardsList.push(Reward.decode(reader, reader.uint32()));
+                    break;
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.rewardsList = object.rewardsList?.map(e => Reward.fromPartial(e)) || [];
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.rewardsList = object.rewardsList?.map(e => Reward.fromAmino(e)) || [];
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.rewardsList) {
+            obj.rewardsList = message.rewardsList.map(e => e ? Reward.toAmino(e) : undefined);
+        }
+        else {
+            obj.rewardsList = message.rewardsList;
+        }
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,81 @@
+//@ts-nocheck
+import { RewardPool } from "./pool";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseParams() {
+    return {
+        evaluatorAddress: "",
+        rewardSeries: []
+    };
+}
+export const Params = {
+    typeUrl: "/gitopia.gitopia.rewards.Params",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.evaluatorAddress !== "") {
+            writer.uint32(10).string(message.evaluatorAddress);
+        }
+        for (const v of message.rewardSeries) {
+            RewardPool.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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.evaluatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.rewardSeries.push(RewardPool.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.evaluatorAddress = object.evaluatorAddress ?? "";
+        message.rewardSeries = object.rewardSeries?.map(e => RewardPool.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        if (object.evaluator_address !== undefined && object.evaluator_address !== null) {
+            message.evaluatorAddress = object.evaluator_address;
+        }
+        message.rewardSeries = object.reward_series?.map(e => RewardPool.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.evaluator_address = message.evaluatorAddress === "" ? undefined : message.evaluatorAddress;
+        if (message.rewardSeries) {
+            obj.reward_series = message.rewardSeries.map(e => e ? RewardPool.toAmino(e) : undefined);
+        }
+        else {
+            obj.reward_series = message.rewardSeries;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Params.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Params.decode(message.value);
+    },
+    toProto(message) {
+        return Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.Params",
+            value: Params.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,191 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { toTimestamp, fromTimestamp } from "../../../helpers";
+export 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 || (Series = {}));
+export const SeriesSDKType = Series;
+export const SeriesAmino = Series;
+export 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;
+    }
+}
+export 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.fromPartial({}),
+        claimedAmount: Coin.fromPartial({}),
+        startTime: new Date(),
+        endTime: new Date(),
+        series: 0
+    };
+}
+export const RewardPool = {
+    typeUrl: "/gitopia.gitopia.rewards.RewardPool",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.totalAmount !== undefined) {
+            Coin.encode(message.totalAmount, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.claimedAmount !== undefined) {
+            Coin.encode(message.claimedAmount, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.startTime !== undefined) {
+            Timestamp.encode(toTimestamp(message.startTime), writer.uint32(26).fork()).ldelim();
+        }
+        if (message.endTime !== undefined) {
+            Timestamp.encode(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 BinaryReader ? input : new 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.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.claimedAmount = Coin.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.endTime = fromTimestamp(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.fromPartial(object.totalAmount) : undefined;
+        message.claimedAmount = object.claimedAmount !== undefined && object.claimedAmount !== null ? 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.fromAmino(object.total_amount);
+        }
+        if (object.claimed_amount !== undefined && object.claimed_amount !== null) {
+            message.claimedAmount = Coin.fromAmino(object.claimed_amount);
+        }
+        if (object.start_time !== undefined && object.start_time !== null) {
+            message.startTime = fromTimestamp(Timestamp.fromAmino(object.start_time));
+        }
+        if (object.end_time !== undefined && object.end_time !== null) {
+            message.endTime = fromTimestamp(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.toAmino(message.totalAmount) : undefined;
+        obj.claimed_amount = message.claimedAmount ? Coin.toAmino(message.claimedAmount) : undefined;
+        obj.start_time = message.startTime ? Timestamp.toAmino(toTimestamp(message.startTime)) : undefined;
+        obj.end_time = message.endTime ? Timestamp.toAmino(toTimestamp(message.endTime)) : undefined;
+        obj.series = message.series === 0 ? undefined : message.series;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return RewardPool.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return RewardPool.decode(message.value);
+    },
+    toProto(message) {
+        return RewardPool.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.RewardPool",
+            value: RewardPool.encode(message).finish()
+        };
+    }
+};