@massalabs/gossip-sdk 0.0.2-dev.20260417075224 → 0.0.2-dev.20260420074041

package/dist/core/SdkEventEmitter.d.ts

@@ -8,6 +8,8 @@ export declare enum SdkEventType {
     MESSAGE_SENT = "messageSent",
     MESSAGE_READ = "messageRead",
     MESSAGE_FAILED = "messageFailed",
+    MESSAGE_DELETED = "messageDeleted",
+    MESSAGE_UPDATED = "messageUpdated",
     SESSION_REQUESTED = "sessionRequested",
     SESSION_CREATED = "sessionCreated",
     SESSION_RENEWED = "sessionRenewed",
@@ -28,6 +30,12 @@ export type SdkEvents = {
         message: Message;
         error: Error;
     };
+    [SdkEventType.MESSAGE_DELETED]: {
+        messages: Message[];
+    };
+    [SdkEventType.MESSAGE_UPDATED]: {
+        messages: Message[];
+    };
     [SdkEventType.SESSION_REQUESTED]: {
         discussion: Discussion;
         contact: Contact;
@@ -40,7 +48,7 @@ export type SdkEvents = {
         contactUserId: string;
         status: SessionStatus;
     };
-    [SdkEventType.DISCUSSION_UPDATED]: string;
+    [SdkEventType.DISCUSSION_UPDATED]: number;
     [SdkEventType.MESSAGE_ACKNOWLEDGED]: {
         contactUserId: string;
         messageDbId: number;

package/dist/core/SdkEventEmitter.js

@@ -8,6 +8,8 @@ export var SdkEventType;
     SdkEventType["MESSAGE_SENT"] = "messageSent";
     SdkEventType["MESSAGE_READ"] = "messageRead";
     SdkEventType["MESSAGE_FAILED"] = "messageFailed";
+    SdkEventType["MESSAGE_DELETED"] = "messageDeleted";
+    SdkEventType["MESSAGE_UPDATED"] = "messageUpdated";
     SdkEventType["SESSION_REQUESTED"] = "sessionRequested";
     SdkEventType["SESSION_CREATED"] = "sessionCreated";
     SdkEventType["SESSION_RENEWED"] = "sessionRenewed";

package/dist/db/queries/activeSeekers.js

@@ -9,10 +9,10 @@ export class ActiveSeekerQueries {
         });
     }
     async replaceAll(seekers) {
-        await this.conn.withTransaction(async () => {
-            await this.conn.db.delete(schema.activeSeekers);
+        await this.conn.db.transaction(async (tx) => {
+            await tx.delete(schema.activeSeekers);
             if (seekers.length > 0) {
-                await this.conn.db
+                await tx
                     .insert(schema.activeSeekers)
                     .values(seekers.map(seeker => ({ seeker })));
             }

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

@@ -1,18 +1,20 @@
 import * as schema from '../schema/index.js';
-import type { DatabaseConnection } from '../sqlite.js';
+import type { DatabaseConnection, GossipSqliteTx } from '../sqlite.js';
+import type { MessageRow } from './messages.js';
 export type DiscussionRow = typeof schema.discussions.$inferSelect;
 export type DiscussionInsert = typeof schema.discussions.$inferInsert;
 export declare class DiscussionQueries {
     private conn;
     constructor(conn: DatabaseConnection);
-    getByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<DiscussionRow | undefined>;
+    getByOwnerAndContact(ownerUserId: string, contactUserId: string, tx?: GossipSqliteTx): Promise<DiscussionRow | undefined>;
     getByOwner(ownerUserId: string): Promise<DiscussionRow[]>;
     getById(id: number): Promise<DiscussionRow | undefined>;
+    getLastTextMessage(contactUserId: string, tx?: GossipSqliteTx): Promise<MessageRow | undefined>;
     insert(values: DiscussionInsert): Promise<number>;
-    updateById(id: number, data: Partial<DiscussionInsert>): Promise<void>;
+    updateById(id: number, data: Partial<DiscussionInsert>, tx?: GossipSqliteTx): 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>;
-    decrementUnreadCount(discussionId: number): Promise<void>;
+    incrementUnreadCount(discussionId: number, tx?: GossipSqliteTx): Promise<void>;
+    decrementUnreadCount(discussionId: number, tx?: GossipSqliteTx): Promise<void>;
 }

package/dist/db/queries/discussions.js

@@ -1,5 +1,6 @@
 import { eq, and, gt, sql } from 'drizzle-orm';
 import * as schema from '../schema/index.js';
+import { MessageType } from '../db.js';
 export class DiscussionQueries {
     constructor(conn) {
         Object.defineProperty(this, "conn", {
@@ -9,8 +10,8 @@ export class DiscussionQueries {
             value: conn
         });
     }
-    async getByOwnerAndContact(ownerUserId, contactUserId) {
-        return this.conn.db
+    async getByOwnerAndContact(ownerUserId, contactUserId, tx) {
+        return (tx ?? this.conn.db)
             .select()
             .from(schema.discussions)
             .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.contactUserId, contactUserId)))
@@ -30,12 +31,21 @@ export class DiscussionQueries {
             .where(eq(schema.discussions.id, id))
             .get();
     }
+    async getLastTextMessage(contactUserId, tx) {
+        return (tx ?? this.conn.db)
+            .select()
+            .from(schema.messages)
+            .where(and(eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.type, MessageType.TEXT)))
+            .orderBy(sql `${schema.messages.timestamp} DESC`)
+            .limit(1)
+            .get();
+    }
     async insert(values) {
         await this.conn.db.insert(schema.discussions).values(values);
         return this.conn.getLastInsertRowId();
     }
-    async updateById(id, data) {
-        await this.conn.db
+    async updateById(id, data, tx) {
+        await (tx ?? this.conn.db)
             .update(schema.discussions)
             .set(data)
             .where(eq(schema.discussions.id, id));
@@ -56,16 +66,16 @@ export class DiscussionQueries {
             .delete(schema.discussions)
             .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.contactUserId, contactUserId)));
     }
-    async incrementUnreadCount(discussionId) {
-        await this.conn.db
+    async incrementUnreadCount(discussionId, tx) {
+        await (tx ?? this.conn.db)
             .update(schema.discussions)
             .set({
             unreadCount: sql `${schema.discussions.unreadCount} + 1`,
         })
             .where(eq(schema.discussions.id, discussionId));
     }
-    async decrementUnreadCount(discussionId) {
-        await this.conn.db
+    async decrementUnreadCount(discussionId, tx) {
+        await (tx ?? this.conn.db)
             .update(schema.discussions)
             .set({
             unreadCount: sql `MAX(${schema.discussions.unreadCount} - 1, 0)`,

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

@@ -1,6 +1,6 @@
 import type { DiscussionRow } from './discussions.js';
 import * as schema from '../schema/index.js';
-import type { DatabaseConnection } from '../sqlite.js';
+import type { DatabaseConnection, GossipSqliteTx } from '../sqlite.js';
 import { MessageStatus } from '../../db/db.js';
 export type MessageRow = typeof schema.messages.$inferSelect;
 export type MessageInsert = typeof schema.messages.$inferInsert;
@@ -14,9 +14,9 @@ export declare class MessageQueries {
     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>;
-    insert(values: MessageInsert): Promise<number>;
+    insert(values: MessageInsert, tx?: GossipSqliteTx): Promise<number>;
     batchInsert(values: MessageInsert[]): Promise<void>;
-    updateById(id: number, data: Partial<MessageInsert>): Promise<void>;
+    updateById(id: number, data: Partial<MessageInsert>, tx?: GossipSqliteTx): Promise<void>;
     deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
     deleteById(id: number): Promise<void>;
     deleteReactionsForMessage(ownerUserId: string, contactUserId: string, messageIdBase64: string): Promise<void>;

package/dist/db/queries/messages.js

@@ -74,8 +74,8 @@ export class MessageQueries {
             .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.messageId, messageId)))
             .get();
     }
-    async insert(values) {
-        await this.conn.db.insert(schema.messages).values(values);
+    async insert(values, tx) {
+        await (tx ?? this.conn.db).insert(schema.messages).values(values);
         return this.conn.getLastInsertRowId();
     }
     async batchInsert(values) {
@@ -83,8 +83,8 @@ export class MessageQueries {
             return;
         await this.conn.db.insert(schema.messages).values(values);
     }
-    async updateById(id, data) {
-        await this.conn.db
+    async updateById(id, data, tx) {
+        await (tx ?? this.conn.db)
             .update(schema.messages)
             .set(data)
             .where(eq(schema.messages.id, id));

package/dist/db/sqlite.d.ts

@@ -14,6 +14,8 @@
 import { type SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
 import * as schema from './schema/index.js';
 export type GossipDatabase = SqliteRemoteDatabase<typeof schema>;
+/** Callback `tx` from `GossipDatabase.transaction()` — pass through query helpers for the same API as `db`. */
+export type GossipSqliteTx = Parameters<Parameters<GossipDatabase['transaction']>[0]>[0];
 /** Selects the SQLite storage backend. */
 export type StorageConfig = {
     type: 'opfs';

package/dist/services/discussion.js

@@ -275,7 +275,7 @@ export class DiscussionService {
         const result = await this.initialize(contact, payload);
         if (result.success) {
             await this.refreshService?.stateUpdate();
-            this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, contact.userId);
+            this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, result.data.discussionId);
         }
         return result;
     }

package/dist/services/message.d.ts

@@ -14,6 +14,7 @@ import { SdkEventEmitter } from '../core/SdkEventEmitter.js';
 import type { RefreshService } from './refresh.js';
 import { Queries } from '../db/queries/index.js';
 import { QueueManager } from '../utils/queue.js';
+import { GossipSqliteTx } from '../db/sqlite.js';
 /** Options for the simplified sendText method */
 export interface SendTextOptions {
     /** Reply to an existing message */
@@ -71,27 +72,9 @@ export declare class MessageService {
      */
     private handleDuplicateMessageId;
     findMessageByMsgId(messageId: Uint8Array, ownerUserId: string, contactUserId?: string): Promise<Message | undefined>;
-    findMessageBySeeker(seeker: Uint8Array, ownerUserId: string): Promise<Message | undefined>;
     private acknowledgeMessages;
-    sendMessage(message: Message): Promise<SendMessageResult>;
-    /**
-     * Happy-path send: peer session is Active, so we can encrypt locally,
-     * fire the network POST, and INSERT the row in parallel. The three
-     * pieces are independent up until the final `UPDATE → SENT`, which
-     * needs both the row id (from INSERT) and a successful network ack.
-     *
-     *   ┌── INSERT (~440 ms) ───────────────┐
-     *   │                                   ├── UPDATE → SENT (background)
-     *   └── encrypt (~150 ms) → POST (~620 ms)
-     *                                       │
-     *                                       └── emit MESSAGE_SENT
-     *
-     * Returns `null` if the fast path can't run (encrypt declined, network
-     * threw, etc.) so the caller can fall back to the slow path.
-     */
-    private sendMessageFastPath;
+    sendMessage(message: Message, parentTx?: GossipSqliteTx): Promise<SendMessageResult>;
     private serializeMessage;
-    resendMessages(messages: Map<string, Message[]>): Promise<void>;
     /**
      * Process the send queue for a single contact.
      * Handles WAITING_SESSION -> READY encryption and READY -> SENT delivery.
@@ -101,10 +84,6 @@ export declare class MessageService {
      * Count pending outgoing messages for a contact (WAITING_SESSION/READY).
      */
     getPendingSendCount(contactUserId: string): Promise<number>;
-    /**
-     * Get count of messages waiting for session with a specific contact.
-     */
-    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).
@@ -124,6 +103,7 @@ export declare class MessageService {
     sendText(contactUserId: string, text: string, options?: SendTextOptions): Promise<SendMessageResult>;
     /** Fetch and decrypt messages from the protocol (alias) */
     fetch(): Promise<MessageResult>;
+    private PerformDeleteMessage;
     /**
      * Delete a message by its database ID (outgoing or incoming in 1-to-1).
      * Marks the local message as deleted and enqueues a delete control message
@@ -133,6 +113,7 @@ export declare class MessageService {
      */
     deleteMessage(id: number): Promise<boolean>;
     sendReaction(contactUserId: string, emoji: string, originalMsgId: Uint8Array): Promise<SendMessageResult>;
+    private performEditMessage;
     /**
      * Edit an outgoing message by its database ID.
      * Updates the local content (preserving timestamp) and enqueues an edit

package/dist/services/message.js

@@ -8,11 +8,14 @@ import { MessageDirection, MessageStatus, MessageType, MESSAGE_ID_SIZE, } from '
 import { decodeUserId, encodeUserId } from '../utils/userId.js';
 import { SessionStatus } from '../wasm/bindings.js';
 import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, serializeDeleteMessage, serializeEditMessage, serializeReactionMessage, serializeRetentionPolicyMessage, deserializeMessage, } from '../utils/messageSerialization.js';
+import * as schema from '../db/schema/index.js';
 import { encodeToBase64, decodeFromBase64 } from '../utils/base64.js';
 import { sessionStatusToString } from '../wasm/session.js';
 import { Logger } from '../utils/logs.js';
 import { defaultSdkConfig } from '../config/sdk.js';
 import { SdkEventType } from '../core/SdkEventEmitter.js';
+import { and, eq, sql } from 'drizzle-orm';
+import { POST_MESSAGE_TYPES } from '../utils/message.js';
 // ---------------------------------------------------------------------------
 // JSON serialization helpers for message fields stored as text in SQLite
 // ---------------------------------------------------------------------------
@@ -309,8 +312,9 @@ export class MessageService {
     /**
      * Add a message to SQLite and update the corresponding discussion.
      */
-    async addMessageAndUpdateDiscussion(message) {
-        return this.queries.conn.withTransaction(async () => {
+    async addMessageAndUpdateDiscussion(message, parentTx) {
+        const db = parentTx ?? this.queries.conn.db;
+        const result = await db.transaction(async (tx) => {
             const messageId = await this.queries.messages.insert({
                 messageId: message.messageId,
                 ownerUserId: message.ownerUserId,
@@ -330,24 +334,26 @@ export class MessageService {
                 reactionOf: serializeReactionOf(message.reactionOf),
                 encryptedMessage: message.encryptedMessage,
                 whenToSend: message.whenToSend,
-            });
-            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.RETENTION_POLICY) {
+            }, tx);
+            const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId, tx);
+            if (discussion && POST_MESSAGE_TYPES.includes(message.type)) {
                 await this.queries.discussions.updateById(discussion.id, {
                     lastMessageId: messageId,
                     lastMessageContent: message.content,
                     lastMessageTimestamp: message.timestamp,
                     updatedAt: new Date(),
-                });
+                }, tx);
                 if (message.direction === MessageDirection.INCOMING) {
-                    await this.queries.discussions.incrementUnreadCount(discussion.id);
+                    await this.queries.discussions.incrementUnreadCount(discussion.id, tx);
                 }
+                return { messageId, updatedDiscussionId: discussion?.id };
             }
-            return messageId;
+            return { messageId, updatedDiscussionId: null };
         });
+        if (result.updatedDiscussionId) {
+            this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, result.updatedDiscussionId);
+        }
+        return result.messageId;
     }
     async decryptMessages(encrypted) {
         const log = logger.forMethod('decryptMessages');
@@ -419,34 +425,13 @@ export class MessageService {
                     });
                     continue;
                 }
-                if (target.type === MessageType.REACTION) {
-                    // Reaction delete: hard-delete the row, not "[Message deleted]"
-                    await this.queries.messages.deleteById(target.id);
-                    this.emitMessageReceived({
-                        ...target,
-                        type: MessageType.DELETED,
-                    });
-                }
-                else {
-                    // Regular message delete: mark as deleted
-                    this.emitMessageReceived({
-                        ...target,
-                        content: '[Message deleted]',
-                        type: MessageType.DELETED,
-                    });
-                    const targetId = target.id;
-                    const deleteOriginalMsgId = message.deleteOf.originalMsgId;
-                    await this.queries.conn.withTransaction(async () => {
-                        await this.queries.messages.updateById(targetId, {
-                            content: '[Message deleted]',
-                            type: MessageType.DELETED,
-                        });
-                        await this.queries.messages.deleteReactionsForMessage(ownerUserId, target.contactUserId, encodeToBase64(deleteOriginalMsgId));
-                    });
+                const resDb = await this.PerformDeleteMessage(target);
+                if (!resDb.success) {
+                    throw new Error(resDb.error?.message ?? 'Failed to delete message from db');
                 }
                 continue;
             }
-            // Handle edit control messages by updating the referenced message in-place
+            // 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) {
@@ -465,10 +450,10 @@ export class MessageService {
                     content: message.content,
                     metadata: mergedMetadata,
                 });
-                await this.queries.messages.updateById(target.id, {
-                    content: message.content,
-                    metadata: serializeMetadata(mergedMetadata),
-                });
+                const res = await this.performEditMessage(message.content, target, mergedMetadata);
+                if (!res.success) {
+                    throw new Error(res.error?.message ?? 'Failed to edit message in db');
+                }
                 // Do not insert a new message row for edit control messages
                 continue;
             }
@@ -482,7 +467,15 @@ export class MessageService {
                     messageRetentionDuration: duration,
                     retentionPolicySetAt: duration ? Date.now() : null,
                 });
-                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, message.senderId);
+                const discussion = await this.queries.discussions.getByOwnerAndContact(ownerUserId, message.senderId);
+                if (!discussion) {
+                    this.eventEmitter.emit(SdkEventType.ERROR, {
+                        error: new Error('could no retrieve discussion after updating retention policy'),
+                        context: 'storeDecryptedMessages',
+                    });
+                    continue;
+                }
+                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussion.id);
                 // Do not insert a new message row for retention policy control messages
                 continue;
             }
@@ -497,8 +490,7 @@ export class MessageService {
                     });
                     continue;
                 }
-                // Emit before DB write so UI updates instantly
-                this.emitMessageReceived({
+                const id = await this.queries.messages.insert({
                     messageId: message.messageId,
                     ownerUserId,
                     contactUserId: discussion.contactUserId,
@@ -507,9 +499,11 @@ export class MessageService {
                     direction: MessageDirection.INCOMING,
                     status: MessageStatus.DELIVERED,
                     timestamp: message.sentAt,
-                    reactionOf: message.reactionOf,
+                    metadata: serializeMetadata({}),
+                    reactionOf: serializeReactionOf(message.reactionOf),
                 });
-                const id = await this.queries.messages.insert({
+                this.emitMessageReceived({
+                    id,
                     messageId: message.messageId,
                     ownerUserId,
                     contactUserId: discussion.contactUserId,
@@ -518,8 +512,7 @@ export class MessageService {
                     direction: MessageDirection.INCOMING,
                     status: MessageStatus.DELIVERED,
                     timestamp: message.sentAt,
-                    metadata: serializeMetadata({}),
-                    reactionOf: serializeReactionOf(message.reactionOf),
+                    reactionOf: message.reactionOf,
                 });
                 storedIds.push(id);
                 // Do not update discussion lastMessageContent for reactions
@@ -536,7 +529,7 @@ export class MessageService {
             // If received msg has same messageId as a previously received msg
             const isDuplicate = await this.handleDuplicateMessageId(message, ownerUserId);
             if (isDuplicate) {
-                log.info('Duplicate message received, skipping', {
+                log.info('Duplicate message received, skip  ping', {
                     senderId: message.senderId,
                     preview: message.content.slice(0, 30),
                 });
@@ -562,8 +555,6 @@ export class MessageService {
                 replyTo: message.replyTo,
                 forwardOf: message.forwardOf,
             };
-            // Emit before DB write — UI shows message instantly
-            this.emitMessageReceived(incomingMsg);
             const id = await this.queries.messages.insert({
                 messageId: message.messageId,
                 ownerUserId,
@@ -590,6 +581,7 @@ export class MessageService {
             storedIds.push(id);
             // Re-emit with DB id so the store patches the optimistic message
             this.emitMessageReceived({ ...incomingMsg, id });
+            this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussion.id);
         }
         return storedIds;
     }
@@ -613,10 +605,6 @@ export class MessageService {
         const row = await this.queries.messages.findByMessageId(ownerUserId, contactUserId, messageId);
         return row ? rowToMessage(row) : undefined;
     }
-    async findMessageBySeeker(seeker, ownerUserId) {
-        const row = await this.queries.messages.getByOwnerAndSeeker(ownerUserId, seeker);
-        return row ? rowToMessage(row) : undefined;
-    }
     async acknowledgeMessages(seekers, userId) {
         if (seekers.size === 0)
             return;
@@ -645,7 +633,7 @@ export class MessageService {
                 .info(`acknowledged ${toUpdate.length} messages`);
         }
     }
-    async sendMessage(message) {
+    async sendMessage(message, parentTx) {
         const log = logger.forMethod('sendMessage');
         log.info('queueing message', {
             messageType: message.type,
@@ -658,7 +646,7 @@ export class MessageService {
             };
         }
         // Look up discussion
-        const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId);
+        const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId, parentTx);
         if (!discussion) {
             return { success: false, error: 'Discussion not found' };
         }
@@ -671,29 +659,12 @@ export class MessageService {
                 : undefined;
             message.messageId = randomMessageId;
         }
-        // Fast path: if the peer's session is already Active we can encrypt
-        // and ship the message in parallel with the local INSERT instead of
-        // waiting for `addMessageAndUpdateDiscussion` to commit before
-        // `processSendQueueForContact` even starts. The user-perceived
-        // latency drops from `INSERT + encrypt + POST` (sequential) to
-        // `max(INSERT, encrypt + POST)` — ~440 ms saved on prod where the
-        // network round-trip dominates.
-        const sessionStatus = this.session.peerSessionStatus(peerId);
-        if (sessionStatus === SessionStatus.Active) {
-            const fastPathResult = await this.sendMessageFastPath(message, peerId);
-            if (fastPathResult) {
-                return fastPathResult;
-            }
-            // Fast path bailed (encrypt returned null, etc.) — fall back to
-            // the slow path below.
-        }
-        // Slow path: INSERT first, let stateUpdate handle the encrypt + send.
-        let messageId;
+        let messageIdDb;
         try {
-            messageId = await this.addMessageAndUpdateDiscussion({
+            messageIdDb = await this.addMessageAndUpdateDiscussion({
                 ...message,
                 status: MessageStatus.WAITING_SESSION,
-            });
+            }, parentTx);
         }
         catch (error) {
             return {
@@ -701,186 +672,21 @@ export class MessageService {
                 error: 'Failed to add message to database, got error: ' + error,
             };
         }
-        const queuedMessage = {
-            ...message,
-            id: messageId,
-            status: MessageStatus.WAITING_SESSION,
-        };
         /*
-        Trigger a state update to send the new message.
-        If the stateUpdate function is already running, it will be skipped.
+        Trigger a sending queue state update for contact in order to send the new message.
+        If the processSendQueueForContact function is already running, it will be skipped.
         */
-        await this.refreshService?.stateUpdate();
-        return {
-            success: true,
-            message: queuedMessage,
-        };
-    }
-    /**
-     * Happy-path send: peer session is Active, so we can encrypt locally,
-     * fire the network POST, and INSERT the row in parallel. The three
-     * pieces are independent up until the final `UPDATE → SENT`, which
-     * needs both the row id (from INSERT) and a successful network ack.
-     *
-     *   ┌── INSERT (~440 ms) ───────────────┐
-     *   │                                   ├── UPDATE → SENT (background)
-     *   └── encrypt (~150 ms) → POST (~620 ms)
-     *                                       │
-     *                                       └── emit MESSAGE_SENT
-     *
-     * Returns `null` if the fast path can't run (encrypt declined, network
-     * threw, etc.) so the caller can fall back to the slow path.
-     */
-    async sendMessageFastPath(message, peerId) {
-        const log = logger.forMethod('sendMessageFastPath');
-        // 1. Serialize synchronously — needed before encrypt.
-        const serializeResult = await this.serializeMessage(message);
-        if (!serializeResult.success) {
-            log.error('failed to serialize message for fast path', {
-                error: serializeResult.error,
-            });
-            return null;
-        }
-        const serializedContent = serializeResult.data;
-        // 2. Kick off the local INSERT and the encrypt in parallel.
-        //    encrypt is fast (~150 ms with rayon) and doesn't depend on
-        //    the row id; INSERT is slow (~440 ms) and only the row id is
-        //    later needed for the SENT update.
-        const insertPromise = this.addMessageAndUpdateDiscussion({
-            ...message,
-            status: MessageStatus.WAITING_SESSION,
-        })
-            .then(id => {
-            this.inFlightFastPath.add(id);
-            return id;
-        })
-            .catch(error => {
-            log.error('addMessageAndUpdateDiscussion failed in fast path', {
-                error,
-            });
-            return null;
-        });
-        let sendOutput;
-        try {
-            sendOutput = await this.session.sendMessage(peerId, serializedContent);
-        }
-        catch (error) {
-            log.error('session.sendMessage threw in fast path, falling back', {
-                error,
-            });
-            sendOutput = undefined;
-        }
-        if (!sendOutput) {
-            // Session became inactive between status check and encrypt.
-            // Wait for the INSERT to land then bail out so the slow path
-            // can take over.
-            const messageId = await insertPromise;
-            if (messageId === null) {
-                return {
-                    success: false,
-                    error: 'Failed to add message to database',
-                };
-            }
-            log.info('encrypt returned null in fast path, falling back to slow path', { messageId });
-            this.inFlightFastPath.delete(messageId);
-            void this.refreshService?.stateUpdate();
-            return {
-                success: true,
-                message: {
-                    ...message,
-                    id: messageId,
-                    status: MessageStatus.WAITING_SESSION,
-                },
-            };
-        }
-        // 3. Encrypt succeeded. Network POST runs in parallel with the
-        //    still-in-flight INSERT.
-        const networkPromise = this.messageProtocol
-            .sendMessage({
-            seeker: sendOutput.seeker,
-            ciphertext: sendOutput.data,
-        })
-            .then(() => true)
-            .catch(error => {
-            log.error('network send failed in fast path', { error });
-            return false;
-        });
-        const [messageId, networkOk] = await Promise.all([
-            insertPromise,
-            networkPromise,
-        ]);
-        if (messageId === null) {
+        await this.processSendQueueForContact(message.contactUserId);
+        const messageDb = await this.queries.messages.getById(messageIdDb);
+        if (!messageDb) {
             return {
                 success: false,
-                error: 'Failed to add message to database',
+                error: 'Could not retrieve message after adding it to the database',
             };
         }
-        if (!networkOk) {
-            // Network failed: persist READY so the next retry doesn't
-            // re-encrypt, and let stateUpdate pick it up.
-            this.inFlightFastPath.delete(messageId);
-            await this.queries.messages.updateById(messageId, {
-                status: MessageStatus.READY,
-                encryptedMessage: sendOutput.data,
-                seeker: sendOutput.seeker,
-                whenToSend: new Date(Date.now() + this.config.messages.retryDelayMs),
-                serializedContent,
-            });
-            void this.refreshService?.stateUpdate();
-            return {
-                success: true,
-                message: {
-                    ...message,
-                    id: messageId,
-                    status: MessageStatus.READY,
-                },
-            };
-        }
-        // 4. Both succeeded. Race-check then UPDATE → SENT.
-        const latestRow = await this.queries.messages.getById(messageId);
-        if (!latestRow || latestRow.status !== MessageStatus.WAITING_SESSION) {
-            log.debug('message gone or status changed during fast-path send, skipping SENT update', { messageId, currentStatus: latestRow?.status });
-            this.inFlightFastPath.delete(messageId);
-            return {
-                success: true,
-                message: {
-                    ...message,
-                    id: messageId,
-                    status: MessageStatus.SENT,
-                },
-            };
-        }
-        await this.queries.messages.updateById(messageId, {
-            status: MessageStatus.SENT,
-            seeker: sendOutput.seeker,
-            encryptedMessage: null,
-            serializedContent: null,
-            whenToSend: null,
-        });
-        this.inFlightFastPath.delete(messageId);
-        const isControlMessage = !!(message.deleteOf || message.editOf);
-        if (!isControlMessage) {
-            try {
-                this.eventEmitter.emit(SdkEventType.MESSAGE_SENT, {
-                    ...message,
-                    id: messageId,
-                    status: MessageStatus.SENT,
-                });
-            }
-            catch (error) {
-                log.error('failed to emit message sent event from fast path', {
-                    messageId,
-                    error,
-                });
-            }
-        }
         return {
             success: true,
-            message: {
-                ...message,
-                id: messageId,
-                status: MessageStatus.SENT,
-            },
+            message: rowToMessage(messageDb),
         };
     }
     async serializeMessage(message) {
@@ -982,28 +788,6 @@ export class MessageService {
             };
         }
     }
-    async resendMessages(messages) {
-        const log = logger.forMethod('resendMessages');
-        let totalProcessed = 0;
-        for (const [contactId, retryMessages] of messages.entries()) {
-            totalProcessed += retryMessages.length;
-            for (const msg of retryMessages) {
-                if (!msg.id)
-                    continue;
-                await this.queries.messages.updateById(msg.id, {
-                    status: MessageStatus.WAITING_SESSION,
-                    encryptedMessage: null,
-                    seeker: null,
-                    whenToSend: null,
-                });
-            }
-            await this.processSendQueueForContact(contactId);
-        }
-        log.info('resend completed', {
-            contacts: messages.size,
-            messagesProcessed: totalProcessed,
-        });
-    }
     /**
      * Process the send queue for a single contact.
      * Handles WAITING_SESSION -> READY encryption and READY -> SENT delivery.
@@ -1275,13 +1059,6 @@ export class MessageService {
         const rows = await this.queries.messages.getSendQueue(ownerUserId, contactUserId);
         return rows.length;
     }
-    /**
-     * Get count of messages waiting for session with a specific contact.
-     */
-    async getWaitingMessageCount(contactUserId) {
-        const ownerUserId = this.session.userIdEncoded;
-        return this.queries.messages.getWaitingCount(ownerUserId, contactUserId);
-    }
     // ─────────────────────────────────────────────────────────────────
     // Consumer-facing convenience methods
     // ─────────────────────────────────────────────────────────────────
@@ -1338,6 +1115,114 @@ export class MessageService {
     async fetch() {
         return this.fetchMessages();
     }
+    async PerformDeleteMessage(message, tx) {
+        if (!message.id) {
+            return { success: false, error: new Error('Message ID is required') };
+        }
+        const db = tx ?? this.queries.conn.db;
+        if (message.type === MessageType.REACTION) {
+            // Reaction delete: hard-delete the row, not "[Message deleted]"
+            try {
+                await this.queries.messages.deleteById(message.id);
+                this.eventEmitter.emit(SdkEventType.MESSAGE_DELETED, {
+                    messages: [message],
+                });
+                return { success: true, data: null };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error
+                        ? error
+                        : new Error('Unknown error occurred while deleting reaction message'),
+                };
+            }
+        }
+        let deletedMessages = [];
+        let updatedMessages = [];
+        let discussionId;
+        try {
+            // Run all operations inside an explicit transaction for atomicity
+            await db.transaction(async (trx) => {
+                const discussion = await trx
+                    .select()
+                    .from(schema.discussions)
+                    .where(and(eq(schema.discussions.ownerUserId, message.ownerUserId), eq(schema.discussions.contactUserId, message.contactUserId)))
+                    .get();
+                if (!discussion) {
+                    throw new Error('Discussion not found');
+                }
+                // delete the message : MessageType.DELETED '[Message deleted]' in  db
+                await this.queries.messages.updateById(message.id, // message.id is guaranteed to be not null because we checked it above
+                {
+                    content: '[Message deleted]',
+                    type: MessageType.DELETED,
+                }, trx);
+                if (POST_MESSAGE_TYPES.includes(message.type)) {
+                    // If the message to delete is the last text message in the discussion, update the discussion to the previous last text message
+                    if (discussion.lastMessageId === message.id) {
+                        const lastMessage = await this.queries.discussions.getLastTextMessage(message.contactUserId, trx);
+                        await this.queries.discussions.updateById(discussion.id, {
+                            lastMessageId: lastMessage?.id ?? null,
+                            lastMessageContent: lastMessage?.content ?? null,
+                            lastMessageTimestamp: lastMessage?.timestamp ?? null,
+                            updatedAt: new Date(),
+                        }, trx);
+                        discussionId = discussion.id;
+                    }
+                    // If deleted message is not read yet, decrement the discussion unread count
+                    if (message.status !== MessageStatus.READ &&
+                        message.direction === MessageDirection.INCOMING) {
+                        await this.queries.discussions.decrementUnreadCount(discussion.id, trx);
+                        discussionId = discussion.id;
+                    }
+                    // Delete all REACTION messages for this contact referencing this message
+                    const deletedReactionMessages = await trx
+                        .delete(schema.messages)
+                        .where(and(eq(schema.messages.contactUserId, message.contactUserId), eq(schema.messages.type, MessageType.REACTION), sql `json_extract(${schema.messages.reactionOf}, '$.originalMsgId') = ${encodeToBase64(message.messageId)}`))
+                        .returning();
+                    deletedMessages = deletedReactionMessages.map(rowToMessage);
+                    // Also update all messages REPLYING to this message by setting their replyTo to null
+                    const updatedMessagesDb = await trx
+                        .update(schema.messages)
+                        .set({ replyTo: null })
+                        .where(and(eq(schema.messages.contactUserId, message.contactUserId), sql `json_extract(${schema.messages.replyTo}, '$.originalMsgId') = ${encodeToBase64(message.messageId)}`))
+                        .returning();
+                    updatedMessages = updatedMessagesDb.map(row => rowToMessage(row));
+                }
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+        // function to be called after the db transaction is committed.
+        // Send events only when we are sure corresponding operation are saved in db
+        const postDbCommit = () => {
+            this.eventEmitter.emit(SdkEventType.MESSAGE_DELETED, {
+                messages: [message, ...deletedMessages],
+            });
+            if (updatedMessages.length > 0) {
+                this.eventEmitter.emit(SdkEventType.MESSAGE_UPDATED, {
+                    messages: updatedMessages,
+                });
+            }
+            if (discussionId) {
+                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussionId);
+            }
+        };
+        if (!tx) {
+            // if we are not in a db transaction, we can just emit the event and return
+            postDbCommit();
+            return { success: true, data: null };
+        }
+        else {
+            // if we are in a db transaction, we need to return a function that will be called after the transaction is committed
+            return { success: true, data: postDbCommit };
+        }
+    }
     /**
      * Delete a message by its database ID (outgoing or incoming in 1-to-1).
      * Marks the local message as deleted and enqueues a delete control message
@@ -1352,28 +1237,33 @@ export class MessageService {
         if (!row.messageId)
             throw new Error('Cannot delete a message that has no messageId');
         const ownerUserId = this.session.userIdEncoded;
-        const messageId = row.messageId;
-        await this.queries.conn.withTransaction(async () => {
-            await this.queries.messages.updateById(id, {
-                content: '[Message deleted]',
+        const callbackAfterDbCommit = await this.queries.conn.db.transaction(async (tx) => {
+            const res = await this.PerformDeleteMessage(rowToMessage(row), tx);
+            if (!res.success) {
+                tx.rollback(); // if deleting the message from the db fails, rollback the transaction
+                throw new Error(res.error?.message ?? 'Failed to delete message from db');
+            }
+            // Send the delete control message to the peer
+            const controlMessage = {
+                ownerUserId,
+                contactUserId: row.contactUserId,
+                content: '',
                 type: MessageType.DELETED,
-            });
-            await this.queries.messages.deleteReactionsForMessage(ownerUserId, row.contactUserId, encodeToBase64(messageId));
+                direction: MessageDirection.OUTGOING,
+                status: MessageStatus.WAITING_SESSION,
+                timestamp: new Date(),
+                deleteOf: { originalMsgId: row.messageId }, // row.messageId was previously verified to be not null
+            };
+            const result = await this.sendMessage(controlMessage, tx);
+            if (!result.success) {
+                tx.rollback(); // if sending the delete control message fails, rollback the transaction
+                throw new Error(result.error ?? 'Failed to enqueue delete message');
+            }
+            return res.data;
         });
-        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();
+        if (callbackAfterDbCommit) {
+            callbackAfterDbCommit();
+        }
         return true;
     }
     async sendReaction(contactUserId, emoji, originalMsgId) {
@@ -1388,9 +1278,53 @@ export class MessageService {
             reactionOf: { originalMsgId },
         };
         const result = await this.send(message);
-        await this.refreshService?.stateUpdate();
         return result;
     }
+    async performEditMessage(newContent, originalMsg, metadata, tx) {
+        if (!originalMsg.id) {
+            return { success: false, error: new Error('Message ID is required') };
+        }
+        const db = tx ?? this.queries.conn.db;
+        let discussionUpdatedId;
+        try {
+            await db
+                .update(schema.messages)
+                .set({ content: newContent, metadata: serializeMetadata(metadata) })
+                .where(eq(schema.messages.id, originalMsg.id))
+                .returning();
+            const discussion = await this.queries.discussions.getByOwnerAndContact(originalMsg.ownerUserId, originalMsg.contactUserId, tx);
+            if (!discussion) {
+                return { success: false, error: new Error('Discussion not found') };
+            }
+            if (discussion.lastMessageId === originalMsg.id) {
+                await this.queries.discussions.updateById(discussion.id, {
+                    lastMessageContent: newContent,
+                    updatedAt: new Date(),
+                }, tx);
+                discussionUpdatedId = discussion.id;
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+        const postDbCommit = () => {
+            if (discussionUpdatedId) {
+                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussionUpdatedId);
+            }
+        };
+        if (!tx) {
+            // if we are not in a db transaction, we can just emit the event and return
+            postDbCommit();
+            return { success: true, data: null };
+        }
+        else {
+            // if we are in a db transaction, we need to return a function that will be called after the transaction is committed
+            return { success: true, data: postDbCommit };
+        }
+    }
     /**
      * Edit an outgoing message by its database ID.
      * Updates the local content (preserving timestamp) and enqueues an edit
@@ -1407,25 +1341,33 @@ export class MessageService {
         const ownerUserId = this.session.userIdEncoded;
         const existingMetadata = deserializeMetadata(row.metadata) ?? {};
         const mergedMetadata = { ...existingMetadata, edited: true };
-        await this.queries.messages.updateById(id, {
-            content: newContent,
-            metadata: serializeMetadata(mergedMetadata),
+        const callbackAfterDbCommit = await this.queries.conn.db.transaction(async (tx) => {
+            const res = await this.performEditMessage(newContent, rowToMessage(row), mergedMetadata, tx);
+            if (!res.success) {
+                tx.rollback();
+                throw new Error(res.error?.message ?? 'Failed to edit message in db');
+            }
+            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 }, // row.messageId was previously verified to be not null
+                metadata: { control: 'edit' },
+            };
+            const result = await this.sendMessage(controlMessage, tx);
+            if (!result.success) {
+                tx.rollback();
+                throw new Error(result.error ?? 'Failed to enqueue edit message');
+            }
+            return res.data;
         });
-        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();
+        if (callbackAfterDbCommit) {
+            callbackAfterDbCommit();
+        }
         return true;
     }
     /**
@@ -1449,14 +1391,22 @@ export class MessageService {
             return false;
         }
         const message = rowToMessage(row);
-        // Update message status
-        await this.queries.messages.updateById(id, { status: MessageStatus.READ });
-        // Atomically decrement discussion unread count
-        const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId);
-        if (discussion) {
-            await this.queries.discussions.decrementUnreadCount(discussion.id);
-        }
+        // Perform message status update and unread count decrement atomically in a transaction
+        const discussionId = await this.queries.conn.db.transaction(async (tx) => {
+            // Update message status
+            await this.queries.messages.updateById(id, { status: MessageStatus.READ }, tx);
+            // Atomically decrement discussion unread count
+            const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId, tx);
+            if (!discussion || !discussion.id) {
+                throw new Error('Discussion not found');
+            }
+            if (discussion) {
+                await this.queries.discussions.decrementUnreadCount(discussion.id, tx);
+            }
+            return discussion.id;
+        });
         this.eventEmitter.emit(SdkEventType.MESSAGE_READ, id);
+        this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussionId);
         return true;
     }
 }

package/dist/utils/message.d.ts

@@ -0,0 +1,2 @@
+import { MessageType } from '../db/db.js';
+export declare const POST_MESSAGE_TYPES: MessageType[];

package/dist/utils/message.js

@@ -0,0 +1,9 @@
+import { MessageType } from '../db/db.js';
+/*Message that add a new post in the discussion */
+export const POST_MESSAGE_TYPES = [
+    MessageType.TEXT,
+    MessageType.IMAGE,
+    MessageType.FILE,
+    MessageType.AUDIO,
+    MessageType.VIDEO,
+];

package/package.json

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