@massalabs/gossip-sdk 0.0.2-dev.20260323092903 → 0.0.2-dev.20260324105033

package/dist/core/SdkEventEmitter.d.ts

@@ -16,6 +16,7 @@ export declare enum SdkEventType {
     SESSION_ACCEPTED = "sessionAccepted",
     SEEKERS_UPDATED = "seekersUpdated",
     SESSION_STATUS_CHANGED = "sessionStatusChanged",
+    DISCUSSION_UPDATED = "discussionUpdated",
     ERROR = "error"
 }
 export interface SdkEventHandlers {
@@ -29,6 +30,7 @@ export interface SdkEventHandlers {
     [SdkEventType.SESSION_ACCEPTED]: (contactUserId: string) => void;
     [SdkEventType.SEEKERS_UPDATED]: (seekers: Uint8Array[]) => void;
     [SdkEventType.SESSION_STATUS_CHANGED]: (contactUserId: string, status: SessionStatus) => void;
+    [SdkEventType.DISCUSSION_UPDATED]: (contactUserId: string) => void;
     [SdkEventType.ERROR]: (error: Error, context: string) => void;
 }
 export declare class SdkEventEmitter {

package/dist/core/SdkEventEmitter.js

@@ -18,6 +18,7 @@ export var SdkEventType;
     SdkEventType["SESSION_ACCEPTED"] = "sessionAccepted";
     SdkEventType["SEEKERS_UPDATED"] = "seekersUpdated";
     SdkEventType["SESSION_STATUS_CHANGED"] = "sessionStatusChanged";
+    SdkEventType["DISCUSSION_UPDATED"] = "discussionUpdated";
     SdkEventType["ERROR"] = "error";
 })(SdkEventType || (SdkEventType = {}));
 // ─────────────────────────────────────────────────────────────────────────────
@@ -40,6 +41,7 @@ export class SdkEventEmitter {
                 [SdkEventType.SESSION_ACCEPTED]: new Set(),
                 [SdkEventType.SEEKERS_UPDATED]: new Set(),
                 [SdkEventType.SESSION_STATUS_CHANGED]: new Set(),
+                [SdkEventType.DISCUSSION_UPDATED]: new Set(),
                 [SdkEventType.ERROR]: new Set(),
             }
         });

package/dist/db/db.d.ts

@@ -100,7 +100,8 @@ export declare enum MessageType {
     AUDIO = "audio",
     VIDEO = "video",
     DELETED = "deleted",
-    REACTION = "reaction"
+    REACTION = "reaction",
+    RETENTION_POLICY = "retention_policy"
 }
 export interface ReadyAnnouncement {
     announcement_bytes: Uint8Array;
@@ -142,6 +143,8 @@ export interface Discussion {
     lastMessageTimestamp: Date | null;
     unreadCount: number;
     pinned: boolean;
+    messageRetentionDuration: number | null;
+    retentionPolicySetAt: number | null;
     killedNextRetryAt?: Date | null;
     saturatedRetryAt?: Date | null;
     saturatedRetryDone: boolean;

package/dist/db/db.js

@@ -38,6 +38,7 @@ export var MessageType;
     MessageType["VIDEO"] = "video";
     MessageType["DELETED"] = "deleted";
     MessageType["REACTION"] = "reaction";
+    MessageType["RETENTION_POLICY"] = "retention_policy";
 })(MessageType || (MessageType = {}));
 /** Serialize a SendAnnouncement to a JSON string for SQLite text column */
 export function serializeSendAnnouncement(announcement) {

package/dist/db/generated-migrations.js

@@ -54,4 +54,13 @@ export const MIGRATIONS = [
         when: 1742000000000,
         statements: ['ALTER TABLE `messages` ADD COLUMN `reactionOf` text;'],
     },
+    {
+        idx: 4,
+        tag: '0004_discussions_retention',
+        when: 1743000000000,
+        statements: [
+            'ALTER TABLE `discussions` ADD COLUMN `messageRetentionDuration` integer;',
+            'ALTER TABLE `discussions` ADD COLUMN `retentionPolicySetAt` integer;',
+        ],
+    },
 ];

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

@@ -10,6 +10,7 @@ export declare class DiscussionQueries {
     getById(id: number): Promise<DiscussionRow | undefined>;
     insert(values: DiscussionInsert): Promise<number>;
     updateById(id: number, data: Partial<DiscussionInsert>): Promise<void>;
+    updateByOwnerAndContact(ownerUserId: string, contactUserId: string, data: Partial<DiscussionInsert>): Promise<void>;
     deleteById(id: number): Promise<void>;
     deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
     incrementUnreadCount(discussionId: number): Promise<void>;

package/dist/db/queries/discussions.js

@@ -40,6 +40,12 @@ export class DiscussionQueries {
             .set(data)
             .where(eq(schema.discussions.id, id));
     }
+    async updateByOwnerAndContact(ownerUserId, contactUserId, data) {
+        await this.conn.db
+            .update(schema.discussions)
+            .set(data)
+            .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.contactUserId, contactUserId)));
+    }
     async deleteById(id) {
         await this.conn.db
             .delete(schema.discussions)

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

@@ -1,3 +1,4 @@
+import type { DiscussionRow } from './discussions.js';
 import * as schema from '../schema/index.js';
 import type { DatabaseConnection } from '../sqlite.js';
 import { MessageStatus } from '../../db/db.js';
@@ -9,6 +10,7 @@ export declare class MessageQueries {
     getById(id: number): Promise<MessageRow | undefined>;
     getByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
     getVisibleByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
+    getLastVisibleByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow | undefined>;
     getReactionsByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
     getByOwnerAndSeeker(ownerUserId: string, seeker: Uint8Array): Promise<MessageRow | undefined>;
     findByMessageId(ownerUserId: string, contactUserId: string, messageId: Uint8Array): Promise<MessageRow | undefined>;
@@ -24,6 +26,12 @@ export declare class MessageQueries {
     getByStatus(ownerUserId: string, status: MessageStatus): Promise<MessageRow[]>;
     resetSendQueue(ownerUserId: string, contactUserId: string): Promise<void>;
     getAnnouncementsByContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
+    /**
+     * Hard-delete messages older than each discussion's retention duration.
+     * Only processes discussions that have a non-null messageRetentionDuration.
+     * Skips KEEP_ALIVE and ANNOUNCEMENT types.
+     */
+    deleteExpiredByOwner(ownerUserId: string, discussions: DiscussionRow[]): Promise<void>;
     findDuplicateIncoming(ownerUserId: string, contactUserId: string, content: string, windowStart: Date, windowEnd: Date): Promise<{
         id: number;
     } | undefined>;

package/dist/db/queries/messages.js

@@ -1,4 +1,4 @@
-import { eq, and, or, sql, inArray, asc, ne } from 'drizzle-orm';
+import { eq, and, or, sql, inArray, asc, ne, lt, gte } from 'drizzle-orm';
 import * as schema from '../schema/index.js';
 import { MessageDirection, MessageStatus, MessageType } from '../../db/db.js';
 export class MessageQueries {
@@ -32,6 +32,8 @@ export class MessageQueries {
             .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 retention policy control messages from UI
+        ne(schema.messages.type, MessageType.RETENTION_POLICY), 
         // Hide reaction messages (and any deleted reaction rows) from main message list
         ne(schema.messages.type, MessageType.REACTION), sql `reactionOf IS NULL`, 
         // Hide delete control messages (outgoing DELETED with empty content)
@@ -41,6 +43,15 @@ export class MessageQueries {
             .orderBy(asc(schema.messages.id))
             .all();
     }
+    async getLastVisibleByOwnerAndContact(ownerUserId, contactUserId) {
+        return this.conn.db
+            .select()
+            .from(schema.messages)
+            .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), ne(schema.messages.type, MessageType.KEEP_ALIVE), ne(schema.messages.type, MessageType.RETENTION_POLICY), ne(schema.messages.type, MessageType.REACTION), sql `reactionOf IS NULL`, or(ne(schema.messages.type, MessageType.DELETED), ne(schema.messages.direction, MessageDirection.OUTGOING), ne(schema.messages.content, '')), sql `(metadata IS NULL OR metadata NOT LIKE '%"control":"edit"%')`))
+            .orderBy(sql `${schema.messages.id} DESC`)
+            .limit(1)
+            .get();
+    }
     async getReactionsByOwnerAndContact(ownerUserId, contactUserId) {
         return this.conn.db
             .select()
@@ -159,6 +170,27 @@ export class MessageQueries {
             .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.INCOMING), eq(schema.messages.type, MessageType.ANNOUNCEMENT)))
             .all();
     }
+    /**
+     * Hard-delete messages older than each discussion's retention duration.
+     * Only processes discussions that have a non-null messageRetentionDuration.
+     * Skips KEEP_ALIVE and ANNOUNCEMENT types.
+     */
+    async deleteExpiredByOwner(ownerUserId, discussions) {
+        const now = Date.now();
+        for (const discussion of discussions) {
+            if (!discussion.messageRetentionDuration ||
+                discussion.messageRetentionDuration <= 0) {
+                continue;
+            }
+            const expiryTs = now - discussion.messageRetentionDuration * 1000;
+            // Only delete messages that were sent AFTER the policy was activated.
+            // Messages that existed before the policy was set are left untouched.
+            const policySetAt = discussion.retentionPolicySetAt ?? 0;
+            await this.conn.db
+                .delete(schema.messages)
+                .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, discussion.contactUserId), lt(schema.messages.timestamp, new Date(expiryTs)), gte(schema.messages.timestamp, new Date(policySetAt)), ne(schema.messages.type, MessageType.KEEP_ALIVE), ne(schema.messages.type, MessageType.ANNOUNCEMENT)));
+        }
+    }
     async findDuplicateIncoming(ownerUserId, contactUserId, content, windowStart, windowEnd) {
         return this.conn.db
             .select({ id: schema.messages.id })

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

@@ -328,6 +328,40 @@ export declare const discussions: import("drizzle-orm/sqlite-core").SQLiteTableW
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        messageRetentionDuration: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "messageRetentionDuration";
+            tableName: "discussions";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        retentionPolicySetAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "retentionPolicySetAt";
+            tableName: "discussions";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         saturatedRetryDone: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "saturatedRetryDone";
             tableName: "discussions";

package/dist/db/schema/discussions.js

@@ -25,6 +25,8 @@ export const discussions = sqliteTable('discussions', {
     pinned: integer('pinned', { mode: 'boolean' }).notNull().default(false),
     killedNextRetryAt: integer('killedNextRetryAt', { mode: 'timestamp_ms' }),
     saturatedRetryAt: integer('saturatedRetryAt', { mode: 'timestamp_ms' }),
+    messageRetentionDuration: integer('messageRetentionDuration'),
+    retentionPolicySetAt: integer('retentionPolicySetAt'), // nullable, ms timestamp when policy was last configured
     saturatedRetryDone: integer('saturatedRetryDone', { mode: 'boolean' })
         .notNull()
         .default(false),

package/dist/gossip.js

@@ -240,6 +240,7 @@ class GossipSdk {
         this._announcement = new AnnouncementService(messageProtocol, session, this.eventEmitter, config, queries);
         this._discussion = new DiscussionService(this._announcement, session, this.eventEmitter, queries);
         this._message = new MessageService(messageProtocol, session, this.eventEmitter, config, queries);
+        this._discussion.setMessageService(this._message);
         this._refresh = new RefreshService(this._message, this._discussion, this._announcement, session, this.eventEmitter, queries, this.config);
         this._selfMessage = new SelfMessageService(queries, session.userIdEncoded, encryptionKey);
         await this._selfMessage.ensureDiscussionExists();

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

@@ -5,7 +5,8 @@ export declare enum MessageType {
     MESSAGE_TYPE_KEEP_ALIVE = 3,
     MESSAGE_TYPE_DELETE = 4,
     MESSAGE_TYPE_EDIT = 5,
-    MESSAGE_TYPE_REACTION = 6
+    MESSAGE_TYPE_REACTION = 6,
+    MESSAGE_TYPE_RETENTION_POLICY = 7
 }
 export interface Message {
     messageType?: MessageType;

package/dist/proto/generated/message.js

@@ -9,6 +9,7 @@ export var MessageType;
     MessageType[MessageType["MESSAGE_TYPE_DELETE"] = 4] = "MESSAGE_TYPE_DELETE";
     MessageType[MessageType["MESSAGE_TYPE_EDIT"] = 5] = "MESSAGE_TYPE_EDIT";
     MessageType[MessageType["MESSAGE_TYPE_REACTION"] = 6] = "MESSAGE_TYPE_REACTION";
+    MessageType[MessageType["MESSAGE_TYPE_RETENTION_POLICY"] = 7] = "MESSAGE_TYPE_RETENTION_POLICY";
 })(MessageType || (MessageType = {}));
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();

package/dist/services/discussion.d.ts

@@ -10,6 +10,7 @@ import { SessionStatus } from '../wasm/bindings.js';
 import { AnnouncementService } from './announcement.js';
 import { SessionModule } from '../wasm/session.js';
 import { RefreshService } from './refresh.js';
+import type { MessageService } from './message.js';
 import type { AuthService } from './auth.js';
 import { Result } from '../utils/type.js';
 import { SdkEventEmitter } from '../core/SdkEventEmitter.js';
@@ -40,10 +41,12 @@ export declare class DiscussionService {
     private session;
     private eventEmitter;
     private refreshService?;
+    private messageService?;
     private authService?;
     private queries;
     constructor(announcementService: AnnouncementService, session: SessionModule, eventEmitter: SdkEventEmitter, queries: Queries, refreshService?: RefreshService);
     setRefreshService(refreshService: RefreshService): void;
+    setMessageService(messageService: MessageService): void;
     setAuthService(authService: AuthService): void;
     /**
      * Initialize a discussion with a contact using SessionManager
@@ -103,4 +106,13 @@ export declare class DiscussionService {
         success: boolean;
         message?: string;
     }>;
+    /**
+     * Set the auto-delete retention policy for a discussion.
+     * Updates the local DB and sends a control message to the peer so both sides
+     * apply the same policy (last-write-wins).
+     *
+     * @param contactUserId - The contact user ID of the discussion
+     * @param durationSeconds - Retention duration in seconds, or null to disable
+     */
+    setRetentionPolicy(contactUserId: string, durationSeconds: number | null): Promise<void>;
 }

package/dist/services/discussion.js

@@ -55,6 +55,12 @@ export class DiscussionService {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "messageService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "authService", {
             enumerable: true,
             configurable: true,
@@ -76,6 +82,9 @@ export class DiscussionService {
     setRefreshService(refreshService) {
         this.refreshService = refreshService;
     }
+    setMessageService(messageService) {
+        this.messageService = messageService;
+    }
     setAuthService(authService) {
         this.authService = authService;
     }
@@ -325,4 +334,42 @@ export class DiscussionService {
     pin(discussionId, pinned) {
         return updateDiscussionPin(discussionId, pinned, this.queries);
     }
+    /**
+     * Set the auto-delete retention policy for a discussion.
+     * Updates the local DB and sends a control message to the peer so both sides
+     * apply the same policy (last-write-wins).
+     *
+     * @param contactUserId - The contact user ID of the discussion
+     * @param durationSeconds - Retention duration in seconds, or null to disable
+     */
+    async setRetentionPolicy(contactUserId, durationSeconds) {
+        const ownerUserId = this.session.userIdEncoded;
+        // Update local DB
+        await this.queries.discussions.updateByOwnerAndContact(ownerUserId, contactUserId, {
+            messageRetentionDuration: durationSeconds,
+            retentionPolicySetAt: durationSeconds ? Date.now() : null,
+        });
+        // Send control message to peer so they apply the same policy
+        if (this.messageService) {
+            const encodedDuration = durationSeconds && durationSeconds > 0 ? durationSeconds : 0;
+            await this.messageService.send({
+                ownerUserId,
+                contactUserId,
+                content: String(encodedDuration),
+                type: MessageType.RETENTION_POLICY,
+                direction: MessageDirection.OUTGOING,
+                status: MessageStatus.WAITING_SESSION,
+                timestamp: new Date(),
+            });
+        }
+        // Restore the correct lastMessageContent by re-deriving from the last
+        // visible message — the control message must not pollute the preview.
+        const lastVisible = await this.queries.messages.getLastVisibleByOwnerAndContact(ownerUserId, contactUserId);
+        await this.queries.discussions.updateByOwnerAndContact(ownerUserId, contactUserId, {
+            lastMessageContent: lastVisible?.content ?? null,
+            lastMessageTimestamp: lastVisible?.timestamp ?? null,
+            lastMessageId: lastVisible?.id ?? null,
+        });
+        await this.refreshService?.stateUpdate();
+    }
 }

package/dist/services/message.d.ts

@@ -111,5 +111,11 @@ export declare class MessageService {
      * control message so the peer can update their copy as well.
      */
     editMessage(id: number, newContent: string): Promise<boolean>;
+    /**
+     * Hard-delete messages that have exceeded their discussion retention duration.
+     * Called periodically from the background refresh cycle.
+     * Emits MESSAGE_RECEIVED if any messages were deleted to trigger UI refresh.
+     */
+    deleteExpiredMessages(ownerUserId: string): Promise<void>;
     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, serializeDeleteMessage, serializeEditMessage, serializeReactionMessage, deserializeMessage, } from '../utils/messageSerialization.js';
+import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, serializeDeleteMessage, serializeEditMessage, serializeReactionMessage, serializeRetentionPolicyMessage, deserializeMessage, } from '../utils/messageSerialization.js';
 import { encodeToBase64, decodeFromBase64 } from '../utils/base64.js';
 import { sessionStatusToString } from '../wasm/session.js';
 import { Logger } from '../utils/logs.js';
@@ -316,7 +316,8 @@ export class MessageService {
         const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId);
         if (discussion &&
             message.type !== MessageType.KEEP_ALIVE &&
-            message.type !== MessageType.REACTION) {
+            message.type !== MessageType.REACTION &&
+            message.type !== MessageType.RETENTION_POLICY) {
             await this.queries.discussions.updateById(discussion.id, {
                 lastMessageId: messageId,
                 lastMessageContent: message.content,
@@ -426,6 +427,20 @@ export class MessageService {
                 // Do not insert a new message row for edit control messages
                 continue;
             }
+            // Handle retention policy control messages by updating the discussion setting
+            if (message.type === MessageType.RETENTION_POLICY) {
+                const durationSeconds = parseInt(message.content, 10);
+                const duration = isNaN(durationSeconds) || durationSeconds <= 0
+                    ? null
+                    : durationSeconds;
+                await this.queries.discussions.updateByOwnerAndContact(ownerUserId, message.senderId, {
+                    messageRetentionDuration: duration,
+                    retentionPolicySetAt: duration ? Date.now() : null,
+                });
+                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, message.senderId);
+                // Do not insert a new message row for retention policy control messages
+                continue;
+            }
             // Handle reaction messages by inserting a separate row
             if (message.type === MessageType.REACTION &&
                 message.reactionOf?.originalMsgId) {
@@ -575,8 +590,9 @@ export class MessageService {
         if (!discussion) {
             return { success: false, error: 'Discussion not found' };
         }
-        // Generate a random messageId for deduplication (not for keep-alive)
-        const randomMessageId = message.type !== MessageType.KEEP_ALIVE
+        // Generate a random messageId for deduplication (not for keep-alive or retention policy)
+        const randomMessageId = message.type !== MessageType.KEEP_ALIVE &&
+            message.type !== MessageType.RETENTION_POLICY
             ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
             : undefined;
         message.messageId = randomMessageId;
@@ -611,7 +627,9 @@ export class MessageService {
     }
     async serializeMessage(message) {
         const log = logger.forMethod('serializeMessage');
-        if (!message.messageId && message.type !== MessageType.KEEP_ALIVE) {
+        if (!message.messageId &&
+            message.type !== MessageType.KEEP_ALIVE &&
+            message.type !== MessageType.RETENTION_POLICY) {
             return {
                 success: false,
                 error: 'Message ID is required',
@@ -636,6 +654,13 @@ export class MessageService {
                 data: serializeKeepAliveMessage(),
             };
         }
+        else if (message.type === MessageType.RETENTION_POLICY) {
+            const durationSeconds = parseInt(message.content, 10);
+            return {
+                success: true,
+                data: serializeRetentionPolicyMessage(isNaN(durationSeconds) || durationSeconds < 0 ? 0 : durationSeconds),
+            };
+        }
         else if (message.type === MessageType.DELETED && message.deleteOf) {
             // Serialize a delete control message targeting an existing messageId
             const originalMsgId = message.deleteOf.originalMsgId;
@@ -1102,6 +1127,18 @@ export class MessageService {
         await this.refreshService?.stateUpdate();
         return true;
     }
+    /**
+     * Hard-delete messages that have exceeded their discussion retention duration.
+     * Called periodically from the background refresh cycle.
+     * Emits MESSAGE_RECEIVED if any messages were deleted to trigger UI refresh.
+     */
+    async deleteExpiredMessages(ownerUserId) {
+        const allRows = await this.queries.discussions.getByOwner(ownerUserId);
+        const withRetention = allRows.filter(d => d.messageRetentionDuration != null && d.messageRetentionDuration > 0);
+        if (withRetention.length === 0)
+            return;
+        await this.queries.messages.deleteExpiredByOwner(ownerUserId, withRetention);
+    }
     // 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/services/refresh.js

@@ -231,6 +231,8 @@ export class RefreshService {
                     });
                 }
             }
+            // Step 4: hard-delete messages that have exceeded retention duration
+            await this.messageService.deleteExpiredMessages(ownerUserId);
         }
         catch (error) {
             log.error('error in update_state', { error });

package/dist/services/selfMessage.d.ts

@@ -20,6 +20,11 @@ export declare class SelfMessageService {
         originalMessageId: number;
     }>;
     removeReaction(reactionId: number): Promise<void>;
+    getRetentionInfo(): Promise<{
+        duration: number | null;
+        setAt: number | null;
+    }>;
+    setRetentionPolicy(durationSeconds: number | null): Promise<void>;
     getReactions(): Promise<{
         id: number;
         emoji: string;

package/dist/services/selfMessage.js

@@ -173,6 +173,20 @@ export class SelfMessageService {
     async removeReaction(reactionId) {
         await this.queries.messages.deleteById(reactionId);
     }
+    async getRetentionInfo() {
+        const row = await this.queries.discussions.getByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
+        return {
+            duration: row?.messageRetentionDuration ?? null,
+            setAt: row?.retentionPolicySetAt ?? null,
+        };
+    }
+    async setRetentionPolicy(durationSeconds) {
+        const duration = durationSeconds != null && durationSeconds > 0 ? durationSeconds : null;
+        await this.queries.discussions.updateByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID, {
+            messageRetentionDuration: duration,
+            retentionPolicySetAt: duration ? Date.now() : null,
+        });
+    }
     async getReactions() {
         const rows = await this.queries.messages.getReactionsByOwnerAndContact(this.ownerUserId, SELF_CONTACT_ID);
         const result = [];

package/dist/utils/messageSerialization.d.ts

@@ -9,6 +9,7 @@ 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 declare const MESSAGE_TYPE_RETENTION_POLICY = ProtoMessageType.MESSAGE_TYPE_RETENTION_POLICY;
 export interface DeserializedMessage {
     content: string;
     messageId?: Uint8Array;
@@ -91,6 +92,13 @@ export declare function serializeDeleteMessage(originalMsgId: Uint8Array, messag
  */
 export declare function serializeEditMessage(newContent: string, originalMsgId: Uint8Array, messageId: Uint8Array): Uint8Array;
 export declare function serializeReactionMessage(emoji: string, originalMsgId: Uint8Array, messageId: Uint8Array): Uint8Array;
+/**
+ * Serialize a retention policy control message
+ *
+ * @param durationSeconds - Retention duration in seconds (0 to disable)
+ * @returns Serialized retention policy message bytes
+ */
+export declare function serializeRetentionPolicyMessage(durationSeconds: number): Uint8Array;
 /**
  * Deserialize a message from bytes
  *

package/dist/utils/messageSerialization.js

@@ -9,6 +9,7 @@ import { Message as ProtoMessage, MessageType as ProtoMessageType, } from '../pr
 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;
+export const MESSAGE_TYPE_RETENTION_POLICY = ProtoMessageType.MESSAGE_TYPE_RETENTION_POLICY;
 /**
  * Serialize a keep-alive message
  * Keep-alive messages are used to maintain session activity
@@ -150,6 +151,18 @@ export function serializeReactionMessage(emoji, originalMsgId, messageId) {
         citedMsgId: originalMsgId,
     });
 }
+/**
+ * Serialize a retention policy control message
+ *
+ * @param durationSeconds - Retention duration in seconds (0 to disable)
+ * @returns Serialized retention policy message bytes
+ */
+export function serializeRetentionPolicyMessage(durationSeconds) {
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_RETENTION_POLICY,
+        content: String(durationSeconds),
+    });
+}
 /**
  * Deserialize a message from bytes
  *
@@ -169,6 +182,12 @@ export function deserializeMessage(buffer) {
             type: MessageType.KEEP_ALIVE,
         };
     }
+    if (protoType === ProtoMessageType.MESSAGE_TYPE_RETENTION_POLICY) {
+        return {
+            content: decoded.content ?? '0',
+            type: MessageType.RETENTION_POLICY,
+        };
+    }
     const content = decoded.content ?? '';
     const messageId = decoded.messageId;
     const citedMsgId = decoded.citedMsgId;

package/package.json

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