@sparkdreamnft/sparkdreamjs 0.0.48 → 0.0.50

package/sparkdream/collect/v1/genesis.d.ts

@@ -28,6 +28,27 @@ export interface GenesisState {
     hideRecords: HideRecord[];
     hideRecordCount: bigint;
     endorsements: Endorsement[];
+    /**
+     * reaction_dedups persists the per-(voter, target) reaction marker
+     * (1 = upvote, 2 = downvote) so a voter cannot react again after import.
+     */
+    reactionDedups: ReactionCounterEntry[];
+    /**
+     * reaction_limits persists the per-(address, day, category) daily counters.
+     */
+    reactionLimits: ReactionCounterEntry[];
+    /**
+     * Not-adjudicated timeout schedule of the pending curation challenges.
+     * A pending challenge without an entry gets the latest possible deadline
+     * (review creation + challenge window + resolution timeout).
+     */
+    curationChallengeDeadlines: CurationChallengeDeadline[];
+    /**
+     * Members queued for eager promotion of their ephemeral content (admitted
+     * after posting). Hook-driven, so carried verbatim with the enqueue height;
+     * without it an import would leave that content to the lazy TTL-time path.
+     */
+    promotionQueue: PromotionQueueEntry[];
 }
 export interface GenesisStateProtoMsg {
     typeUrl: "/sparkdream.collect.v1.GenesisState";
@@ -58,11 +79,120 @@ export interface GenesisStateAmino {
     hide_records?: HideRecordAmino[];
     hide_record_count?: string;
     endorsements?: EndorsementAmino[];
+    /**
+     * reaction_dedups persists the per-(voter, target) reaction marker
+     * (1 = upvote, 2 = downvote) so a voter cannot react again after import.
+     */
+    reaction_dedups?: ReactionCounterEntryAmino[];
+    /**
+     * reaction_limits persists the per-(address, day, category) daily counters.
+     */
+    reaction_limits?: ReactionCounterEntryAmino[];
+    /**
+     * Not-adjudicated timeout schedule of the pending curation challenges.
+     * A pending challenge without an entry gets the latest possible deadline
+     * (review creation + challenge window + resolution timeout).
+     */
+    curation_challenge_deadlines?: CurationChallengeDeadlineAmino[];
+    /**
+     * Members queued for eager promotion of their ephemeral content (admitted
+     * after posting). Hook-driven, so carried verbatim with the enqueue height;
+     * without it an import would leave that content to the lazy TTL-time path.
+     */
+    promotion_queue?: PromotionQueueEntryAmino[];
 }
 export interface GenesisStateAminoMsg {
     type: "/sparkdream.collect.v1.GenesisState";
     value: GenesisStateAmino;
 }
+/**
+ * CurationChallengeDeadline is the block height at which the pending
+ * challenge on review_id resolves as not adjudicated.
+ * @name CurationChallengeDeadline
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.CurationChallengeDeadline
+ */
+export interface CurationChallengeDeadline {
+    deadline: bigint;
+    reviewId: bigint;
+}
+export interface CurationChallengeDeadlineProtoMsg {
+    typeUrl: "/sparkdream.collect.v1.CurationChallengeDeadline";
+    value: Uint8Array;
+}
+/**
+ * CurationChallengeDeadline is the block height at which the pending
+ * challenge on review_id resolves as not adjudicated.
+ * @name CurationChallengeDeadlineAmino
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.CurationChallengeDeadline
+ */
+export interface CurationChallengeDeadlineAmino {
+    deadline?: string;
+    review_id?: string;
+}
+export interface CurationChallengeDeadlineAminoMsg {
+    type: "/sparkdream.collect.v1.CurationChallengeDeadline";
+    value: CurationChallengeDeadlineAmino;
+}
+/**
+ * ReactionCounterEntry is one string-keyed uint32 counter (ReactionDedup or
+ * ReactionLimit), flattened for genesis import/export.
+ * @name ReactionCounterEntry
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.ReactionCounterEntry
+ */
+export interface ReactionCounterEntry {
+    key: string;
+    value: number;
+}
+export interface ReactionCounterEntryProtoMsg {
+    typeUrl: "/sparkdream.collect.v1.ReactionCounterEntry";
+    value: Uint8Array;
+}
+/**
+ * ReactionCounterEntry is one string-keyed uint32 counter (ReactionDedup or
+ * ReactionLimit), flattened for genesis import/export.
+ * @name ReactionCounterEntryAmino
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.ReactionCounterEntry
+ */
+export interface ReactionCounterEntryAmino {
+    key?: string;
+    value?: number;
+}
+export interface ReactionCounterEntryAminoMsg {
+    type: "/sparkdream.collect.v1.ReactionCounterEntry";
+    value: ReactionCounterEntryAmino;
+}
+/**
+ * PromotionQueueEntry is one queued author and the height it was enqueued.
+ * @name PromotionQueueEntry
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.PromotionQueueEntry
+ */
+export interface PromotionQueueEntry {
+    address: string;
+    enqueuedAt: bigint;
+}
+export interface PromotionQueueEntryProtoMsg {
+    typeUrl: "/sparkdream.collect.v1.PromotionQueueEntry";
+    value: Uint8Array;
+}
+/**
+ * PromotionQueueEntry is one queued author and the height it was enqueued.
+ * @name PromotionQueueEntryAmino
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.PromotionQueueEntry
+ */
+export interface PromotionQueueEntryAmino {
+    address?: string;
+    enqueued_at?: string;
+}
+export interface PromotionQueueEntryAminoMsg {
+    type: "/sparkdream.collect.v1.PromotionQueueEntry";
+    value: PromotionQueueEntryAmino;
+}
 /**
  * GenesisState defines the collect module's genesis state.
  * @name GenesisState
@@ -81,3 +211,59 @@ export declare const GenesisState: {
     toProto(message: GenesisState): Uint8Array;
     toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
 };
+/**
+ * CurationChallengeDeadline is the block height at which the pending
+ * challenge on review_id resolves as not adjudicated.
+ * @name CurationChallengeDeadline
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.CurationChallengeDeadline
+ */
+export declare const CurationChallengeDeadline: {
+    typeUrl: string;
+    encode(message: CurationChallengeDeadline, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CurationChallengeDeadline;
+    fromPartial(object: DeepPartial<CurationChallengeDeadline>): CurationChallengeDeadline;
+    fromAmino(object: CurationChallengeDeadlineAmino): CurationChallengeDeadline;
+    toAmino(message: CurationChallengeDeadline): CurationChallengeDeadlineAmino;
+    fromAminoMsg(object: CurationChallengeDeadlineAminoMsg): CurationChallengeDeadline;
+    fromProtoMsg(message: CurationChallengeDeadlineProtoMsg): CurationChallengeDeadline;
+    toProto(message: CurationChallengeDeadline): Uint8Array;
+    toProtoMsg(message: CurationChallengeDeadline): CurationChallengeDeadlineProtoMsg;
+};
+/**
+ * ReactionCounterEntry is one string-keyed uint32 counter (ReactionDedup or
+ * ReactionLimit), flattened for genesis import/export.
+ * @name ReactionCounterEntry
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.ReactionCounterEntry
+ */
+export declare const ReactionCounterEntry: {
+    typeUrl: string;
+    encode(message: ReactionCounterEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ReactionCounterEntry;
+    fromPartial(object: DeepPartial<ReactionCounterEntry>): ReactionCounterEntry;
+    fromAmino(object: ReactionCounterEntryAmino): ReactionCounterEntry;
+    toAmino(message: ReactionCounterEntry): ReactionCounterEntryAmino;
+    fromAminoMsg(object: ReactionCounterEntryAminoMsg): ReactionCounterEntry;
+    fromProtoMsg(message: ReactionCounterEntryProtoMsg): ReactionCounterEntry;
+    toProto(message: ReactionCounterEntry): Uint8Array;
+    toProtoMsg(message: ReactionCounterEntry): ReactionCounterEntryProtoMsg;
+};
+/**
+ * PromotionQueueEntry is one queued author and the height it was enqueued.
+ * @name PromotionQueueEntry
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.PromotionQueueEntry
+ */
+export declare const PromotionQueueEntry: {
+    typeUrl: string;
+    encode(message: PromotionQueueEntry, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PromotionQueueEntry;
+    fromPartial(object: DeepPartial<PromotionQueueEntry>): PromotionQueueEntry;
+    fromAmino(object: PromotionQueueEntryAmino): PromotionQueueEntry;
+    toAmino(message: PromotionQueueEntry): PromotionQueueEntryAmino;
+    fromAminoMsg(object: PromotionQueueEntryAminoMsg): PromotionQueueEntry;
+    fromProtoMsg(message: PromotionQueueEntryProtoMsg): PromotionQueueEntry;
+    toProto(message: PromotionQueueEntry): Uint8Array;
+    toProtoMsg(message: PromotionQueueEntry): PromotionQueueEntryProtoMsg;
+};

package/sparkdream/collect/v1/genesis.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenesisState = void 0;
+exports.PromotionQueueEntry = exports.ReactionCounterEntry = exports.CurationChallengeDeadline = exports.GenesisState = void 0;
 //@ts-nocheck
 const params_1 = require("./params");
 const types_1 = require("./types");
@@ -22,7 +22,11 @@ function createBaseGenesisState() {
         flags: [],
         hideRecords: [],
         hideRecordCount: BigInt(0),
-        endorsements: []
+        endorsements: [],
+        reactionDedups: [],
+        reactionLimits: [],
+        curationChallengeDeadlines: [],
+        promotionQueue: []
     };
 }
 /**
@@ -53,7 +57,7 @@ exports.GenesisState = {
             types_1.Collaborator.encode(v, writer.uint32(50).fork()).ldelim();
         }
         for (const v of message.curatorActivities) {
-            curator_activity_1.CuratorActivity.encode(v, writer.uint32(130).fork()).ldelim();
+            curator_activity_1.CuratorActivity.encode(v, writer.uint32(58).fork()).ldelim();
         }
         for (const v of message.curationReviews) {
             types_1.CurationReview.encode(v, writer.uint32(66).fork()).ldelim();
@@ -79,6 +83,18 @@ exports.GenesisState = {
         for (const v of message.endorsements) {
             types_1.Endorsement.encode(v, writer.uint32(122).fork()).ldelim();
         }
+        for (const v of message.reactionDedups) {
+            exports.ReactionCounterEntry.encode(v, writer.uint32(130).fork()).ldelim();
+        }
+        for (const v of message.reactionLimits) {
+            exports.ReactionCounterEntry.encode(v, writer.uint32(138).fork()).ldelim();
+        }
+        for (const v of message.curationChallengeDeadlines) {
+            exports.CurationChallengeDeadline.encode(v, writer.uint32(146).fork()).ldelim();
+        }
+        for (const v of message.promotionQueue) {
+            exports.PromotionQueueEntry.encode(v, writer.uint32(154).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
@@ -106,7 +122,7 @@ exports.GenesisState = {
                 case 6:
                     message.collaborators.push(types_1.Collaborator.decode(reader, reader.uint32()));
                     break;
-                case 16:
+                case 7:
                     message.curatorActivities.push(curator_activity_1.CuratorActivity.decode(reader, reader.uint32()));
                     break;
                 case 8:
@@ -133,6 +149,18 @@ exports.GenesisState = {
                 case 15:
                     message.endorsements.push(types_1.Endorsement.decode(reader, reader.uint32()));
                     break;
+                case 16:
+                    message.reactionDedups.push(exports.ReactionCounterEntry.decode(reader, reader.uint32()));
+                    break;
+                case 17:
+                    message.reactionLimits.push(exports.ReactionCounterEntry.decode(reader, reader.uint32()));
+                    break;
+                case 18:
+                    message.curationChallengeDeadlines.push(exports.CurationChallengeDeadline.decode(reader, reader.uint32()));
+                    break;
+                case 19:
+                    message.promotionQueue.push(exports.PromotionQueueEntry.decode(reader, reader.uint32()));
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -157,6 +185,10 @@ exports.GenesisState = {
         message.hideRecords = object.hideRecords?.map(e => types_1.HideRecord.fromPartial(e)) || [];
         message.hideRecordCount = object.hideRecordCount !== undefined && object.hideRecordCount !== null ? BigInt(object.hideRecordCount.toString()) : BigInt(0);
         message.endorsements = object.endorsements?.map(e => types_1.Endorsement.fromPartial(e)) || [];
+        message.reactionDedups = object.reactionDedups?.map(e => exports.ReactionCounterEntry.fromPartial(e)) || [];
+        message.reactionLimits = object.reactionLimits?.map(e => exports.ReactionCounterEntry.fromPartial(e)) || [];
+        message.curationChallengeDeadlines = object.curationChallengeDeadlines?.map(e => exports.CurationChallengeDeadline.fromPartial(e)) || [];
+        message.promotionQueue = object.promotionQueue?.map(e => exports.PromotionQueueEntry.fromPartial(e)) || [];
         return message;
     },
     fromAmino(object) {
@@ -186,6 +218,10 @@ exports.GenesisState = {
             message.hideRecordCount = BigInt(object.hide_record_count);
         }
         message.endorsements = object.endorsements?.map(e => types_1.Endorsement.fromAmino(e)) || [];
+        message.reactionDedups = object.reaction_dedups?.map(e => exports.ReactionCounterEntry.fromAmino(e)) || [];
+        message.reactionLimits = object.reaction_limits?.map(e => exports.ReactionCounterEntry.fromAmino(e)) || [];
+        message.curationChallengeDeadlines = object.curation_challenge_deadlines?.map(e => exports.CurationChallengeDeadline.fromAmino(e)) || [];
+        message.promotionQueue = object.promotion_queue?.map(e => exports.PromotionQueueEntry.fromAmino(e)) || [];
         return message;
     },
     toAmino(message) {
@@ -255,6 +291,30 @@ exports.GenesisState = {
         else {
             obj.endorsements = message.endorsements;
         }
+        if (message.reactionDedups) {
+            obj.reaction_dedups = message.reactionDedups.map(e => e ? exports.ReactionCounterEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.reaction_dedups = message.reactionDedups;
+        }
+        if (message.reactionLimits) {
+            obj.reaction_limits = message.reactionLimits.map(e => e ? exports.ReactionCounterEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.reaction_limits = message.reactionLimits;
+        }
+        if (message.curationChallengeDeadlines) {
+            obj.curation_challenge_deadlines = message.curationChallengeDeadlines.map(e => e ? exports.CurationChallengeDeadline.toAmino(e) : undefined);
+        }
+        else {
+            obj.curation_challenge_deadlines = message.curationChallengeDeadlines;
+        }
+        if (message.promotionQueue) {
+            obj.promotion_queue = message.promotionQueue.map(e => e ? exports.PromotionQueueEntry.toAmino(e) : undefined);
+        }
+        else {
+            obj.promotion_queue = message.promotionQueue;
+        }
         return obj;
     },
     fromAminoMsg(object) {
@@ -273,3 +333,248 @@ exports.GenesisState = {
         };
     }
 };
+function createBaseCurationChallengeDeadline() {
+    return {
+        deadline: BigInt(0),
+        reviewId: BigInt(0)
+    };
+}
+/**
+ * CurationChallengeDeadline is the block height at which the pending
+ * challenge on review_id resolves as not adjudicated.
+ * @name CurationChallengeDeadline
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.CurationChallengeDeadline
+ */
+exports.CurationChallengeDeadline = {
+    typeUrl: "/sparkdream.collect.v1.CurationChallengeDeadline",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.deadline !== BigInt(0)) {
+            writer.uint32(8).int64(message.deadline);
+        }
+        if (message.reviewId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.reviewId);
+        }
+        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 = createBaseCurationChallengeDeadline();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.deadline = reader.int64();
+                    break;
+                case 2:
+                    message.reviewId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCurationChallengeDeadline();
+        message.deadline = object.deadline !== undefined && object.deadline !== null ? BigInt(object.deadline.toString()) : BigInt(0);
+        message.reviewId = object.reviewId !== undefined && object.reviewId !== null ? BigInt(object.reviewId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCurationChallengeDeadline();
+        if (object.deadline !== undefined && object.deadline !== null) {
+            message.deadline = BigInt(object.deadline);
+        }
+        if (object.review_id !== undefined && object.review_id !== null) {
+            message.reviewId = BigInt(object.review_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.deadline = message.deadline !== BigInt(0) ? message.deadline?.toString() : undefined;
+        obj.review_id = message.reviewId !== BigInt(0) ? message.reviewId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.CurationChallengeDeadline.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.CurationChallengeDeadline.decode(message.value);
+    },
+    toProto(message) {
+        return exports.CurationChallengeDeadline.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.CurationChallengeDeadline",
+            value: exports.CurationChallengeDeadline.encode(message).finish()
+        };
+    }
+};
+function createBaseReactionCounterEntry() {
+    return {
+        key: "",
+        value: 0
+    };
+}
+/**
+ * ReactionCounterEntry is one string-keyed uint32 counter (ReactionDedup or
+ * ReactionLimit), flattened for genesis import/export.
+ * @name ReactionCounterEntry
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.ReactionCounterEntry
+ */
+exports.ReactionCounterEntry = {
+    typeUrl: "/sparkdream.collect.v1.ReactionCounterEntry",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== 0) {
+            writer.uint32(16).uint32(message.value);
+        }
+        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 = createBaseReactionCounterEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReactionCounterEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReactionCounterEntry();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value === 0 ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ReactionCounterEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ReactionCounterEntry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ReactionCounterEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.ReactionCounterEntry",
+            value: exports.ReactionCounterEntry.encode(message).finish()
+        };
+    }
+};
+function createBasePromotionQueueEntry() {
+    return {
+        address: "",
+        enqueuedAt: BigInt(0)
+    };
+}
+/**
+ * PromotionQueueEntry is one queued author and the height it was enqueued.
+ * @name PromotionQueueEntry
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.PromotionQueueEntry
+ */
+exports.PromotionQueueEntry = {
+    typeUrl: "/sparkdream.collect.v1.PromotionQueueEntry",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.enqueuedAt !== BigInt(0)) {
+            writer.uint32(16).int64(message.enqueuedAt);
+        }
+        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 = createBasePromotionQueueEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.enqueuedAt = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePromotionQueueEntry();
+        message.address = object.address ?? "";
+        message.enqueuedAt = object.enqueuedAt !== undefined && object.enqueuedAt !== null ? BigInt(object.enqueuedAt.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePromotionQueueEntry();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.enqueued_at !== undefined && object.enqueued_at !== null) {
+            message.enqueuedAt = BigInt(object.enqueued_at);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.enqueued_at = message.enqueuedAt !== BigInt(0) ? message.enqueuedAt?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PromotionQueueEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.PromotionQueueEntry.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PromotionQueueEntry.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.PromotionQueueEntry",
+            value: exports.PromotionQueueEntry.encode(message).finish()
+        };
+    }
+};

package/sparkdream/collect/v1/tx.d.ts

@@ -1677,6 +1677,66 @@ export interface MsgUnhideContentResponseAminoMsg {
     type: "/sparkdream.collect.v1.MsgUnhideContentResponse";
     value: MsgUnhideContentResponseAmino;
 }
+/**
+ * MsgResolveCurationChallenge delivers the verdict on a curation challenge.
+ * upheld = true overturns the review and slashes the curator's committed
+ * bond; upheld = false lets the review stand and burns the challenge deposit.
+ * @name MsgResolveCurationChallenge
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.MsgResolveCurationChallenge
+ */
+export interface MsgResolveCurationChallenge {
+    creator: string;
+    reviewId: bigint;
+    upheld: boolean;
+    reason: string;
+}
+export interface MsgResolveCurationChallengeProtoMsg {
+    typeUrl: "/sparkdream.collect.v1.MsgResolveCurationChallenge";
+    value: Uint8Array;
+}
+/**
+ * MsgResolveCurationChallenge delivers the verdict on a curation challenge.
+ * upheld = true overturns the review and slashes the curator's committed
+ * bond; upheld = false lets the review stand and burns the challenge deposit.
+ * @name MsgResolveCurationChallengeAmino
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.MsgResolveCurationChallenge
+ */
+export interface MsgResolveCurationChallengeAmino {
+    creator?: string;
+    review_id?: string;
+    upheld?: boolean;
+    reason?: string;
+}
+export interface MsgResolveCurationChallengeAminoMsg {
+    type: "sparkdream/x/collect/MsgResolveCurationChallenge";
+    value: MsgResolveCurationChallengeAmino;
+}
+/**
+ * MsgResolveCurationChallengeResponse defines the MsgResolveCurationChallengeResponse message.
+ * @name MsgResolveCurationChallengeResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.MsgResolveCurationChallengeResponse
+ */
+export interface MsgResolveCurationChallengeResponse {
+}
+export interface MsgResolveCurationChallengeResponseProtoMsg {
+    typeUrl: "/sparkdream.collect.v1.MsgResolveCurationChallengeResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgResolveCurationChallengeResponse defines the MsgResolveCurationChallengeResponse message.
+ * @name MsgResolveCurationChallengeResponseAmino
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.MsgResolveCurationChallengeResponse
+ */
+export interface MsgResolveCurationChallengeResponseAmino {
+}
+export interface MsgResolveCurationChallengeResponseAminoMsg {
+    type: "/sparkdream.collect.v1.MsgResolveCurationChallengeResponse";
+    value: MsgResolveCurationChallengeResponseAmino;
+}
 /**
  * MsgUpdateParams is the Msg/UpdateParams request type.
  * @name MsgUpdateParams
@@ -2783,3 +2843,43 @@ export declare const MsgUnhideContentResponse: {
     toProto(message: MsgUnhideContentResponse): Uint8Array;
     toProtoMsg(message: MsgUnhideContentResponse): MsgUnhideContentResponseProtoMsg;
 };
+/**
+ * MsgResolveCurationChallenge delivers the verdict on a curation challenge.
+ * upheld = true overturns the review and slashes the curator's committed
+ * bond; upheld = false lets the review stand and burns the challenge deposit.
+ * @name MsgResolveCurationChallenge
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.MsgResolveCurationChallenge
+ */
+export declare const MsgResolveCurationChallenge: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: MsgResolveCurationChallenge, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgResolveCurationChallenge;
+    fromPartial(object: DeepPartial<MsgResolveCurationChallenge>): MsgResolveCurationChallenge;
+    fromAmino(object: MsgResolveCurationChallengeAmino): MsgResolveCurationChallenge;
+    toAmino(message: MsgResolveCurationChallenge): MsgResolveCurationChallengeAmino;
+    fromAminoMsg(object: MsgResolveCurationChallengeAminoMsg): MsgResolveCurationChallenge;
+    toAminoMsg(message: MsgResolveCurationChallenge): MsgResolveCurationChallengeAminoMsg;
+    fromProtoMsg(message: MsgResolveCurationChallengeProtoMsg): MsgResolveCurationChallenge;
+    toProto(message: MsgResolveCurationChallenge): Uint8Array;
+    toProtoMsg(message: MsgResolveCurationChallenge): MsgResolveCurationChallengeProtoMsg;
+};
+/**
+ * MsgResolveCurationChallengeResponse defines the MsgResolveCurationChallengeResponse message.
+ * @name MsgResolveCurationChallengeResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.MsgResolveCurationChallengeResponse
+ */
+export declare const MsgResolveCurationChallengeResponse: {
+    typeUrl: string;
+    encode(_: MsgResolveCurationChallengeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgResolveCurationChallengeResponse;
+    fromPartial(_: DeepPartial<MsgResolveCurationChallengeResponse>): MsgResolveCurationChallengeResponse;
+    fromAmino(_: MsgResolveCurationChallengeResponseAmino): MsgResolveCurationChallengeResponse;
+    toAmino(_: MsgResolveCurationChallengeResponse): MsgResolveCurationChallengeResponseAmino;
+    fromAminoMsg(object: MsgResolveCurationChallengeResponseAminoMsg): MsgResolveCurationChallengeResponse;
+    fromProtoMsg(message: MsgResolveCurationChallengeResponseProtoMsg): MsgResolveCurationChallengeResponse;
+    toProto(message: MsgResolveCurationChallengeResponse): Uint8Array;
+    toProtoMsg(message: MsgResolveCurationChallengeResponse): MsgResolveCurationChallengeResponseProtoMsg;
+};