@gitopia/gitopiajs 0.0.4 → 0.0.5

package/dist/gitopia/gitopia/offchain/offchain.d.ts

@@ -0,0 +1,74 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** MsgSignData defines an arbitrary, general-purpose, off-chain message */
+export interface MsgSignData {
+    /** signer is the bech32 representation of the signer's account address */
+    signer: string;
+    /** data represents the raw bytes of the content that is signed (text, json, etc) */
+    data: Uint8Array;
+}
+export interface MsgSignDataProtoMsg {
+    typeUrl: "/gitopia.gitopia.offchain.MsgSignData";
+    value: Uint8Array;
+}
+/** MsgSignData defines an arbitrary, general-purpose, off-chain message */
+export interface MsgSignDataAmino {
+    /** signer is the bech32 representation of the signer's account address */
+    signer?: string;
+    /** data represents the raw bytes of the content that is signed (text, json, etc) */
+    data?: string;
+}
+export interface MsgSignDataAminoMsg {
+    type: "/gitopia.gitopia.offchain.MsgSignData";
+    value: MsgSignDataAmino;
+}
+/** MsgSignData defines an arbitrary, general-purpose, off-chain message */
+export interface MsgSignDataSDKType {
+    signer: string;
+    data: Uint8Array;
+}
+/** ListOfMsgSignData defines a list of MsgSignData, used to marshal and unmarshal them in a clean way */
+export interface ListOfMsgSignData {
+    /** msgs is a list of messages */
+    msgs: MsgSignData[];
+}
+export interface ListOfMsgSignDataProtoMsg {
+    typeUrl: "/gitopia.gitopia.offchain.ListOfMsgSignData";
+    value: Uint8Array;
+}
+/** ListOfMsgSignData defines a list of MsgSignData, used to marshal and unmarshal them in a clean way */
+export interface ListOfMsgSignDataAmino {
+    /** msgs is a list of messages */
+    msgs?: MsgSignDataAmino[];
+}
+export interface ListOfMsgSignDataAminoMsg {
+    type: "/gitopia.gitopia.offchain.ListOfMsgSignData";
+    value: ListOfMsgSignDataAmino;
+}
+/** ListOfMsgSignData defines a list of MsgSignData, used to marshal and unmarshal them in a clean way */
+export interface ListOfMsgSignDataSDKType {
+    msgs: MsgSignDataSDKType[];
+}
+export declare const MsgSignData: {
+    typeUrl: string;
+    encode(message: MsgSignData, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgSignData;
+    fromPartial(object: Partial<MsgSignData>): MsgSignData;
+    fromAmino(object: MsgSignDataAmino): MsgSignData;
+    toAmino(message: MsgSignData): MsgSignDataAmino;
+    fromAminoMsg(object: MsgSignDataAminoMsg): MsgSignData;
+    fromProtoMsg(message: MsgSignDataProtoMsg): MsgSignData;
+    toProto(message: MsgSignData): Uint8Array;
+    toProtoMsg(message: MsgSignData): MsgSignDataProtoMsg;
+};
+export declare const ListOfMsgSignData: {
+    typeUrl: string;
+    encode(message: ListOfMsgSignData, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ListOfMsgSignData;
+    fromPartial(object: Partial<ListOfMsgSignData>): ListOfMsgSignData;
+    fromAmino(object: ListOfMsgSignDataAmino): ListOfMsgSignData;
+    toAmino(message: ListOfMsgSignData): ListOfMsgSignDataAmino;
+    fromAminoMsg(object: ListOfMsgSignDataAminoMsg): ListOfMsgSignData;
+    fromProtoMsg(message: ListOfMsgSignDataProtoMsg): ListOfMsgSignData;
+    toProto(message: ListOfMsgSignData): Uint8Array;
+    toProtoMsg(message: ListOfMsgSignData): ListOfMsgSignDataProtoMsg;
+};

package/dist/gitopia/gitopia/offchain/offchain.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListOfMsgSignData = exports.MsgSignData = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBaseMsgSignData() {
+    return {
+        signer: "",
+        data: new Uint8Array()
+    };
+}
+exports.MsgSignData = {
+    typeUrl: "/gitopia.gitopia.offchain.MsgSignData",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.signer !== "") {
+            writer.uint32(10).string(message.signer);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        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 = createBaseMsgSignData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signer = reader.string();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSignData();
+        message.signer = object.signer ?? "";
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSignData();
+        if (object.signer !== undefined && object.signer !== null) {
+            message.signer = object.signer;
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = (0, helpers_1.bytesFromBase64)(object.data);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signer = message.signer === "" ? undefined : message.signer;
+        obj.data = message.data ? (0, helpers_1.base64FromBytes)(message.data) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgSignData.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.MsgSignData.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgSignData.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.offchain.MsgSignData",
+            value: exports.MsgSignData.encode(message).finish()
+        };
+    }
+};
+function createBaseListOfMsgSignData() {
+    return {
+        msgs: []
+    };
+}
+exports.ListOfMsgSignData = {
+    typeUrl: "/gitopia.gitopia.offchain.ListOfMsgSignData",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.msgs) {
+            exports.MsgSignData.encode(v, writer.uint32(10).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 = createBaseListOfMsgSignData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.msgs.push(exports.MsgSignData.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseListOfMsgSignData();
+        message.msgs = object.msgs?.map(e => exports.MsgSignData.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseListOfMsgSignData();
+        message.msgs = object.msgs?.map(e => exports.MsgSignData.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.msgs) {
+            obj.msgs = message.msgs.map(e => e ? exports.MsgSignData.toAmino(e) : undefined);
+        }
+        else {
+            obj.msgs = message.msgs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ListOfMsgSignData.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ListOfMsgSignData.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ListOfMsgSignData.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.offchain.ListOfMsgSignData",
+            value: exports.ListOfMsgSignData.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,40 @@
+import { Reward, RewardAmino, RewardSDKType } from "./rewards";
+import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the rewards module's genesis state. */
+export interface GenesisState {
+    rewardsList: Reward[];
+    /** this line is used by starport scaffolding # genesis/proto/state */
+    params: Params;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the rewards module's genesis state. */
+export interface GenesisStateAmino {
+    rewardsList?: RewardAmino[];
+    /** this line is used by starport scaffolding # genesis/proto/state */
+    params?: ParamsAmino;
+}
+export interface GenesisStateAminoMsg {
+    type: "/gitopia.gitopia.rewards.GenesisState";
+    value: GenesisStateAmino;
+}
+/** GenesisState defines the rewards module's genesis state. */
+export interface GenesisStateSDKType {
+    rewardsList: RewardSDKType[];
+    params: ParamsSDKType;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: Partial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

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

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

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

@@ -0,0 +1,37 @@
+import { RewardPool, RewardPoolAmino, RewardPoolSDKType } from "./pool";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** Params defines the parameters for the module. */
+export interface Params {
+    evaluatorAddress: string;
+    rewardSeries: RewardPool[];
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.Params";
+    value: Uint8Array;
+}
+/** Params defines the parameters for the module. */
+export interface ParamsAmino {
+    evaluator_address?: string;
+    reward_series?: RewardPoolAmino[];
+}
+export interface ParamsAminoMsg {
+    type: "/gitopia.gitopia.rewards.Params";
+    value: ParamsAmino;
+}
+/** Params defines the parameters for the module. */
+export interface ParamsSDKType {
+    evaluator_address: string;
+    reward_series: RewardPoolSDKType[];
+}
+export declare const Params: {
+    typeUrl: string;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: Partial<Params>): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Params = void 0;
+//@ts-nocheck
+const pool_1 = require("./pool");
+const binary_1 = require("../../../binary");
+function createBaseParams() {
+    return {
+        evaluatorAddress: "",
+        rewardSeries: []
+    };
+}
+exports.Params = {
+    typeUrl: "/gitopia.gitopia.rewards.Params",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.evaluatorAddress !== "") {
+            writer.uint32(10).string(message.evaluatorAddress);
+        }
+        for (const v of message.rewardSeries) {
+            pool_1.RewardPool.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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.evaluatorAddress = reader.string();
+                    break;
+                case 2:
+                    message.rewardSeries.push(pool_1.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 => pool_1.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 => pool_1.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 ? pool_1.RewardPool.toAmino(e) : undefined);
+        }
+        else {
+            obj.reward_series = message.rewardSeries;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Params.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Params.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.rewards.Params",
+            value: exports.Params.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,59 @@
+import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export declare enum Series {
+    NONE = 0,
+    ONE = 1,
+    TWO = 2,
+    THREE = 3,
+    FOUR = 4,
+    FIVE = 5,
+    SIX = 6,
+    SEVEN = 7,
+    COSMOS = 8,
+    UNRECOGNIZED = -1
+}
+export declare const SeriesSDKType: typeof Series;
+export declare const SeriesAmino: typeof Series;
+export declare function seriesFromJSON(object: any): Series;
+export declare function seriesToJSON(object: Series): string;
+export interface RewardPool {
+    totalAmount: Coin;
+    claimedAmount: Coin;
+    startTime: Date;
+    endTime: Date;
+    series: Series;
+}
+export interface RewardPoolProtoMsg {
+    typeUrl: "/gitopia.gitopia.rewards.RewardPool";
+    value: Uint8Array;
+}
+export interface RewardPoolAmino {
+    total_amount?: CoinAmino;
+    claimed_amount?: CoinAmino;
+    start_time?: string;
+    end_time?: string;
+    series?: Series;
+}
+export interface RewardPoolAminoMsg {
+    type: "/gitopia.gitopia.rewards.RewardPool";
+    value: RewardPoolAmino;
+}
+export interface RewardPoolSDKType {
+    total_amount: CoinSDKType;
+    claimed_amount: CoinSDKType;
+    start_time: Date;
+    end_time: Date;
+    series: Series;
+}
+export declare const RewardPool: {
+    typeUrl: string;
+    encode(message: RewardPool, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RewardPool;
+    fromPartial(object: Partial<RewardPool>): RewardPool;
+    fromAmino(object: RewardPoolAmino): RewardPool;
+    toAmino(message: RewardPool): RewardPoolAmino;
+    fromAminoMsg(object: RewardPoolAminoMsg): RewardPool;
+    fromProtoMsg(message: RewardPoolProtoMsg): RewardPool;
+    toProto(message: RewardPool): Uint8Array;
+    toProtoMsg(message: RewardPool): RewardPoolProtoMsg;
+};