@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

package/esm/sparkdream/common/v1/content_type.js

@@ -0,0 +1,96 @@
+//@ts-nocheck
+/**
+ * ContentType tells the frontend how to interpret post content.
+ * On-chain text types (0-9) are human-readable strings.
+ * On-chain compressed types (10-19) are base64-encoded binary strings.
+ * Off-chain reference types (20+) are URI/hash strings.
+ */
+export var ContentType;
+(function (ContentType) {
+    ContentType[ContentType["CONTENT_TYPE_UNSPECIFIED"] = 0] = "CONTENT_TYPE_UNSPECIFIED";
+    /** CONTENT_TYPE_TEXT - On-chain text formats (human-readable strings) */
+    ContentType[ContentType["CONTENT_TYPE_TEXT"] = 1] = "CONTENT_TYPE_TEXT";
+    /** CONTENT_TYPE_HTML - HTML content */
+    ContentType[ContentType["CONTENT_TYPE_HTML"] = 2] = "CONTENT_TYPE_HTML";
+    /** CONTENT_TYPE_MARKDOWN - Markdown content */
+    ContentType[ContentType["CONTENT_TYPE_MARKDOWN"] = 3] = "CONTENT_TYPE_MARKDOWN";
+    /** CONTENT_TYPE_GZIP - On-chain compressed formats (base64-encoded strings) */
+    ContentType[ContentType["CONTENT_TYPE_GZIP"] = 10] = "CONTENT_TYPE_GZIP";
+    /** CONTENT_TYPE_ZSTD - Zstandard-compressed (frontend decompresses) */
+    ContentType[ContentType["CONTENT_TYPE_ZSTD"] = 11] = "CONTENT_TYPE_ZSTD";
+    /** CONTENT_TYPE_IPFS - Off-chain references (hash/CID strings) */
+    ContentType[ContentType["CONTENT_TYPE_IPFS"] = 20] = "CONTENT_TYPE_IPFS";
+    /** CONTENT_TYPE_ARWEAVE - Arweave TX ID (frontend fetches from Arweave gateway) */
+    ContentType[ContentType["CONTENT_TYPE_ARWEAVE"] = 21] = "CONTENT_TYPE_ARWEAVE";
+    /** CONTENT_TYPE_FILECOIN - Filecoin CID (frontend fetches from Filecoin gateway) */
+    ContentType[ContentType["CONTENT_TYPE_FILECOIN"] = 22] = "CONTENT_TYPE_FILECOIN";
+    /** CONTENT_TYPE_JACKAL - Jackal FID (frontend fetches from Jackal gateway) */
+    ContentType[ContentType["CONTENT_TYPE_JACKAL"] = 23] = "CONTENT_TYPE_JACKAL";
+    ContentType[ContentType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ContentType || (ContentType = {}));
+export const ContentTypeAmino = ContentType;
+export function contentTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "CONTENT_TYPE_UNSPECIFIED":
+            return ContentType.CONTENT_TYPE_UNSPECIFIED;
+        case 1:
+        case "CONTENT_TYPE_TEXT":
+            return ContentType.CONTENT_TYPE_TEXT;
+        case 2:
+        case "CONTENT_TYPE_HTML":
+            return ContentType.CONTENT_TYPE_HTML;
+        case 3:
+        case "CONTENT_TYPE_MARKDOWN":
+            return ContentType.CONTENT_TYPE_MARKDOWN;
+        case 10:
+        case "CONTENT_TYPE_GZIP":
+            return ContentType.CONTENT_TYPE_GZIP;
+        case 11:
+        case "CONTENT_TYPE_ZSTD":
+            return ContentType.CONTENT_TYPE_ZSTD;
+        case 20:
+        case "CONTENT_TYPE_IPFS":
+            return ContentType.CONTENT_TYPE_IPFS;
+        case 21:
+        case "CONTENT_TYPE_ARWEAVE":
+            return ContentType.CONTENT_TYPE_ARWEAVE;
+        case 22:
+        case "CONTENT_TYPE_FILECOIN":
+            return ContentType.CONTENT_TYPE_FILECOIN;
+        case 23:
+        case "CONTENT_TYPE_JACKAL":
+            return ContentType.CONTENT_TYPE_JACKAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ContentType.UNRECOGNIZED;
+    }
+}
+export function contentTypeToJSON(object) {
+    switch (object) {
+        case ContentType.CONTENT_TYPE_UNSPECIFIED:
+            return "CONTENT_TYPE_UNSPECIFIED";
+        case ContentType.CONTENT_TYPE_TEXT:
+            return "CONTENT_TYPE_TEXT";
+        case ContentType.CONTENT_TYPE_HTML:
+            return "CONTENT_TYPE_HTML";
+        case ContentType.CONTENT_TYPE_MARKDOWN:
+            return "CONTENT_TYPE_MARKDOWN";
+        case ContentType.CONTENT_TYPE_GZIP:
+            return "CONTENT_TYPE_GZIP";
+        case ContentType.CONTENT_TYPE_ZSTD:
+            return "CONTENT_TYPE_ZSTD";
+        case ContentType.CONTENT_TYPE_IPFS:
+            return "CONTENT_TYPE_IPFS";
+        case ContentType.CONTENT_TYPE_ARWEAVE:
+            return "CONTENT_TYPE_ARWEAVE";
+        case ContentType.CONTENT_TYPE_FILECOIN:
+            return "CONTENT_TYPE_FILECOIN";
+        case ContentType.CONTENT_TYPE_JACKAL:
+            return "CONTENT_TYPE_JACKAL";
+        case ContentType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/esm/sparkdream/common/v1/flag_record.js

@@ -0,0 +1,119 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseFlagRecord() {
+    return {
+        flagger: "",
+        reason: 0,
+        reasonText: "",
+        flaggedAt: BigInt(0),
+        weight: ""
+    };
+}
+/**
+ * FlagRecord records a single member's flag on a piece of content.
+ * Shared across modules (x/forum, x/collect) for consistent moderation records.
+ * @name FlagRecord
+ * @package sparkdream.common.v1
+ * @see proto type: sparkdream.common.v1.FlagRecord
+ */
+export const FlagRecord = {
+    typeUrl: "/sparkdream.common.v1.FlagRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.flagger !== "") {
+            writer.uint32(10).string(message.flagger);
+        }
+        if (message.reason !== 0) {
+            writer.uint32(16).int32(message.reason);
+        }
+        if (message.reasonText !== "") {
+            writer.uint32(26).string(message.reasonText);
+        }
+        if (message.flaggedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.flaggedAt);
+        }
+        if (message.weight !== "") {
+            writer.uint32(42).string(message.weight);
+        }
+        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 = createBaseFlagRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.flagger = reader.string();
+                    break;
+                case 2:
+                    message.reason = reader.int32();
+                    break;
+                case 3:
+                    message.reasonText = reader.string();
+                    break;
+                case 4:
+                    message.flaggedAt = reader.int64();
+                    break;
+                case 5:
+                    message.weight = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseFlagRecord();
+        message.flagger = object.flagger ?? "";
+        message.reason = object.reason ?? 0;
+        message.reasonText = object.reasonText ?? "";
+        message.flaggedAt = object.flaggedAt !== undefined && object.flaggedAt !== null ? BigInt(object.flaggedAt.toString()) : BigInt(0);
+        message.weight = object.weight ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseFlagRecord();
+        if (object.flagger !== undefined && object.flagger !== null) {
+            message.flagger = object.flagger;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        if (object.reason_text !== undefined && object.reason_text !== null) {
+            message.reasonText = object.reason_text;
+        }
+        if (object.flagged_at !== undefined && object.flagged_at !== null) {
+            message.flaggedAt = BigInt(object.flagged_at);
+        }
+        if (object.weight !== undefined && object.weight !== null) {
+            message.weight = object.weight;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.flagger = message.flagger === "" ? undefined : message.flagger;
+        obj.reason = message.reason === 0 ? undefined : message.reason;
+        obj.reason_text = message.reasonText === "" ? undefined : message.reasonText;
+        obj.flagged_at = message.flaggedAt !== BigInt(0) ? message.flaggedAt?.toString() : undefined;
+        obj.weight = message.weight === "" ? undefined : message.weight;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return FlagRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return FlagRecord.decode(message.value);
+    },
+    toProto(message) {
+        return FlagRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.common.v1.FlagRecord",
+            value: FlagRecord.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/common/v1/moderation_reason.js

@@ -0,0 +1,115 @@
+//@ts-nocheck
+/**
+ * ModerationReason defines the reason for flagging or hiding content.
+ * Shared across modules (x/forum, x/collect) for consistent moderation vocabulary.
+ */
+export var ModerationReason;
+(function (ModerationReason) {
+    ModerationReason[ModerationReason["MODERATION_REASON_UNSPECIFIED"] = 0] = "MODERATION_REASON_UNSPECIFIED";
+    /** MODERATION_REASON_SPAM - Unsolicited commercial content, repetitive posts */
+    ModerationReason[ModerationReason["MODERATION_REASON_SPAM"] = 1] = "MODERATION_REASON_SPAM";
+    /** MODERATION_REASON_HARASSMENT - Personal attacks, bullying, threats */
+    ModerationReason[ModerationReason["MODERATION_REASON_HARASSMENT"] = 2] = "MODERATION_REASON_HARASSMENT";
+    /** MODERATION_REASON_MISINFORMATION - False claims, misleading content */
+    ModerationReason[ModerationReason["MODERATION_REASON_MISINFORMATION"] = 3] = "MODERATION_REASON_MISINFORMATION";
+    /** MODERATION_REASON_OFF_TOPIC - Content unrelated to category/thread */
+    ModerationReason[ModerationReason["MODERATION_REASON_OFF_TOPIC"] = 4] = "MODERATION_REASON_OFF_TOPIC";
+    /** MODERATION_REASON_LOW_QUALITY - Low-effort posts, unclear content */
+    ModerationReason[ModerationReason["MODERATION_REASON_LOW_QUALITY"] = 5] = "MODERATION_REASON_LOW_QUALITY";
+    /** MODERATION_REASON_INAPPROPRIATE - Adult content, graphic material */
+    ModerationReason[ModerationReason["MODERATION_REASON_INAPPROPRIATE"] = 6] = "MODERATION_REASON_INAPPROPRIATE";
+    /** MODERATION_REASON_IMPERSONATION - Pretending to be someone else */
+    ModerationReason[ModerationReason["MODERATION_REASON_IMPERSONATION"] = 7] = "MODERATION_REASON_IMPERSONATION";
+    /** MODERATION_REASON_POLICY_VIOLATION - Violates community guidelines */
+    ModerationReason[ModerationReason["MODERATION_REASON_POLICY_VIOLATION"] = 8] = "MODERATION_REASON_POLICY_VIOLATION";
+    /** MODERATION_REASON_DUPLICATE - Duplicate/cross-posted content */
+    ModerationReason[ModerationReason["MODERATION_REASON_DUPLICATE"] = 9] = "MODERATION_REASON_DUPLICATE";
+    /** MODERATION_REASON_SCAM - Fraudulent content, phishing attempts */
+    ModerationReason[ModerationReason["MODERATION_REASON_SCAM"] = 10] = "MODERATION_REASON_SCAM";
+    /** MODERATION_REASON_COPYRIGHT - Copyright infringement */
+    ModerationReason[ModerationReason["MODERATION_REASON_COPYRIGHT"] = 11] = "MODERATION_REASON_COPYRIGHT";
+    /** MODERATION_REASON_OTHER - Requires custom reason field */
+    ModerationReason[ModerationReason["MODERATION_REASON_OTHER"] = 12] = "MODERATION_REASON_OTHER";
+    ModerationReason[ModerationReason["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ModerationReason || (ModerationReason = {}));
+export const ModerationReasonAmino = ModerationReason;
+export function moderationReasonFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "MODERATION_REASON_UNSPECIFIED":
+            return ModerationReason.MODERATION_REASON_UNSPECIFIED;
+        case 1:
+        case "MODERATION_REASON_SPAM":
+            return ModerationReason.MODERATION_REASON_SPAM;
+        case 2:
+        case "MODERATION_REASON_HARASSMENT":
+            return ModerationReason.MODERATION_REASON_HARASSMENT;
+        case 3:
+        case "MODERATION_REASON_MISINFORMATION":
+            return ModerationReason.MODERATION_REASON_MISINFORMATION;
+        case 4:
+        case "MODERATION_REASON_OFF_TOPIC":
+            return ModerationReason.MODERATION_REASON_OFF_TOPIC;
+        case 5:
+        case "MODERATION_REASON_LOW_QUALITY":
+            return ModerationReason.MODERATION_REASON_LOW_QUALITY;
+        case 6:
+        case "MODERATION_REASON_INAPPROPRIATE":
+            return ModerationReason.MODERATION_REASON_INAPPROPRIATE;
+        case 7:
+        case "MODERATION_REASON_IMPERSONATION":
+            return ModerationReason.MODERATION_REASON_IMPERSONATION;
+        case 8:
+        case "MODERATION_REASON_POLICY_VIOLATION":
+            return ModerationReason.MODERATION_REASON_POLICY_VIOLATION;
+        case 9:
+        case "MODERATION_REASON_DUPLICATE":
+            return ModerationReason.MODERATION_REASON_DUPLICATE;
+        case 10:
+        case "MODERATION_REASON_SCAM":
+            return ModerationReason.MODERATION_REASON_SCAM;
+        case 11:
+        case "MODERATION_REASON_COPYRIGHT":
+            return ModerationReason.MODERATION_REASON_COPYRIGHT;
+        case 12:
+        case "MODERATION_REASON_OTHER":
+            return ModerationReason.MODERATION_REASON_OTHER;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ModerationReason.UNRECOGNIZED;
+    }
+}
+export function moderationReasonToJSON(object) {
+    switch (object) {
+        case ModerationReason.MODERATION_REASON_UNSPECIFIED:
+            return "MODERATION_REASON_UNSPECIFIED";
+        case ModerationReason.MODERATION_REASON_SPAM:
+            return "MODERATION_REASON_SPAM";
+        case ModerationReason.MODERATION_REASON_HARASSMENT:
+            return "MODERATION_REASON_HARASSMENT";
+        case ModerationReason.MODERATION_REASON_MISINFORMATION:
+            return "MODERATION_REASON_MISINFORMATION";
+        case ModerationReason.MODERATION_REASON_OFF_TOPIC:
+            return "MODERATION_REASON_OFF_TOPIC";
+        case ModerationReason.MODERATION_REASON_LOW_QUALITY:
+            return "MODERATION_REASON_LOW_QUALITY";
+        case ModerationReason.MODERATION_REASON_INAPPROPRIATE:
+            return "MODERATION_REASON_INAPPROPRIATE";
+        case ModerationReason.MODERATION_REASON_IMPERSONATION:
+            return "MODERATION_REASON_IMPERSONATION";
+        case ModerationReason.MODERATION_REASON_POLICY_VIOLATION:
+            return "MODERATION_REASON_POLICY_VIOLATION";
+        case ModerationReason.MODERATION_REASON_DUPLICATE:
+            return "MODERATION_REASON_DUPLICATE";
+        case ModerationReason.MODERATION_REASON_SCAM:
+            return "MODERATION_REASON_SCAM";
+        case ModerationReason.MODERATION_REASON_COPYRIGHT:
+            return "MODERATION_REASON_COPYRIGHT";
+        case ModerationReason.MODERATION_REASON_OTHER:
+            return "MODERATION_REASON_OTHER";
+        case ModerationReason.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/esm/sparkdream/commons/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.commons.module.v1
+ * @see proto type: sparkdream.commons.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.commons.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.commons.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/commons/v1/category.js

@@ -0,0 +1,121 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseCategory() {
+    return {
+        categoryId: BigInt(0),
+        title: "",
+        description: "",
+        membersOnlyWrite: false,
+        adminOnlyWrite: false
+    };
+}
+/**
+ * Category defines a governance-curated content category. Created by the
+ * Commons Council (or Operations Committee). Per-module restrictions on
+ * which categories are valid are enforced by the consuming module.
+ * @name Category
+ * @package sparkdream.commons.v1
+ * @see proto type: sparkdream.commons.v1.Category
+ */
+export const Category = {
+    typeUrl: "/sparkdream.commons.v1.Category",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.categoryId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.categoryId);
+        }
+        if (message.title !== "") {
+            writer.uint32(18).string(message.title);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        if (message.membersOnlyWrite === true) {
+            writer.uint32(32).bool(message.membersOnlyWrite);
+        }
+        if (message.adminOnlyWrite === true) {
+            writer.uint32(40).bool(message.adminOnlyWrite);
+        }
+        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 = createBaseCategory();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.categoryId = reader.uint64();
+                    break;
+                case 2:
+                    message.title = reader.string();
+                    break;
+                case 3:
+                    message.description = reader.string();
+                    break;
+                case 4:
+                    message.membersOnlyWrite = reader.bool();
+                    break;
+                case 5:
+                    message.adminOnlyWrite = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCategory();
+        message.categoryId = object.categoryId !== undefined && object.categoryId !== null ? BigInt(object.categoryId.toString()) : BigInt(0);
+        message.title = object.title ?? "";
+        message.description = object.description ?? "";
+        message.membersOnlyWrite = object.membersOnlyWrite ?? false;
+        message.adminOnlyWrite = object.adminOnlyWrite ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCategory();
+        if (object.category_id !== undefined && object.category_id !== null) {
+            message.categoryId = BigInt(object.category_id);
+        }
+        if (object.title !== undefined && object.title !== null) {
+            message.title = object.title;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.members_only_write !== undefined && object.members_only_write !== null) {
+            message.membersOnlyWrite = object.members_only_write;
+        }
+        if (object.admin_only_write !== undefined && object.admin_only_write !== null) {
+            message.adminOnlyWrite = object.admin_only_write;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.category_id = message.categoryId !== BigInt(0) ? message.categoryId?.toString() : undefined;
+        obj.title = message.title === "" ? undefined : message.title;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.members_only_write = message.membersOnlyWrite === false ? undefined : message.membersOnlyWrite;
+        obj.admin_only_write = message.adminOnlyWrite === false ? undefined : message.adminOnlyWrite;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Category.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Category.decode(message.value);
+    },
+    toProto(message) {
+        return Category.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.commons.v1.Category",
+            value: Category.encode(message).finish()
+        };
+    }
+};