@gitopia/gitopiajs 0.0.3 → 0.0.4

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

@@ -1,82 +0,0 @@
-//@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

@@ -1,81 +0,0 @@
-//@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

@@ -1,191 +0,0 @@
-//@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()
-        };
-    }
-};