@massalabs/gossip-sdk 0.0.2-dev.20260313034537 → 0.0.2-dev.20260313145228

package/README.md

@@ -147,9 +147,15 @@ await sdk.messages.sendText(contactId, 'Hello!', {
 // Fetch new messages from server
 const fetchResult = await sdk.messages.fetch();
 
-// Get all messages for a given contact
+// Get all messages for a given contact (raw, protocol-level view)
 const messages = await sdk.messages.getMessages(contactId);
 
+// Get only user-visible messages for a contact
+// - Excludes KEEP_ALIVE protocol pings
+// - Excludes outgoing delete control messages (empty content)
+// - Ordered by ascending database id
+const visibleMessages = await sdk.messages.getVisibleMessages(contactId);
+
 // Mark a specific message (by DB ID) as read
 await sdk.messages.markAsRead(messageId);
 ```

package/dist/db/db.d.ts

@@ -39,6 +39,12 @@ export interface Message {
         originalContent?: string;
         originalContactId?: Uint8Array;
     };
+    deleteOf?: {
+        originalMsgId: Uint8Array;
+    };
+    editOf?: {
+        originalMsgId: Uint8Array;
+    };
 }
 export interface UserProfile {
     userId: string;
@@ -89,7 +95,8 @@ export declare enum MessageType {
     IMAGE = "image",
     FILE = "file",
     AUDIO = "audio",
-    VIDEO = "video"
+    VIDEO = "video",
+    DELETED = "deleted"
 }
 export interface ReadyAnnouncement {
     announcement_bytes: Uint8Array;

package/dist/db/db.js

@@ -36,6 +36,7 @@ export var MessageType;
     MessageType["FILE"] = "file";
     MessageType["AUDIO"] = "audio";
     MessageType["VIDEO"] = "video";
+    MessageType["DELETED"] = "deleted";
 })(MessageType || (MessageType = {}));
 /** Serialize a SendAnnouncement to a JSON string for SQLite text column */
 export function serializeSendAnnouncement(announcement) {

package/dist/db/generated-migrations.js

@@ -14,7 +14,7 @@ export const MIGRATIONS = [
             'CREATE INDEX `contacts_owner_name_idx` ON `contacts` (`ownerUserId`,`name`);',
             'CREATE TABLE `discussions` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`weAccepted` integer DEFAULT false NOT NULL,\n\t`sendAnnouncement` text,\n\t`direction` text NOT NULL,\n\t`nextSeeker` blob,\n\t`initiationAnnouncement` blob,\n\t`announcementMessage` text,\n\t`lastSyncTimestamp` integer,\n\t`customName` text,\n\t`lastMessageId` integer,\n\t`lastMessageContent` text,\n\t`lastMessageTimestamp` integer,\n\t`unreadCount` integer DEFAULT 0 NOT NULL,\n\t`killedNextRetryAt` integer,\n\t`saturatedRetryAt` integer,\n\t`saturatedRetryDone` integer DEFAULT 0 NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL\n);',
             'CREATE UNIQUE INDEX `discussions_owner_contact_idx` ON `discussions` (`ownerUserId`,`contactUserId`);',
-            'CREATE TABLE `messages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`messageId` blob,\n\t`content` text NOT NULL,\n\t`serializedContent` blob,\n\t`type` text NOT NULL,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`timestamp` integer NOT NULL,\n\t`metadata` text,\n\t`seeker` blob,\n\t`replyTo` text,\n\t`forwardOf` text,\n\t`encryptedMessage` blob,\n\t`whenToSend` integer\n);',
+            'CREATE TABLE `messages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`messageId` blob,\n\t`content` text NOT NULL,\n\t`serializedContent` blob,\n\t`type` text NOT NULL,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`timestamp` integer NOT NULL,\n\t`metadata` text,\n\t`seeker` blob,\n\t`replyTo` text,\n\t`forwardOf` text,\n\t`deleteOf` text,\n\t`encryptedMessage` blob,\n\t`whenToSend` integer\n);',
             'CREATE INDEX `messages_owner_contact_idx` ON `messages` (`ownerUserId`,`contactUserId`);',
             'CREATE INDEX `messages_owner_status_idx` ON `messages` (`ownerUserId`,`status`);',
             'CREATE INDEX `messages_owner_contact_status_idx` ON `messages` (`ownerUserId`,`contactUserId`,`status`);',
@@ -34,4 +34,10 @@ export const MIGRATIONS = [
             'CREATE INDEX `userProfile_status_idx` ON `userProfile` (`status`);',
         ],
     },
+    {
+        idx: 1,
+        tag: '0001_messages_edit_of',
+        when: 1740000000000,
+        statements: ['ALTER TABLE `messages` ADD COLUMN `editOf` text;'],
+    },
 ];

package/dist/db/queries/messages.d.ts

@@ -8,6 +8,7 @@ export declare class MessageQueries {
     constructor(conn: DatabaseConnection);
     getById(id: number): Promise<MessageRow | undefined>;
     getByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
+    getVisibleByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
     getByOwnerAndSeeker(ownerUserId: string, seeker: Uint8Array): Promise<MessageRow | undefined>;
     findByMessageId(ownerUserId: string, contactUserId: string, messageId: Uint8Array): Promise<MessageRow | undefined>;
     insert(values: MessageInsert): Promise<number>;

package/dist/db/queries/messages.js

@@ -1,4 +1,4 @@
-import { eq, and, sql, inArray, asc } from 'drizzle-orm';
+import { eq, and, or, sql, inArray, asc, ne } from 'drizzle-orm';
 import * as schema from '../schema/index.js';
 import { MessageDirection, MessageStatus, MessageType } from '../../db/db.js';
 export class MessageQueries {
@@ -25,6 +25,20 @@ export class MessageQueries {
             .orderBy(asc(schema.messages.timestamp), asc(schema.messages.id))
             .all();
     }
+    async getVisibleByOwnerAndContact(ownerUserId, contactUserId) {
+        return this.conn.db
+            .select()
+            .from(schema.messages)
+            .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), 
+        // Hide keep-alive messages from UI
+        ne(schema.messages.type, MessageType.KEEP_ALIVE), 
+        // Hide delete control messages (outgoing DELETED with empty content)
+        or(ne(schema.messages.type, MessageType.DELETED), ne(schema.messages.direction, MessageDirection.OUTGOING), ne(schema.messages.content, '')), 
+        // Hide edit control messages tagged via metadata.control === 'edit'
+        sql `(metadata IS NULL OR metadata NOT LIKE '%"control":"edit"%')`))
+            .orderBy(asc(schema.messages.id))
+            .all();
+    }
     async getByOwnerAndSeeker(ownerUserId, seeker) {
         return this.conn.db
             .select()
@@ -98,7 +112,6 @@ export class MessageQueries {
             .all();
     }
     async resetSendQueue(ownerUserId, contactUserId) {
-        const statuses = [MessageStatus.READY, MessageStatus.SENT];
         await this.conn.db
             .update(schema.messages)
             .set({
@@ -106,7 +119,10 @@ export class MessageQueries {
             encryptedMessage: null,
             seeker: null,
         })
-            .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.OUTGOING), statuses ? inArray(schema.messages.status, statuses) : undefined));
+            .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.OUTGOING), inArray(schema.messages.status, [
+            MessageStatus.READY,
+            MessageStatus.SENT,
+        ])));
         const waitingSessionMessages = await this.conn.db
             .select()
             .from(schema.messages)

package/dist/db/schema/messages.d.ts

@@ -268,6 +268,44 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
         }, {}, {
             length: number | undefined;
         }>;
+        deleteOf: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "deleteOf";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        editOf: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "editOf";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         encryptedMessage: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "encryptedMessage";
             tableName: "messages";

package/dist/db/schema/messages.js

@@ -15,6 +15,8 @@ export const messages = sqliteTable('messages', {
     seeker: bytes('seeker'),
     replyTo: text('replyTo'),
     forwardOf: text('forwardOf'),
+    deleteOf: text('deleteOf'),
+    editOf: text('editOf'),
     encryptedMessage: bytes('encryptedMessage'),
     whenToSend: integer('whenToSend', { mode: 'timestamp_ms' }),
 }, table => [

package/dist/proto/generated/message.d.ts

@@ -2,7 +2,9 @@ export declare enum MessageType {
     MESSAGE_TYPE_REGULAR = 0,
     MESSAGE_TYPE_REPLY = 1,
     MESSAGE_TYPE_FORWARD = 2,
-    MESSAGE_TYPE_KEEP_ALIVE = 3
+    MESSAGE_TYPE_KEEP_ALIVE = 3,
+    MESSAGE_TYPE_DELETE = 4,
+    MESSAGE_TYPE_EDIT = 5
 }
 export interface Message {
     messageType?: MessageType;

package/dist/proto/generated/message.js

@@ -6,6 +6,8 @@ export var MessageType;
     MessageType[MessageType["MESSAGE_TYPE_REPLY"] = 1] = "MESSAGE_TYPE_REPLY";
     MessageType[MessageType["MESSAGE_TYPE_FORWARD"] = 2] = "MESSAGE_TYPE_FORWARD";
     MessageType[MessageType["MESSAGE_TYPE_KEEP_ALIVE"] = 3] = "MESSAGE_TYPE_KEEP_ALIVE";
+    MessageType[MessageType["MESSAGE_TYPE_DELETE"] = 4] = "MESSAGE_TYPE_DELETE";
+    MessageType[MessageType["MESSAGE_TYPE_EDIT"] = 5] = "MESSAGE_TYPE_EDIT";
 })(MessageType || (MessageType = {}));
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();

package/dist/services/message.d.ts

@@ -81,8 +81,12 @@ export declare class MessageService {
     getWaitingMessageCount(contactUserId: string): Promise<number>;
     /** Get a message by its database ID */
     get(id: number): Promise<Message | undefined>;
-    /** Get all messages for a contact (using session owner) */
+    /** Get all messages for a contact (using session owner).
+     *  NOTE: This returns raw rows without UI-level filtering.
+     */
     getMessages(contactUserId: string): Promise<Message[]>;
+    /** Get only user-visible messages for a contact (filtered + ordered). */
+    getVisibleMessages(contactUserId: string): Promise<Message[]>;
     /** Send a message, queued via QueueManager if available */
     send(message: Omit<Message, 'id'>): Promise<SendMessageResult>;
     /**
@@ -92,5 +96,17 @@ export declare class MessageService {
     sendText(contactUserId: string, text: string, options?: SendTextOptions): Promise<SendMessageResult>;
     /** Fetch and decrypt messages from the protocol (alias) */
     fetch(): Promise<MessageResult>;
+    /**
+     * Delete an outgoing message by its database ID.
+     * Marks the local message as deleted and enqueues a delete control message
+     * so the peer can mark their copy as deleted as well.
+     */
+    deleteMessage(id: number): Promise<boolean>;
+    /**
+     * Edit an outgoing message by its database ID.
+     * Updates the local content (preserving timestamp) and enqueues an edit
+     * control message so the peer can update their copy as well.
+     */
+    editMessage(id: number, newContent: string): Promise<boolean>;
     markAsRead(id: number): Promise<boolean>;
 }

package/dist/services/message.js

@@ -7,7 +7,7 @@
 import { MessageDirection, MessageStatus, MessageType, MESSAGE_ID_SIZE, } from '../db/index.js';
 import { decodeUserId, encodeUserId } from '../utils/userId.js';
 import { SessionStatus } from '../wasm/bindings.js';
-import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, deserializeMessage, } from '../utils/messageSerialization.js';
+import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, serializeDeleteMessage, serializeEditMessage, deserializeMessage, } from '../utils/messageSerialization.js';
 import { encodeToBase64, decodeFromBase64 } from '../utils/base64.js';
 import { sessionStatusToString } from '../wasm/session.js';
 import { Logger } from '../utils/logs.js';
@@ -57,6 +57,38 @@ function deserializeForwardOf(json) {
             : undefined,
     };
 }
+/** Serialize deleteOf to JSON string for SQLite storage. */
+function serializeDeleteOf(deleteOf) {
+    if (!deleteOf)
+        return null;
+    return JSON.stringify({
+        originalMsgId: encodeToBase64(deleteOf.originalMsgId),
+    });
+}
+/** Deserialize deleteOf from JSON string. */
+function deserializeDeleteOf(json) {
+    if (!json)
+        return undefined;
+    const parsed = JSON.parse(json);
+    return {
+        originalMsgId: decodeFromBase64(parsed.originalMsgId),
+    };
+}
+function serializeEditOf(editOf) {
+    if (!editOf)
+        return null;
+    return JSON.stringify({
+        originalMsgId: encodeToBase64(editOf.originalMsgId),
+    });
+}
+function deserializeEditOf(json) {
+    if (!json)
+        return undefined;
+    const parsed = JSON.parse(json);
+    return {
+        originalMsgId: decodeFromBase64(parsed.originalMsgId),
+    };
+}
 /** Serialize metadata to JSON string. */
 function serializeMetadata(metadata) {
     if (!metadata)
@@ -86,6 +118,8 @@ export function rowToMessage(row) {
         seeker: row.seeker ?? undefined,
         replyTo: deserializeReplyTo(row.replyTo),
         forwardOf: deserializeForwardOf(row.forwardOf),
+        deleteOf: deserializeDeleteOf(row.deleteOf ?? null),
+        editOf: deserializeEditOf(row.editOf ?? null),
         encryptedMessage: row.encryptedMessage ?? undefined,
         whenToSend: row.whenToSend ?? undefined,
     };
@@ -257,6 +291,8 @@ export class MessageService {
             seeker: message.seeker,
             replyTo: serializeReplyTo(message.replyTo),
             forwardOf: serializeForwardOf(message.forwardOf),
+            deleteOf: serializeDeleteOf(message.deleteOf),
+            editOf: serializeEditOf(message.editOf),
             encryptedMessage: message.encryptedMessage,
             whenToSend: message.whenToSend,
         });
@@ -290,6 +326,7 @@ export class MessageService {
                     if (deserialized.type === MessageType.KEEP_ALIVE) {
                         continue;
                     }
+                    // Delete control messages are handled at storage time; keep them in decrypted array
                     if (!deserialized.messageId ||
                         deserialized.messageId.length !== MESSAGE_ID_SIZE) {
                         log.warn('missing or invalid messageId, skipping message', {
@@ -306,6 +343,8 @@ export class MessageService {
                         type: deserialized.type,
                         replyTo: deserialized.replyTo,
                         forwardOf: deserialized.forwardOf,
+                        deleteOf: deserialized.deleteOf,
+                        editOf: deserialized.editOf,
                     });
                 }
                 catch (deserializationError) {
@@ -330,6 +369,43 @@ export class MessageService {
         const log = logger.forMethod('storeDecryptedMessages');
         const storedIds = [];
         for (const message of decrypted) {
+            // Handle delete control messages by updating the referenced message in-place
+            if (message.type === MessageType.DELETED &&
+                message.deleteOf?.originalMsgId) {
+                const target = await this.findMessageByMsgId(message.deleteOf.originalMsgId, ownerUserId, message.senderId);
+                if (!target || !target.id) {
+                    log.warn('delete target not found', {
+                        originalMsgId: encodeToBase64(message.deleteOf.originalMsgId),
+                    });
+                    continue;
+                }
+                await this.queries.messages.updateById(target.id, {
+                    content: '[Message deleted]',
+                    type: MessageType.DELETED,
+                });
+                // Do not insert a new message row for delete control messages
+                continue;
+            }
+            // Handle edit control messages by updating the referenced message in-place
+            if (message.editOf?.originalMsgId) {
+                const target = await this.findMessageByMsgId(message.editOf.originalMsgId, ownerUserId, message.senderId);
+                if (!target || !target.id) {
+                    log.warn('edit target not found', {
+                        originalMsgId: encodeToBase64(message.editOf.originalMsgId),
+                    });
+                    continue;
+                }
+                const mergedMetadata = {
+                    ...(target.metadata ?? {}),
+                    edited: true,
+                };
+                await this.queries.messages.updateById(target.id, {
+                    content: message.content,
+                    metadata: serializeMetadata(mergedMetadata),
+                });
+                // Do not insert a new message row for edit control messages
+                continue;
+            }
             const discussion = await this.queries.discussions.getByOwnerAndContact(ownerUserId, message.senderId);
             if (!discussion) {
                 log.error('no discussion for incoming message', {
@@ -513,6 +589,33 @@ export class MessageService {
                 data: serializeKeepAliveMessage(),
             };
         }
+        else if (message.type === MessageType.DELETED && message.deleteOf) {
+            // Serialize a delete control message targeting an existing messageId
+            const originalMsgId = message.deleteOf.originalMsgId;
+            if (!originalMsgId || originalMsgId.length !== MESSAGE_ID_SIZE) {
+                return {
+                    success: false,
+                    error: 'Original messageId is required for delete messages',
+                };
+            }
+            return {
+                success: true,
+                data: serializeDeleteMessage(originalMsgId, message.messageId),
+            };
+        }
+        else if (message.editOf) {
+            const originalMsgId = message.editOf.originalMsgId;
+            if (!originalMsgId || originalMsgId.length !== MESSAGE_ID_SIZE) {
+                return {
+                    success: false,
+                    error: 'Original messageId is required for edit messages',
+                };
+            }
+            return {
+                success: true,
+                data: serializeEditMessage(message.content, originalMsgId, message.messageId),
+            };
+        }
         else if (message.forwardOf) {
             try {
                 return {
@@ -781,11 +884,18 @@ export class MessageService {
         const row = await this.queries.messages.getById(id);
         return row ? rowToMessage(row) : undefined;
     }
-    /** Get all messages for a contact (using session owner) */
+    /** Get all messages for a contact (using session owner).
+     *  NOTE: This returns raw rows without UI-level filtering.
+     */
     async getMessages(contactUserId) {
         const rows = await this.queries.messages.getByOwnerAndContact(this.session.userIdEncoded, contactUserId);
         return rows.map(rowToMessage);
     }
+    /** Get only user-visible messages for a contact (filtered + ordered). */
+    async getVisibleMessages(contactUserId) {
+        const rows = await this.queries.messages.getVisibleByOwnerAndContact(this.session.userIdEncoded, contactUserId);
+        return rows.map(rowToMessage);
+    }
     /** Send a message, queued via QueueManager if available */
     async send(message) {
         if (this.queueManager) {
@@ -817,6 +927,101 @@ export class MessageService {
     async fetch() {
         return this.fetchMessages();
     }
+    /**
+     * Delete an outgoing message by its database ID.
+     * Marks the local message as deleted and enqueues a delete control message
+     * so the peer can mark their copy as deleted as well.
+     */
+    async deleteMessage(id) {
+        const row = await this.queries.messages.getById(id);
+        if (!row) {
+            return false;
+        }
+        // Only allow deleting our own outgoing messages
+        if (row.direction !== MessageDirection.OUTGOING) {
+            return false;
+        }
+        if (!row.messageId) {
+            throw new Error('Cannot delete a message that has no messageId');
+        }
+        const ownerUserId = this.session.userIdEncoded;
+        // Mark the original message as deleted locally
+        await this.queries.messages.updateById(id, {
+            content: '[Message deleted]',
+            type: MessageType.DELETED,
+        });
+        // Enqueue a delete control message to notify the peer
+        const controlMessage = {
+            ownerUserId,
+            contactUserId: row.contactUserId,
+            content: '',
+            type: MessageType.DELETED,
+            direction: MessageDirection.OUTGOING,
+            status: MessageStatus.WAITING_SESSION,
+            timestamp: new Date(),
+            deleteOf: {
+                originalMsgId: row.messageId,
+            },
+        };
+        const result = await this.send(controlMessage);
+        if (!result.success) {
+            throw new Error(result.error ?? 'Failed to enqueue delete message');
+        }
+        await this.refreshService?.stateUpdate();
+        return true;
+    }
+    /**
+     * Edit an outgoing message by its database ID.
+     * Updates the local content (preserving timestamp) and enqueues an edit
+     * control message so the peer can update their copy as well.
+     */
+    async editMessage(id, newContent) {
+        const row = await this.queries.messages.getById(id);
+        if (!row) {
+            return false;
+        }
+        // Only allow editing our own outgoing messages
+        if (row.direction !== MessageDirection.OUTGOING) {
+            return false;
+        }
+        if (!row.messageId || row.messageId.length !== MESSAGE_ID_SIZE) {
+            throw new Error('Cannot edit a message that has no valid messageId');
+        }
+        const ownerUserId = this.session.userIdEncoded;
+        // Merge existing metadata with edited flag
+        const existingMetadata = deserializeMetadata(row.metadata) ?? {};
+        const mergedMetadata = {
+            ...existingMetadata,
+            edited: true,
+        };
+        // Update the original message content locally, preserving timestamp
+        await this.queries.messages.updateById(id, {
+            content: newContent,
+            metadata: serializeMetadata(mergedMetadata),
+        });
+        // Enqueue an edit control message to notify the peer
+        const controlMessage = {
+            ownerUserId,
+            contactUserId: row.contactUserId,
+            content: newContent,
+            type: MessageType.TEXT,
+            direction: MessageDirection.OUTGOING,
+            status: MessageStatus.WAITING_SESSION,
+            timestamp: new Date(),
+            editOf: {
+                originalMsgId: row.messageId,
+            },
+            metadata: {
+                control: 'edit',
+            },
+        };
+        const result = await this.send(controlMessage);
+        if (!result.success) {
+            throw new Error(result.error ?? 'Failed to enqueue edit message');
+        }
+        await this.refreshService?.stateUpdate();
+        return true;
+    }
     // Mark a message as read. Returns true if the message has been marked as read, false if it was already marked as read or doesn't exist.
     async markAsRead(id) {
         // Check current message status from DB to avoid race conditions

package/dist/utils/messageSerialization.d.ts

@@ -7,6 +7,8 @@
 import { MessageType } from '../db/index.js';
 import { MessageType as ProtoMessageType } from '../proto/generated/message.js';
 export declare const MESSAGE_TYPE_KEEP_ALIVE = ProtoMessageType.MESSAGE_TYPE_KEEP_ALIVE;
+export declare const MESSAGE_TYPE_DELETE = ProtoMessageType.MESSAGE_TYPE_DELETE;
+export declare const MESSAGE_TYPE_EDIT = ProtoMessageType.MESSAGE_TYPE_EDIT;
 export interface DeserializedMessage {
     content: string;
     messageId?: Uint8Array;
@@ -17,6 +19,12 @@ export interface DeserializedMessage {
         originalContent: string;
         originalContactId?: Uint8Array;
     };
+    deleteOf?: {
+        originalMsgId: Uint8Array;
+    };
+    editOf?: {
+        originalMsgId: Uint8Array;
+    };
     type: MessageType;
 }
 /**
@@ -57,6 +65,28 @@ export declare function serializeReplyMessage(newContent: string, originalMsgId:
  * @returns Serialized forward message bytes
  */
 export declare function serializeForwardMessage(forwardedContent: string, newContent: string, messageId: Uint8Array, originalContactId?: Uint8Array): Uint8Array;
+/**
+ * Serialize a delete control message
+ *
+ * Format: protobuf Message with citedMsgId set and delete type
+ *
+ * @param originalMsgId - The messageId of the message being deleted
+ * @param messageId - 12-byte random message ID for the control message
+ * @returns Serialized delete message bytes
+ */
+export declare function serializeDeleteMessage(originalMsgId: Uint8Array, messageId: Uint8Array): Uint8Array;
+/**
+ * Serialize an edit control message
+ *
+ * Format: protobuf Message with citedMsgId set to the original messageId and
+ * content carrying the new text.
+ *
+ * @param newContent - The updated message content
+ * @param originalMsgId - The messageId of the message being edited
+ * @param messageId - 12-byte random message ID for the control message
+ * @returns Serialized edit message bytes
+ */
+export declare function serializeEditMessage(newContent: string, originalMsgId: Uint8Array, messageId: Uint8Array): Uint8Array;
 /**
  * Deserialize a message from bytes
  *

package/dist/utils/messageSerialization.js

@@ -7,6 +7,8 @@
 import { MessageType, MESSAGE_ID_SIZE } from '../db/index.js';
 import { Message as ProtoMessage, MessageType as ProtoMessageType, } from '../proto/generated/message.js';
 export const MESSAGE_TYPE_KEEP_ALIVE = ProtoMessageType.MESSAGE_TYPE_KEEP_ALIVE;
+export const MESSAGE_TYPE_DELETE = ProtoMessageType.MESSAGE_TYPE_DELETE;
+export const MESSAGE_TYPE_EDIT = ProtoMessageType.MESSAGE_TYPE_EDIT;
 /**
  * Serialize a keep-alive message
  * Keep-alive messages are used to maintain session activity
@@ -86,6 +88,54 @@ export function serializeForwardMessage(forwardedContent, newContent, messageId,
         forwardedContent,
     });
 }
+/**
+ * Serialize a delete control message
+ *
+ * Format: protobuf Message with citedMsgId set and delete type
+ *
+ * @param originalMsgId - The messageId of the message being deleted
+ * @param messageId - 12-byte random message ID for the control message
+ * @returns Serialized delete message bytes
+ */
+export function serializeDeleteMessage(originalMsgId, messageId) {
+    if (messageId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`messageId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    if (originalMsgId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`originalMsgId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_DELETE,
+        messageId,
+        content: '',
+        citedMsgId: originalMsgId,
+    });
+}
+/**
+ * Serialize an edit control message
+ *
+ * Format: protobuf Message with citedMsgId set to the original messageId and
+ * content carrying the new text.
+ *
+ * @param newContent - The updated message content
+ * @param originalMsgId - The messageId of the message being edited
+ * @param messageId - 12-byte random message ID for the control message
+ * @returns Serialized edit message bytes
+ */
+export function serializeEditMessage(newContent, originalMsgId, messageId) {
+    if (messageId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`messageId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    if (originalMsgId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`originalMsgId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_EDIT,
+        messageId,
+        content: newContent,
+        citedMsgId: originalMsgId,
+    });
+}
 /**
  * Deserialize a message from bytes
  *
@@ -109,6 +159,8 @@ export function deserializeMessage(buffer) {
     const messageId = decoded.messageId;
     const citedMsgId = decoded.citedMsgId;
     let replyTo = undefined;
+    let deleteOf = undefined;
+    let editOf = undefined;
     if (protoType === ProtoMessageType.MESSAGE_TYPE_REPLY) {
         if (citedMsgId && citedMsgId.length === MESSAGE_ID_SIZE) {
             replyTo = {
@@ -119,6 +171,26 @@ export function deserializeMessage(buffer) {
             throw new Error(`invalid message format: message of type reply but citedMsgId empty or not correct size (${MESSAGE_ID_SIZE})`);
         }
     }
+    if (protoType === ProtoMessageType.MESSAGE_TYPE_DELETE) {
+        if (citedMsgId && citedMsgId.length === MESSAGE_ID_SIZE) {
+            deleteOf = {
+                originalMsgId: citedMsgId,
+            };
+        }
+        else {
+            throw new Error(`invalid message format: message of type delete but citedMsgId empty or not correct size (${MESSAGE_ID_SIZE})`);
+        }
+    }
+    if (protoType === ProtoMessageType.MESSAGE_TYPE_EDIT) {
+        if (citedMsgId && citedMsgId.length === MESSAGE_ID_SIZE) {
+            editOf = {
+                originalMsgId: citedMsgId,
+            };
+        }
+        else {
+            throw new Error(`invalid message format: message of type edit but citedMsgId empty or not correct size (${MESSAGE_ID_SIZE})`);
+        }
+    }
     let forwardOf = undefined;
     if (protoType === ProtoMessageType.MESSAGE_TYPE_FORWARD) {
         if (decoded.forwardedContent &&
@@ -138,6 +210,10 @@ export function deserializeMessage(buffer) {
         messageId,
         replyTo,
         forwardOf,
-        type: MessageType.TEXT,
+        deleteOf,
+        editOf,
+        type: protoType === ProtoMessageType.MESSAGE_TYPE_DELETE
+            ? MessageType.DELETED
+            : MessageType.TEXT,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.2-dev.20260313034537",
+  "version": "0.0.2-dev.20260313145228",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",