@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/esm/sparkdream/season/v1/season_title_eligibility.js

@@ -0,0 +1,194 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseTitleGrant() {
+    return {
+        titleId: "",
+        titleName: "",
+        eligibleMembers: []
+    };
+}
+/**
+ * TitleGrant represents a title and its eligible recipients for a season.
+ * @name TitleGrant
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.TitleGrant
+ */
+export const TitleGrant = {
+    typeUrl: "/sparkdream.season.v1.TitleGrant",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.titleId !== "") {
+            writer.uint32(10).string(message.titleId);
+        }
+        if (message.titleName !== "") {
+            writer.uint32(18).string(message.titleName);
+        }
+        for (const v of message.eligibleMembers) {
+            writer.uint32(26).string(v);
+        }
+        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 = createBaseTitleGrant();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.titleId = reader.string();
+                    break;
+                case 2:
+                    message.titleName = reader.string();
+                    break;
+                case 3:
+                    message.eligibleMembers.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTitleGrant();
+        message.titleId = object.titleId ?? "";
+        message.titleName = object.titleName ?? "";
+        message.eligibleMembers = object.eligibleMembers?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTitleGrant();
+        if (object.title_id !== undefined && object.title_id !== null) {
+            message.titleId = object.title_id;
+        }
+        if (object.title_name !== undefined && object.title_name !== null) {
+            message.titleName = object.title_name;
+        }
+        message.eligibleMembers = object.eligible_members?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.title_id = message.titleId === "" ? undefined : message.titleId;
+        obj.title_name = message.titleName === "" ? undefined : message.titleName;
+        if (message.eligibleMembers) {
+            obj.eligible_members = message.eligibleMembers.map(e => e);
+        }
+        else {
+            obj.eligible_members = message.eligibleMembers;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TitleGrant.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TitleGrant.decode(message.value);
+    },
+    toProto(message) {
+        return TitleGrant.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.TitleGrant",
+            value: TitleGrant.encode(message).finish()
+        };
+    }
+};
+function createBaseSeasonTitleEligibility() {
+    return {
+        titleSeason: BigInt(0),
+        season: BigInt(0),
+        grants: []
+    };
+}
+/**
+ * SeasonTitleEligibility tracks title grants for a season.
+ * @name SeasonTitleEligibility
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.SeasonTitleEligibility
+ */
+export const SeasonTitleEligibility = {
+    typeUrl: "/sparkdream.season.v1.SeasonTitleEligibility",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.titleSeason !== BigInt(0)) {
+            writer.uint32(8).uint64(message.titleSeason);
+        }
+        if (message.season !== BigInt(0)) {
+            writer.uint32(16).uint64(message.season);
+        }
+        for (const v of message.grants) {
+            TitleGrant.encode(v, writer.uint32(26).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 = createBaseSeasonTitleEligibility();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.titleSeason = reader.uint64();
+                    break;
+                case 2:
+                    message.season = reader.uint64();
+                    break;
+                case 3:
+                    message.grants.push(TitleGrant.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSeasonTitleEligibility();
+        message.titleSeason = object.titleSeason !== undefined && object.titleSeason !== null ? BigInt(object.titleSeason.toString()) : BigInt(0);
+        message.season = object.season !== undefined && object.season !== null ? BigInt(object.season.toString()) : BigInt(0);
+        message.grants = object.grants?.map(e => TitleGrant.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSeasonTitleEligibility();
+        if (object.title_season !== undefined && object.title_season !== null) {
+            message.titleSeason = BigInt(object.title_season);
+        }
+        if (object.season !== undefined && object.season !== null) {
+            message.season = BigInt(object.season);
+        }
+        message.grants = object.grants?.map(e => TitleGrant.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.title_season = message.titleSeason !== BigInt(0) ? message.titleSeason?.toString() : undefined;
+        obj.season = message.season !== BigInt(0) ? message.season?.toString() : undefined;
+        if (message.grants) {
+            obj.grants = message.grants.map(e => e ? TitleGrant.toAmino(e) : undefined);
+        }
+        else {
+            obj.grants = message.grants;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SeasonTitleEligibility.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SeasonTitleEligibility.decode(message.value);
+    },
+    toProto(message) {
+        return SeasonTitleEligibility.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.SeasonTitleEligibility",
+            value: SeasonTitleEligibility.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/season/v1/season_transition_state.js

@@ -0,0 +1,130 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseSeasonTransitionState() {
+    return {
+        phase: 0,
+        processedCount: BigInt(0),
+        totalCount: BigInt(0),
+        lastProcessed: "",
+        transitionStart: BigInt(0),
+        maintenanceMode: false
+    };
+}
+/**
+ * SeasonTransitionState tracks the progress of a season transition.
+ * @name SeasonTransitionState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.SeasonTransitionState
+ */
+export const SeasonTransitionState = {
+    typeUrl: "/sparkdream.season.v1.SeasonTransitionState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.phase !== 0) {
+            writer.uint32(8).int32(message.phase);
+        }
+        if (message.processedCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.processedCount);
+        }
+        if (message.totalCount !== BigInt(0)) {
+            writer.uint32(24).uint64(message.totalCount);
+        }
+        if (message.lastProcessed !== "") {
+            writer.uint32(34).string(message.lastProcessed);
+        }
+        if (message.transitionStart !== BigInt(0)) {
+            writer.uint32(40).int64(message.transitionStart);
+        }
+        if (message.maintenanceMode === true) {
+            writer.uint32(48).bool(message.maintenanceMode);
+        }
+        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 = createBaseSeasonTransitionState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.phase = reader.int32();
+                    break;
+                case 2:
+                    message.processedCount = reader.uint64();
+                    break;
+                case 3:
+                    message.totalCount = reader.uint64();
+                    break;
+                case 4:
+                    message.lastProcessed = reader.string();
+                    break;
+                case 5:
+                    message.transitionStart = reader.int64();
+                    break;
+                case 6:
+                    message.maintenanceMode = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSeasonTransitionState();
+        message.phase = object.phase ?? 0;
+        message.processedCount = object.processedCount !== undefined && object.processedCount !== null ? BigInt(object.processedCount.toString()) : BigInt(0);
+        message.totalCount = object.totalCount !== undefined && object.totalCount !== null ? BigInt(object.totalCount.toString()) : BigInt(0);
+        message.lastProcessed = object.lastProcessed ?? "";
+        message.transitionStart = object.transitionStart !== undefined && object.transitionStart !== null ? BigInt(object.transitionStart.toString()) : BigInt(0);
+        message.maintenanceMode = object.maintenanceMode ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSeasonTransitionState();
+        if (object.phase !== undefined && object.phase !== null) {
+            message.phase = object.phase;
+        }
+        if (object.processed_count !== undefined && object.processed_count !== null) {
+            message.processedCount = BigInt(object.processed_count);
+        }
+        if (object.total_count !== undefined && object.total_count !== null) {
+            message.totalCount = BigInt(object.total_count);
+        }
+        if (object.last_processed !== undefined && object.last_processed !== null) {
+            message.lastProcessed = object.last_processed;
+        }
+        if (object.transition_start !== undefined && object.transition_start !== null) {
+            message.transitionStart = BigInt(object.transition_start);
+        }
+        if (object.maintenance_mode !== undefined && object.maintenance_mode !== null) {
+            message.maintenanceMode = object.maintenance_mode;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.phase = message.phase === 0 ? undefined : message.phase;
+        obj.processed_count = message.processedCount !== BigInt(0) ? message.processedCount?.toString() : undefined;
+        obj.total_count = message.totalCount !== BigInt(0) ? message.totalCount?.toString() : undefined;
+        obj.last_processed = message.lastProcessed === "" ? undefined : message.lastProcessed;
+        obj.transition_start = message.transitionStart !== BigInt(0) ? message.transitionStart?.toString() : undefined;
+        obj.maintenance_mode = message.maintenanceMode === false ? undefined : message.maintenanceMode;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return SeasonTransitionState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return SeasonTransitionState.decode(message.value);
+    },
+    toProto(message) {
+        return SeasonTransitionState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.SeasonTransitionState",
+            value: SeasonTransitionState.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/season/v1/title.js

@@ -0,0 +1,154 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseTitle() {
+    return {
+        titleId: "",
+        name: "",
+        description: "",
+        rarity: 0,
+        requirementType: 0,
+        requirementThreshold: BigInt(0),
+        requirementSeason: BigInt(0),
+        seasonal: false
+    };
+}
+/**
+ * Title defines a title that can be displayed by members.
+ * @name Title
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.Title
+ */
+export const Title = {
+    typeUrl: "/sparkdream.season.v1.Title",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.titleId !== "") {
+            writer.uint32(10).string(message.titleId);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        if (message.rarity !== 0) {
+            writer.uint32(32).int32(message.rarity);
+        }
+        if (message.requirementType !== 0) {
+            writer.uint32(40).int32(message.requirementType);
+        }
+        if (message.requirementThreshold !== BigInt(0)) {
+            writer.uint32(48).uint64(message.requirementThreshold);
+        }
+        if (message.requirementSeason !== BigInt(0)) {
+            writer.uint32(56).uint64(message.requirementSeason);
+        }
+        if (message.seasonal === true) {
+            writer.uint32(64).bool(message.seasonal);
+        }
+        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 = createBaseTitle();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.titleId = reader.string();
+                    break;
+                case 2:
+                    message.name = reader.string();
+                    break;
+                case 3:
+                    message.description = reader.string();
+                    break;
+                case 4:
+                    message.rarity = reader.int32();
+                    break;
+                case 5:
+                    message.requirementType = reader.int32();
+                    break;
+                case 6:
+                    message.requirementThreshold = reader.uint64();
+                    break;
+                case 7:
+                    message.requirementSeason = reader.uint64();
+                    break;
+                case 8:
+                    message.seasonal = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTitle();
+        message.titleId = object.titleId ?? "";
+        message.name = object.name ?? "";
+        message.description = object.description ?? "";
+        message.rarity = object.rarity ?? 0;
+        message.requirementType = object.requirementType ?? 0;
+        message.requirementThreshold = object.requirementThreshold !== undefined && object.requirementThreshold !== null ? BigInt(object.requirementThreshold.toString()) : BigInt(0);
+        message.requirementSeason = object.requirementSeason !== undefined && object.requirementSeason !== null ? BigInt(object.requirementSeason.toString()) : BigInt(0);
+        message.seasonal = object.seasonal ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTitle();
+        if (object.title_id !== undefined && object.title_id !== null) {
+            message.titleId = object.title_id;
+        }
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.rarity !== undefined && object.rarity !== null) {
+            message.rarity = object.rarity;
+        }
+        if (object.requirement_type !== undefined && object.requirement_type !== null) {
+            message.requirementType = object.requirement_type;
+        }
+        if (object.requirement_threshold !== undefined && object.requirement_threshold !== null) {
+            message.requirementThreshold = BigInt(object.requirement_threshold);
+        }
+        if (object.requirement_season !== undefined && object.requirement_season !== null) {
+            message.requirementSeason = BigInt(object.requirement_season);
+        }
+        if (object.seasonal !== undefined && object.seasonal !== null) {
+            message.seasonal = object.seasonal;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.title_id = message.titleId === "" ? undefined : message.titleId;
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.rarity = message.rarity === 0 ? undefined : message.rarity;
+        obj.requirement_type = message.requirementType === 0 ? undefined : message.requirementType;
+        obj.requirement_threshold = message.requirementThreshold !== BigInt(0) ? message.requirementThreshold?.toString() : undefined;
+        obj.requirement_season = message.requirementSeason !== BigInt(0) ? message.requirementSeason?.toString() : undefined;
+        obj.seasonal = message.seasonal === false ? undefined : message.seasonal;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Title.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Title.decode(message.value);
+    },
+    toProto(message) {
+        return Title.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.Title",
+            value: Title.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/season/v1/transition_recovery_state.js

@@ -0,0 +1,118 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseTransitionRecoveryState() {
+    return {
+        lastAttemptBlock: BigInt(0),
+        failedPhase: 0,
+        failureCount: BigInt(0),
+        lastError: "",
+        recoveryMode: false
+    };
+}
+/**
+ * TransitionRecoveryState tracks recovery from failed season transitions.
+ * @name TransitionRecoveryState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.TransitionRecoveryState
+ */
+export const TransitionRecoveryState = {
+    typeUrl: "/sparkdream.season.v1.TransitionRecoveryState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.lastAttemptBlock !== BigInt(0)) {
+            writer.uint32(8).int64(message.lastAttemptBlock);
+        }
+        if (message.failedPhase !== 0) {
+            writer.uint32(16).int32(message.failedPhase);
+        }
+        if (message.failureCount !== BigInt(0)) {
+            writer.uint32(24).uint64(message.failureCount);
+        }
+        if (message.lastError !== "") {
+            writer.uint32(34).string(message.lastError);
+        }
+        if (message.recoveryMode === true) {
+            writer.uint32(40).bool(message.recoveryMode);
+        }
+        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 = createBaseTransitionRecoveryState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.lastAttemptBlock = reader.int64();
+                    break;
+                case 2:
+                    message.failedPhase = reader.int32();
+                    break;
+                case 3:
+                    message.failureCount = reader.uint64();
+                    break;
+                case 4:
+                    message.lastError = reader.string();
+                    break;
+                case 5:
+                    message.recoveryMode = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTransitionRecoveryState();
+        message.lastAttemptBlock = object.lastAttemptBlock !== undefined && object.lastAttemptBlock !== null ? BigInt(object.lastAttemptBlock.toString()) : BigInt(0);
+        message.failedPhase = object.failedPhase ?? 0;
+        message.failureCount = object.failureCount !== undefined && object.failureCount !== null ? BigInt(object.failureCount.toString()) : BigInt(0);
+        message.lastError = object.lastError ?? "";
+        message.recoveryMode = object.recoveryMode ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTransitionRecoveryState();
+        if (object.last_attempt_block !== undefined && object.last_attempt_block !== null) {
+            message.lastAttemptBlock = BigInt(object.last_attempt_block);
+        }
+        if (object.failed_phase !== undefined && object.failed_phase !== null) {
+            message.failedPhase = object.failed_phase;
+        }
+        if (object.failure_count !== undefined && object.failure_count !== null) {
+            message.failureCount = BigInt(object.failure_count);
+        }
+        if (object.last_error !== undefined && object.last_error !== null) {
+            message.lastError = object.last_error;
+        }
+        if (object.recovery_mode !== undefined && object.recovery_mode !== null) {
+            message.recoveryMode = object.recovery_mode;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.last_attempt_block = message.lastAttemptBlock !== BigInt(0) ? message.lastAttemptBlock?.toString() : undefined;
+        obj.failed_phase = message.failedPhase === 0 ? undefined : message.failedPhase;
+        obj.failure_count = message.failureCount !== BigInt(0) ? message.failureCount?.toString() : undefined;
+        obj.last_error = message.lastError === "" ? undefined : message.lastError;
+        obj.recovery_mode = message.recoveryMode === false ? undefined : message.recoveryMode;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return TransitionRecoveryState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return TransitionRecoveryState.decode(message.value);
+    },
+    toProto(message) {
+        return TransitionRecoveryState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.TransitionRecoveryState",
+            value: TransitionRecoveryState.encode(message).finish()
+        };
+    }
+};