@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

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

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseModule() {
+    return {
+        authority: ""
+    };
+}
+/**
+ * Module is the config object for the module.
+ * @name Module
+ * @package sparkdream.forum.module.v1
+ * @see proto type: sparkdream.forum.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.forum.module.v1.Module",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        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 = createBaseModule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseModule();
+        message.authority = object.authority ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModule();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Module.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Module.decode(message.value);
+    },
+    toProto(message) {
+        return Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,119 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseArchiveMetadata() {
+    return {
+        rootId: BigInt(0),
+        archiveCount: BigInt(0),
+        firstArchivedAt: BigInt(0),
+        lastArchivedAt: BigInt(0),
+        hrOverrideRequired: false
+    };
+}
+/**
+ * ArchiveMetadata defines the ArchiveMetadata message.
+ * @name ArchiveMetadata
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ArchiveMetadata
+ */
+export const ArchiveMetadata = {
+    typeUrl: "/sparkdream.forum.v1.ArchiveMetadata",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.rootId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.rootId);
+        }
+        if (message.archiveCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.archiveCount);
+        }
+        if (message.firstArchivedAt !== BigInt(0)) {
+            writer.uint32(24).int64(message.firstArchivedAt);
+        }
+        if (message.lastArchivedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.lastArchivedAt);
+        }
+        if (message.hrOverrideRequired === true) {
+            writer.uint32(40).bool(message.hrOverrideRequired);
+        }
+        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 = createBaseArchiveMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.rootId = reader.uint64();
+                    break;
+                case 2:
+                    message.archiveCount = reader.uint64();
+                    break;
+                case 3:
+                    message.firstArchivedAt = reader.int64();
+                    break;
+                case 4:
+                    message.lastArchivedAt = reader.int64();
+                    break;
+                case 5:
+                    message.hrOverrideRequired = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseArchiveMetadata();
+        message.rootId = object.rootId !== undefined && object.rootId !== null ? BigInt(object.rootId.toString()) : BigInt(0);
+        message.archiveCount = object.archiveCount !== undefined && object.archiveCount !== null ? BigInt(object.archiveCount.toString()) : BigInt(0);
+        message.firstArchivedAt = object.firstArchivedAt !== undefined && object.firstArchivedAt !== null ? BigInt(object.firstArchivedAt.toString()) : BigInt(0);
+        message.lastArchivedAt = object.lastArchivedAt !== undefined && object.lastArchivedAt !== null ? BigInt(object.lastArchivedAt.toString()) : BigInt(0);
+        message.hrOverrideRequired = object.hrOverrideRequired ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseArchiveMetadata();
+        if (object.root_id !== undefined && object.root_id !== null) {
+            message.rootId = BigInt(object.root_id);
+        }
+        if (object.archive_count !== undefined && object.archive_count !== null) {
+            message.archiveCount = BigInt(object.archive_count);
+        }
+        if (object.first_archived_at !== undefined && object.first_archived_at !== null) {
+            message.firstArchivedAt = BigInt(object.first_archived_at);
+        }
+        if (object.last_archived_at !== undefined && object.last_archived_at !== null) {
+            message.lastArchivedAt = BigInt(object.last_archived_at);
+        }
+        if (object.hr_override_required !== undefined && object.hr_override_required !== null) {
+            message.hrOverrideRequired = object.hr_override_required;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.root_id = message.rootId !== BigInt(0) ? message.rootId?.toString() : undefined;
+        obj.archive_count = message.archiveCount !== BigInt(0) ? message.archiveCount?.toString() : undefined;
+        obj.first_archived_at = message.firstArchivedAt !== BigInt(0) ? message.firstArchivedAt?.toString() : undefined;
+        obj.last_archived_at = message.lastArchivedAt !== BigInt(0) ? message.lastArchivedAt?.toString() : undefined;
+        obj.hr_override_required = message.hrOverrideRequired === false ? undefined : message.hrOverrideRequired;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ArchiveMetadata.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ArchiveMetadata.decode(message.value);
+    },
+    toProto(message) {
+        return ArchiveMetadata.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.ArchiveMetadata",
+            value: ArchiveMetadata.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,183 @@
+//@ts-nocheck
+import { BountyAward } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseBounty() {
+    return {
+        id: BigInt(0),
+        creator: "",
+        threadId: BigInt(0),
+        amount: "",
+        createdAt: BigInt(0),
+        expiresAt: BigInt(0),
+        status: 0,
+        moderationSuspendedAt: BigInt(0),
+        timeRemainingAtSuspension: BigInt(0),
+        awards: []
+    };
+}
+/**
+ * Bounty defines the Bounty message.
+ * @name Bounty
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.Bounty
+ */
+export const Bounty = {
+    typeUrl: "/sparkdream.forum.v1.Bounty",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        if (message.creator !== "") {
+            writer.uint32(18).string(message.creator);
+        }
+        if (message.threadId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.threadId);
+        }
+        if (message.amount !== "") {
+            writer.uint32(34).string(message.amount);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(40).int64(message.createdAt);
+        }
+        if (message.expiresAt !== BigInt(0)) {
+            writer.uint32(48).int64(message.expiresAt);
+        }
+        if (message.status !== 0) {
+            writer.uint32(56).int32(message.status);
+        }
+        if (message.moderationSuspendedAt !== BigInt(0)) {
+            writer.uint32(64).int64(message.moderationSuspendedAt);
+        }
+        if (message.timeRemainingAtSuspension !== BigInt(0)) {
+            writer.uint32(72).int64(message.timeRemainingAtSuspension);
+        }
+        for (const v of message.awards) {
+            BountyAward.encode(v, writer.uint32(162).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 = createBaseBounty();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                case 2:
+                    message.creator = reader.string();
+                    break;
+                case 3:
+                    message.threadId = reader.uint64();
+                    break;
+                case 4:
+                    message.amount = reader.string();
+                    break;
+                case 5:
+                    message.createdAt = reader.int64();
+                    break;
+                case 6:
+                    message.expiresAt = reader.int64();
+                    break;
+                case 7:
+                    message.status = reader.int32();
+                    break;
+                case 8:
+                    message.moderationSuspendedAt = reader.int64();
+                    break;
+                case 9:
+                    message.timeRemainingAtSuspension = reader.int64();
+                    break;
+                case 20:
+                    message.awards.push(BountyAward.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBounty();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.creator = object.creator ?? "";
+        message.threadId = object.threadId !== undefined && object.threadId !== null ? BigInt(object.threadId.toString()) : BigInt(0);
+        message.amount = object.amount ?? "";
+        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
+        message.expiresAt = object.expiresAt !== undefined && object.expiresAt !== null ? BigInt(object.expiresAt.toString()) : BigInt(0);
+        message.status = object.status ?? 0;
+        message.moderationSuspendedAt = object.moderationSuspendedAt !== undefined && object.moderationSuspendedAt !== null ? BigInt(object.moderationSuspendedAt.toString()) : BigInt(0);
+        message.timeRemainingAtSuspension = object.timeRemainingAtSuspension !== undefined && object.timeRemainingAtSuspension !== null ? BigInt(object.timeRemainingAtSuspension.toString()) : BigInt(0);
+        message.awards = object.awards?.map(e => BountyAward.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBounty();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.thread_id !== undefined && object.thread_id !== null) {
+            message.threadId = BigInt(object.thread_id);
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = object.amount;
+        }
+        if (object.created_at !== undefined && object.created_at !== null) {
+            message.createdAt = BigInt(object.created_at);
+        }
+        if (object.expires_at !== undefined && object.expires_at !== null) {
+            message.expiresAt = BigInt(object.expires_at);
+        }
+        if (object.status !== undefined && object.status !== null) {
+            message.status = object.status;
+        }
+        if (object.moderation_suspended_at !== undefined && object.moderation_suspended_at !== null) {
+            message.moderationSuspendedAt = BigInt(object.moderation_suspended_at);
+        }
+        if (object.time_remaining_at_suspension !== undefined && object.time_remaining_at_suspension !== null) {
+            message.timeRemainingAtSuspension = BigInt(object.time_remaining_at_suspension);
+        }
+        message.awards = object.awards?.map(e => BountyAward.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.thread_id = message.threadId !== BigInt(0) ? message.threadId?.toString() : undefined;
+        obj.amount = message.amount === "" ? undefined : message.amount;
+        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.expires_at = message.expiresAt !== BigInt(0) ? message.expiresAt?.toString() : undefined;
+        obj.status = message.status === 0 ? undefined : message.status;
+        obj.moderation_suspended_at = message.moderationSuspendedAt !== BigInt(0) ? message.moderationSuspendedAt?.toString() : undefined;
+        obj.time_remaining_at_suspension = message.timeRemainingAtSuspension !== BigInt(0) ? message.timeRemainingAtSuspension?.toString() : undefined;
+        if (message.awards) {
+            obj.awards = message.awards.map(e => e ? BountyAward.toAmino(e) : undefined);
+        }
+        else {
+            obj.awards = message.awards;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Bounty.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Bounty.decode(message.value);
+    },
+    toProto(message) {
+        return Bounty.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.Bounty",
+            value: Bounty.encode(message).finish()
+        };
+    }
+};

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

@@ -0,0 +1,292 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { Post } from "./post";
+import { UserRateLimit } from "./user_rate_limit";
+import { UserReactionLimit } from "./user_reaction_limit";
+import { SentinelActivity } from "./sentinel_activity";
+import { HideRecord } from "./hide_record";
+import { ThreadLockRecord } from "./thread_lock_record";
+import { ThreadMoveRecord } from "./thread_move_record";
+import { PostFlag } from "./post_flag";
+import { Bounty } from "./bounty";
+import { ThreadMetadata } from "./thread_metadata";
+import { ThreadFollow } from "./thread_follow";
+import { ThreadFollowCount } from "./thread_follow_count";
+import { ArchiveMetadata } from "./archive_metadata";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseGenesisState() {
+    return {
+        params: Params.fromPartial({}),
+        postMap: [],
+        userRateLimitMap: [],
+        userReactionLimitMap: [],
+        sentinelActivityMap: [],
+        hideRecordMap: [],
+        threadLockRecordMap: [],
+        threadMoveRecordMap: [],
+        postFlagMap: [],
+        bountyList: [],
+        bountyCount: BigInt(0),
+        threadMetadataMap: [],
+        threadFollowMap: [],
+        threadFollowCountMap: [],
+        archiveMetadataMap: []
+    };
+}
+/**
+ * GenesisState defines the forum module's genesis state.
+ * @name GenesisState
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.GenesisState
+ */
+export const GenesisState = {
+    typeUrl: "/sparkdream.forum.v1.GenesisState",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.postMap) {
+            Post.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.userRateLimitMap) {
+            UserRateLimit.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        for (const v of message.userReactionLimitMap) {
+            UserReactionLimit.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.sentinelActivityMap) {
+            SentinelActivity.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.hideRecordMap) {
+            HideRecord.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        for (const v of message.threadLockRecordMap) {
+            ThreadLockRecord.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        for (const v of message.threadMoveRecordMap) {
+            ThreadMoveRecord.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        for (const v of message.postFlagMap) {
+            PostFlag.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        for (const v of message.bountyList) {
+            Bounty.encode(v, writer.uint32(82).fork()).ldelim();
+        }
+        if (message.bountyCount !== BigInt(0)) {
+            writer.uint32(88).uint64(message.bountyCount);
+        }
+        for (const v of message.threadMetadataMap) {
+            ThreadMetadata.encode(v, writer.uint32(98).fork()).ldelim();
+        }
+        for (const v of message.threadFollowMap) {
+            ThreadFollow.encode(v, writer.uint32(106).fork()).ldelim();
+        }
+        for (const v of message.threadFollowCountMap) {
+            ThreadFollowCount.encode(v, writer.uint32(114).fork()).ldelim();
+        }
+        for (const v of message.archiveMetadataMap) {
+            ArchiveMetadata.encode(v, writer.uint32(122).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.postMap.push(Post.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.userRateLimitMap.push(UserRateLimit.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.userReactionLimitMap.push(UserReactionLimit.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.sentinelActivityMap.push(SentinelActivity.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.hideRecordMap.push(HideRecord.decode(reader, reader.uint32()));
+                    break;
+                case 7:
+                    message.threadLockRecordMap.push(ThreadLockRecord.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.threadMoveRecordMap.push(ThreadMoveRecord.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.postFlagMap.push(PostFlag.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.bountyList.push(Bounty.decode(reader, reader.uint32()));
+                    break;
+                case 11:
+                    message.bountyCount = reader.uint64();
+                    break;
+                case 12:
+                    message.threadMetadataMap.push(ThreadMetadata.decode(reader, reader.uint32()));
+                    break;
+                case 13:
+                    message.threadFollowMap.push(ThreadFollow.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.threadFollowCountMap.push(ThreadFollowCount.decode(reader, reader.uint32()));
+                    break;
+                case 15:
+                    message.archiveMetadataMap.push(ArchiveMetadata.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        message.postMap = object.postMap?.map(e => Post.fromPartial(e)) || [];
+        message.userRateLimitMap = object.userRateLimitMap?.map(e => UserRateLimit.fromPartial(e)) || [];
+        message.userReactionLimitMap = object.userReactionLimitMap?.map(e => UserReactionLimit.fromPartial(e)) || [];
+        message.sentinelActivityMap = object.sentinelActivityMap?.map(e => SentinelActivity.fromPartial(e)) || [];
+        message.hideRecordMap = object.hideRecordMap?.map(e => HideRecord.fromPartial(e)) || [];
+        message.threadLockRecordMap = object.threadLockRecordMap?.map(e => ThreadLockRecord.fromPartial(e)) || [];
+        message.threadMoveRecordMap = object.threadMoveRecordMap?.map(e => ThreadMoveRecord.fromPartial(e)) || [];
+        message.postFlagMap = object.postFlagMap?.map(e => PostFlag.fromPartial(e)) || [];
+        message.bountyList = object.bountyList?.map(e => Bounty.fromPartial(e)) || [];
+        message.bountyCount = object.bountyCount !== undefined && object.bountyCount !== null ? BigInt(object.bountyCount.toString()) : BigInt(0);
+        message.threadMetadataMap = object.threadMetadataMap?.map(e => ThreadMetadata.fromPartial(e)) || [];
+        message.threadFollowMap = object.threadFollowMap?.map(e => ThreadFollow.fromPartial(e)) || [];
+        message.threadFollowCountMap = object.threadFollowCountMap?.map(e => ThreadFollowCount.fromPartial(e)) || [];
+        message.archiveMetadataMap = object.archiveMetadataMap?.map(e => ArchiveMetadata.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        message.postMap = object.post_map?.map(e => Post.fromAmino(e)) || [];
+        message.userRateLimitMap = object.user_rate_limit_map?.map(e => UserRateLimit.fromAmino(e)) || [];
+        message.userReactionLimitMap = object.user_reaction_limit_map?.map(e => UserReactionLimit.fromAmino(e)) || [];
+        message.sentinelActivityMap = object.sentinel_activity_map?.map(e => SentinelActivity.fromAmino(e)) || [];
+        message.hideRecordMap = object.hide_record_map?.map(e => HideRecord.fromAmino(e)) || [];
+        message.threadLockRecordMap = object.thread_lock_record_map?.map(e => ThreadLockRecord.fromAmino(e)) || [];
+        message.threadMoveRecordMap = object.thread_move_record_map?.map(e => ThreadMoveRecord.fromAmino(e)) || [];
+        message.postFlagMap = object.post_flag_map?.map(e => PostFlag.fromAmino(e)) || [];
+        message.bountyList = object.bounty_list?.map(e => Bounty.fromAmino(e)) || [];
+        if (object.bounty_count !== undefined && object.bounty_count !== null) {
+            message.bountyCount = BigInt(object.bounty_count);
+        }
+        message.threadMetadataMap = object.thread_metadata_map?.map(e => ThreadMetadata.fromAmino(e)) || [];
+        message.threadFollowMap = object.thread_follow_map?.map(e => ThreadFollow.fromAmino(e)) || [];
+        message.threadFollowCountMap = object.thread_follow_count_map?.map(e => ThreadFollowCount.fromAmino(e)) || [];
+        message.archiveMetadataMap = object.archive_metadata_map?.map(e => ArchiveMetadata.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+        if (message.postMap) {
+            obj.post_map = message.postMap.map(e => e ? Post.toAmino(e) : undefined);
+        }
+        else {
+            obj.post_map = message.postMap;
+        }
+        if (message.userRateLimitMap) {
+            obj.user_rate_limit_map = message.userRateLimitMap.map(e => e ? UserRateLimit.toAmino(e) : undefined);
+        }
+        else {
+            obj.user_rate_limit_map = message.userRateLimitMap;
+        }
+        if (message.userReactionLimitMap) {
+            obj.user_reaction_limit_map = message.userReactionLimitMap.map(e => e ? UserReactionLimit.toAmino(e) : undefined);
+        }
+        else {
+            obj.user_reaction_limit_map = message.userReactionLimitMap;
+        }
+        if (message.sentinelActivityMap) {
+            obj.sentinel_activity_map = message.sentinelActivityMap.map(e => e ? SentinelActivity.toAmino(e) : undefined);
+        }
+        else {
+            obj.sentinel_activity_map = message.sentinelActivityMap;
+        }
+        if (message.hideRecordMap) {
+            obj.hide_record_map = message.hideRecordMap.map(e => e ? HideRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.hide_record_map = message.hideRecordMap;
+        }
+        if (message.threadLockRecordMap) {
+            obj.thread_lock_record_map = message.threadLockRecordMap.map(e => e ? ThreadLockRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.thread_lock_record_map = message.threadLockRecordMap;
+        }
+        if (message.threadMoveRecordMap) {
+            obj.thread_move_record_map = message.threadMoveRecordMap.map(e => e ? ThreadMoveRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.thread_move_record_map = message.threadMoveRecordMap;
+        }
+        if (message.postFlagMap) {
+            obj.post_flag_map = message.postFlagMap.map(e => e ? PostFlag.toAmino(e) : undefined);
+        }
+        else {
+            obj.post_flag_map = message.postFlagMap;
+        }
+        if (message.bountyList) {
+            obj.bounty_list = message.bountyList.map(e => e ? Bounty.toAmino(e) : undefined);
+        }
+        else {
+            obj.bounty_list = message.bountyList;
+        }
+        obj.bounty_count = message.bountyCount !== BigInt(0) ? message.bountyCount?.toString() : undefined;
+        if (message.threadMetadataMap) {
+            obj.thread_metadata_map = message.threadMetadataMap.map(e => e ? ThreadMetadata.toAmino(e) : undefined);
+        }
+        else {
+            obj.thread_metadata_map = message.threadMetadataMap;
+        }
+        if (message.threadFollowMap) {
+            obj.thread_follow_map = message.threadFollowMap.map(e => e ? ThreadFollow.toAmino(e) : undefined);
+        }
+        else {
+            obj.thread_follow_map = message.threadFollowMap;
+        }
+        if (message.threadFollowCountMap) {
+            obj.thread_follow_count_map = message.threadFollowCountMap.map(e => e ? ThreadFollowCount.toAmino(e) : undefined);
+        }
+        else {
+            obj.thread_follow_count_map = message.threadFollowCountMap;
+        }
+        if (message.archiveMetadataMap) {
+            obj.archive_metadata_map = message.archiveMetadataMap.map(e => e ? ArchiveMetadata.toAmino(e) : undefined);
+        }
+        else {
+            obj.archive_metadata_map = message.archiveMetadataMap;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.GenesisState",
+            value: GenesisState.encode(message).finish()
+        };
+    }
+};