@sparkdreamnft/sparkdreamjs 0.0.18 → 0.0.20

package/esm/sparkdream/forum/v1/types.js

@@ -1,5 +1,6 @@
 //@ts-nocheck
 import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
 /** PostStatus represents the status of a post. */
 export var PostStatus;
 (function (PostStatus) {
@@ -540,3 +541,357 @@ export const PinnedReplyRecord = {
         };
     }
 };
+function createBaseForumRepEpochCounter() {
+    return {
+        epochId: BigInt(0),
+        accumulated: ""
+    };
+}
+/**
+ * ForumRepEpochCounter tracks how much forum reputation a single author has
+ * earned in a single tag during the current UTC-day epoch. Reset implicitly
+ * by comparing epoch_id to floor(block_time / 86400) on read — when the
+ * stored epoch_id is stale, the accumulated counter is treated as zero and
+ * overwritten on the next credit. Used by the post-conviction accrual loop
+ * to enforce Params.max_forum_rep_per_tag_per_epoch.
+ * @name ForumRepEpochCounter
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ForumRepEpochCounter
+ */
+export const ForumRepEpochCounter = {
+    typeUrl: "/sparkdream.forum.v1.ForumRepEpochCounter",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.epochId !== BigInt(0)) {
+            writer.uint32(8).int64(message.epochId);
+        }
+        if (message.accumulated !== "") {
+            writer.uint32(18).string(Decimal.fromUserInput(message.accumulated, 18).atomics);
+        }
+        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 = createBaseForumRepEpochCounter();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.epochId = reader.int64();
+                    break;
+                case 2:
+                    message.accumulated = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseForumRepEpochCounter();
+        message.epochId = object.epochId !== undefined && object.epochId !== null ? BigInt(object.epochId.toString()) : BigInt(0);
+        message.accumulated = object.accumulated ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseForumRepEpochCounter();
+        if (object.epoch_id !== undefined && object.epoch_id !== null) {
+            message.epochId = BigInt(object.epoch_id);
+        }
+        if (object.accumulated !== undefined && object.accumulated !== null) {
+            message.accumulated = object.accumulated;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.epoch_id = message.epochId !== BigInt(0) ? message.epochId?.toString() : undefined;
+        obj.accumulated = message.accumulated === "" ? undefined : message.accumulated;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ForumRepEpochCounter.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ForumRepEpochCounter.decode(message.value);
+    },
+    toProto(message) {
+        return ForumRepEpochCounter.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.ForumRepEpochCounter",
+            value: ForumRepEpochCounter.encode(message).finish()
+        };
+    }
+};
+function createBasePostConvictionStake_AccruedRepPerTagEntry() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * @name PostConvictionStake_AccruedRepPerTagEntry
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.undefined
+ */
+export const PostConvictionStake_AccruedRepPerTagEntry = {
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        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 = createBasePostConvictionStake_AccruedRepPerTagEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePostConvictionStake_AccruedRepPerTagEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePostConvictionStake_AccruedRepPerTagEntry();
+        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 === "" ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PostConvictionStake_AccruedRepPerTagEntry.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PostConvictionStake_AccruedRepPerTagEntry.decode(message.value);
+    },
+    toProto(message) {
+        return PostConvictionStake_AccruedRepPerTagEntry.encode(message).finish();
+    }
+};
+function createBasePostConvictionStake() {
+    return {
+        id: BigInt(0),
+        staker: "",
+        postId: BigInt(0),
+        amount: "",
+        stakedAt: BigInt(0),
+        unlocksAt: BigInt(0),
+        accruedRepPerTag: {},
+        lastAccrualAt: BigInt(0),
+        released: false
+    };
+}
+/**
+ * PostConvictionStake records an ESTABLISHED+ member's DREAM lock backing a
+ * post's author. While the stake is active, the EndBlocker streams per-tag
+ * reputation to the author proportional to the stake's share of total active
+ * stakes on the post (split evenly across the post's tags). On confirmed
+ * sentinel hide (ExpireHiddenPosts), the accrued rep is clawed back from the
+ * author per tag and a fraction of the staker's locked DREAM is slashed
+ * (staker_slash_bps) — both staker and author endorsed harm.
+ *
+ * Stakers cannot stake on their own posts. Stakes are released after
+ * unlocks_at via MsgReleasePostConviction; LockDREAM/UnlockDREAM bypass the
+ * 3% transfer tax because it is internal member-balance rebalancing, not a
+ * transfer.
+ * @name PostConvictionStake
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.PostConvictionStake
+ */
+export const PostConvictionStake = {
+    typeUrl: "/sparkdream.forum.v1.PostConvictionStake",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        if (message.staker !== "") {
+            writer.uint32(18).string(message.staker);
+        }
+        if (message.postId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.postId);
+        }
+        if (message.amount !== "") {
+            writer.uint32(34).string(message.amount);
+        }
+        if (message.stakedAt !== BigInt(0)) {
+            writer.uint32(40).int64(message.stakedAt);
+        }
+        if (message.unlocksAt !== BigInt(0)) {
+            writer.uint32(48).int64(message.unlocksAt);
+        }
+        Object.entries(message.accruedRepPerTag).forEach(([key, value]) => {
+            PostConvictionStake_AccruedRepPerTagEntry.encode({
+                key: key,
+                value
+            }, writer.uint32(58).fork()).ldelim();
+        });
+        if (message.lastAccrualAt !== BigInt(0)) {
+            writer.uint32(64).int64(message.lastAccrualAt);
+        }
+        if (message.released === true) {
+            writer.uint32(72).bool(message.released);
+        }
+        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 = createBasePostConvictionStake();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                case 2:
+                    message.staker = reader.string();
+                    break;
+                case 3:
+                    message.postId = reader.uint64();
+                    break;
+                case 4:
+                    message.amount = reader.string();
+                    break;
+                case 5:
+                    message.stakedAt = reader.int64();
+                    break;
+                case 6:
+                    message.unlocksAt = reader.int64();
+                    break;
+                case 7:
+                    const entry7 = PostConvictionStake_AccruedRepPerTagEntry.decode(reader, reader.uint32());
+                    if (entry7.value !== undefined) {
+                        message.accruedRepPerTag[entry7.key] = entry7.value;
+                    }
+                    break;
+                case 8:
+                    message.lastAccrualAt = reader.int64();
+                    break;
+                case 9:
+                    message.released = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePostConvictionStake();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.staker = object.staker ?? "";
+        message.postId = object.postId !== undefined && object.postId !== null ? BigInt(object.postId.toString()) : BigInt(0);
+        message.amount = object.amount ?? "";
+        message.stakedAt = object.stakedAt !== undefined && object.stakedAt !== null ? BigInt(object.stakedAt.toString()) : BigInt(0);
+        message.unlocksAt = object.unlocksAt !== undefined && object.unlocksAt !== null ? BigInt(object.unlocksAt.toString()) : BigInt(0);
+        message.accruedRepPerTag = Object.entries(object.accruedRepPerTag ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        message.lastAccrualAt = object.lastAccrualAt !== undefined && object.lastAccrualAt !== null ? BigInt(object.lastAccrualAt.toString()) : BigInt(0);
+        message.released = object.released ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePostConvictionStake();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        if (object.staker !== undefined && object.staker !== null) {
+            message.staker = object.staker;
+        }
+        if (object.post_id !== undefined && object.post_id !== null) {
+            message.postId = BigInt(object.post_id);
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        if (object.staked_at !== undefined && object.staked_at !== null) {
+            message.stakedAt = BigInt(object.staked_at);
+        }
+        if (object.unlocks_at !== undefined && object.unlocks_at !== null) {
+            message.unlocksAt = BigInt(object.unlocks_at);
+        }
+        message.accruedRepPerTag = Object.entries(object.accrued_rep_per_tag ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        if (object.last_accrual_at !== undefined && object.last_accrual_at !== null) {
+            message.lastAccrualAt = BigInt(object.last_accrual_at);
+        }
+        if (object.released !== undefined && object.released !== null) {
+            message.released = object.released;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.staker = message.staker === "" ? undefined : message.staker;
+        obj.post_id = message.postId !== BigInt(0) ? message.postId?.toString() : undefined;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        obj.staked_at = message.stakedAt !== BigInt(0) ? message.stakedAt?.toString() : undefined;
+        obj.unlocks_at = message.unlocksAt !== BigInt(0) ? message.unlocksAt?.toString() : undefined;
+        obj.accrued_rep_per_tag = {};
+        if (message.accruedRepPerTag) {
+            Object.entries(message.accruedRepPerTag).forEach(([k, v]) => {
+                obj.accrued_rep_per_tag[k] = v;
+            });
+        }
+        obj.last_accrual_at = message.lastAccrualAt !== BigInt(0) ? message.lastAccrualAt?.toString() : undefined;
+        obj.released = message.released === false ? undefined : message.released;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PostConvictionStake.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PostConvictionStake.decode(message.value);
+    },
+    toProto(message) {
+        return PostConvictionStake.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.PostConvictionStake",
+            value: PostConvictionStake.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/forum/v1/user_rate_limit.js

@@ -6,11 +6,17 @@ function createBaseUserRateLimit() {
         currentEpochCount: BigInt(0),
         previousEpochCount: BigInt(0),
         currentEpochStart: BigInt(0),
-        lastPostTime: BigInt(0)
+        lastPostTime: BigInt(0),
+        makePermanentCurrentEpochCount: BigInt(0),
+        makePermanentPreviousEpochCount: BigInt(0),
+        makePermanentCurrentEpochStart: BigInt(0)
     };
 }
 /**
- * UserRateLimit defines the UserRateLimit message.
+ * UserRateLimit defines the UserRateLimit message. Counters are split by
+ * action class — the post counter (fields 2-5) bounds CreatePost, the
+ * make-permanent counter (fields 6-8) bounds MakePostPermanent. They are
+ * kept on the same record to avoid an extra collection lookup per call.
  * @name UserRateLimit
  * @package sparkdream.forum.v1
  * @see proto type: sparkdream.forum.v1.UserRateLimit
@@ -33,6 +39,15 @@ export const UserRateLimit = {
         if (message.lastPostTime !== BigInt(0)) {
             writer.uint32(40).int64(message.lastPostTime);
         }
+        if (message.makePermanentCurrentEpochCount !== BigInt(0)) {
+            writer.uint32(48).uint64(message.makePermanentCurrentEpochCount);
+        }
+        if (message.makePermanentPreviousEpochCount !== BigInt(0)) {
+            writer.uint32(56).uint64(message.makePermanentPreviousEpochCount);
+        }
+        if (message.makePermanentCurrentEpochStart !== BigInt(0)) {
+            writer.uint32(64).int64(message.makePermanentCurrentEpochStart);
+        }
         return writer;
     },
     decode(input, length) {
@@ -57,6 +72,15 @@ export const UserRateLimit = {
                 case 5:
                     message.lastPostTime = reader.int64();
                     break;
+                case 6:
+                    message.makePermanentCurrentEpochCount = reader.uint64();
+                    break;
+                case 7:
+                    message.makePermanentPreviousEpochCount = reader.uint64();
+                    break;
+                case 8:
+                    message.makePermanentCurrentEpochStart = reader.int64();
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -71,6 +95,9 @@ export const UserRateLimit = {
         message.previousEpochCount = object.previousEpochCount !== undefined && object.previousEpochCount !== null ? BigInt(object.previousEpochCount.toString()) : BigInt(0);
         message.currentEpochStart = object.currentEpochStart !== undefined && object.currentEpochStart !== null ? BigInt(object.currentEpochStart.toString()) : BigInt(0);
         message.lastPostTime = object.lastPostTime !== undefined && object.lastPostTime !== null ? BigInt(object.lastPostTime.toString()) : BigInt(0);
+        message.makePermanentCurrentEpochCount = object.makePermanentCurrentEpochCount !== undefined && object.makePermanentCurrentEpochCount !== null ? BigInt(object.makePermanentCurrentEpochCount.toString()) : BigInt(0);
+        message.makePermanentPreviousEpochCount = object.makePermanentPreviousEpochCount !== undefined && object.makePermanentPreviousEpochCount !== null ? BigInt(object.makePermanentPreviousEpochCount.toString()) : BigInt(0);
+        message.makePermanentCurrentEpochStart = object.makePermanentCurrentEpochStart !== undefined && object.makePermanentCurrentEpochStart !== null ? BigInt(object.makePermanentCurrentEpochStart.toString()) : BigInt(0);
         return message;
     },
     fromAmino(object) {
@@ -90,6 +117,15 @@ export const UserRateLimit = {
         if (object.last_post_time !== undefined && object.last_post_time !== null) {
             message.lastPostTime = BigInt(object.last_post_time);
         }
+        if (object.make_permanent_current_epoch_count !== undefined && object.make_permanent_current_epoch_count !== null) {
+            message.makePermanentCurrentEpochCount = BigInt(object.make_permanent_current_epoch_count);
+        }
+        if (object.make_permanent_previous_epoch_count !== undefined && object.make_permanent_previous_epoch_count !== null) {
+            message.makePermanentPreviousEpochCount = BigInt(object.make_permanent_previous_epoch_count);
+        }
+        if (object.make_permanent_current_epoch_start !== undefined && object.make_permanent_current_epoch_start !== null) {
+            message.makePermanentCurrentEpochStart = BigInt(object.make_permanent_current_epoch_start);
+        }
         return message;
     },
     toAmino(message) {
@@ -99,6 +135,9 @@ export const UserRateLimit = {
         obj.previous_epoch_count = message.previousEpochCount !== BigInt(0) ? message.previousEpochCount?.toString() : undefined;
         obj.current_epoch_start = message.currentEpochStart !== BigInt(0) ? message.currentEpochStart?.toString() : undefined;
         obj.last_post_time = message.lastPostTime !== BigInt(0) ? message.lastPostTime?.toString() : undefined;
+        obj.make_permanent_current_epoch_count = message.makePermanentCurrentEpochCount !== BigInt(0) ? message.makePermanentCurrentEpochCount?.toString() : undefined;
+        obj.make_permanent_previous_epoch_count = message.makePermanentPreviousEpochCount !== BigInt(0) ? message.makePermanentPreviousEpochCount?.toString() : undefined;
+        obj.make_permanent_current_epoch_start = message.makePermanentCurrentEpochStart !== BigInt(0) ? message.makePermanentCurrentEpochStart?.toString() : undefined;
         return obj;
     },
     fromAminoMsg(object) {