@massalabs/gossip-sdk 0.0.2-dev.20260220052333 → 0.0.2-dev.20260220053835

package/dist/services/message.js

@@ -5,24 +5,98 @@
  * This service works both in host app contexts and SDK/automation context.
  */
 import { MessageDirection, MessageStatus, MessageType, MESSAGE_ID_SIZE, } from '../db';
+import { getMessageById, getMessageByOwnerAndSeeker, findMessageByMessageId, insertMessage, updateMessageById, deleteDeliveredKeepAliveMessages, getOutgoingSentMessagesByOwner, getWaitingMessageCount as getWaitingCount, getSendQueueMessages, } from '../queries';
+import { getDiscussionByOwnerAndContact, updateDiscussionById, incrementUnreadCount, decrementUnreadCount, } from '../queries';
+import { replaceActiveSeekers } from '../queries';
 import { decodeUserId, encodeUserId } from '../utils/userId';
 import { SessionStatus } from '../wasm/bindings';
 import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, deserializeMessage, } from '../utils/messageSerialization';
-import { encodeToBase64 } from '../utils/base64';
+import { encodeToBase64, decodeFromBase64 } from '../utils/base64';
 import { sessionStatusToString } from '../wasm/session';
 import { Logger } from '../utils/logs';
 import { defaultSdkConfig } from '../config/sdk';
 import { SdkEventType } from '../core/SdkEventEmitter';
+// ---------------------------------------------------------------------------
+// JSON serialization helpers for message fields stored as text in SQLite
+// ---------------------------------------------------------------------------
+/** Serialize replyTo to JSON string for SQLite storage.
+ *  Uint8Array fields are base64-encoded. */
+function serializeReplyTo(replyTo) {
+    if (!replyTo)
+        return null;
+    return JSON.stringify({
+        originalMsgId: encodeToBase64(replyTo.originalMsgId),
+    });
+}
+/** Deserialize replyTo from JSON string. */
+function deserializeReplyTo(json) {
+    if (!json)
+        return undefined;
+    const parsed = JSON.parse(json);
+    return {
+        originalMsgId: decodeFromBase64(parsed.originalMsgId),
+    };
+}
+/** Serialize forwardOf to JSON string for SQLite storage. */
+function serializeForwardOf(forwardOf) {
+    if (!forwardOf)
+        return null;
+    return JSON.stringify({
+        originalContent: forwardOf.originalContent,
+        originalContactId: forwardOf.originalContactId
+            ? encodeToBase64(forwardOf.originalContactId)
+            : undefined,
+    });
+}
+/** Deserialize forwardOf from JSON string. */
+function deserializeForwardOf(json) {
+    if (!json)
+        return undefined;
+    const parsed = JSON.parse(json);
+    return {
+        originalContent: parsed.originalContent ?? undefined,
+        originalContactId: parsed.originalContactId
+            ? decodeFromBase64(parsed.originalContactId)
+            : undefined,
+    };
+}
+/** Serialize metadata to JSON string. */
+function serializeMetadata(metadata) {
+    if (!metadata)
+        return null;
+    return JSON.stringify(metadata);
+}
+/** Deserialize metadata from JSON string. */
+function deserializeMetadata(json) {
+    if (!json)
+        return undefined;
+    return JSON.parse(json);
+}
+/** Convert a SQLite row from the messages table to a Message object. */
+export function rowToMessage(row) {
+    return {
+        id: row.id,
+        messageId: row.messageId ?? undefined,
+        ownerUserId: row.ownerUserId,
+        contactUserId: row.contactUserId,
+        content: row.content,
+        serializedContent: row.serializedContent ?? undefined,
+        type: row.type,
+        direction: row.direction,
+        status: row.status,
+        timestamp: row.timestamp,
+        metadata: deserializeMetadata(row.metadata),
+        seeker: row.seeker ?? undefined,
+        replyTo: deserializeReplyTo(row.replyTo),
+        forwardOf: deserializeForwardOf(row.forwardOf),
+        encryptedMessage: row.encryptedMessage ?? undefined,
+        whenToSend: row.whenToSend ?? undefined,
+    };
+}
 const sleep = (ms) => new Promise(res => setTimeout(res, ms));
 const logger = new Logger('MessageService');
 export class MessageService {
-    constructor(db, messageProtocol, session, discussionService, eventEmitter, config = defaultSdkConfig) {
-        Object.defineProperty(this, "db", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+    constructor(messageProtocol, session, eventEmitter, config = defaultSdkConfig) {
         Object.defineProperty(this, "messageProtocol", {
             enumerable: true,
             configurable: true,
@@ -35,19 +109,19 @@ export class MessageService {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "discussionService", {
+        Object.defineProperty(this, "eventEmitter", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "eventEmitter", {
+        Object.defineProperty(this, "config", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "config", {
+        Object.defineProperty(this, "refreshService", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -65,13 +139,13 @@ export class MessageService {
             writable: true,
             value: false
         });
-        this.db = db;
         this.messageProtocol = messageProtocol;
         this.session = session;
-        this.discussionService = discussionService;
         this.eventEmitter = eventEmitter;
         this.config = config;
-        void this.discussionService;
+    }
+    setRefreshService(refreshService) {
+        this.refreshService = refreshService;
     }
     async fetchMessages() {
         const log = logger.forMethod('fetchMessages');
@@ -129,7 +203,7 @@ export class MessageService {
                 await sleep(this.config.messages.fetchDelayMs);
             }
             try {
-                await this.db.setActiveSeekers(seekers);
+                await replaceActiveSeekers(seekers);
             }
             catch (error) {
                 log.error('failed to update active seekers', error);
@@ -151,6 +225,41 @@ export class MessageService {
             this.isFetchingMessages = false;
         }
     }
+    /**
+     * Add a message to SQLite and update the corresponding discussion.
+     */
+    async addMessageAndUpdateDiscussion(message) {
+        const messageId = await insertMessage({
+            messageId: message.messageId,
+            ownerUserId: message.ownerUserId,
+            contactUserId: message.contactUserId,
+            content: message.content,
+            serializedContent: message.serializedContent,
+            type: message.type,
+            direction: message.direction,
+            status: message.status,
+            timestamp: message.timestamp,
+            metadata: serializeMetadata(message.metadata),
+            seeker: message.seeker,
+            replyTo: serializeReplyTo(message.replyTo),
+            forwardOf: serializeForwardOf(message.forwardOf),
+            encryptedMessage: message.encryptedMessage,
+            whenToSend: message.whenToSend,
+        });
+        const discussion = await getDiscussionByOwnerAndContact(message.ownerUserId, message.contactUserId);
+        if (discussion) {
+            await updateDiscussionById(discussion.id, {
+                lastMessageId: messageId,
+                lastMessageContent: message.content,
+                lastMessageTimestamp: message.timestamp,
+                updatedAt: new Date(),
+            });
+            if (message.direction === MessageDirection.INCOMING) {
+                await incrementUnreadCount(discussion.id);
+            }
+        }
+        return messageId;
+    }
     async decryptMessages(encrypted) {
         const log = logger.forMethod('decryptMessages');
         const decrypted = [];
@@ -207,187 +316,117 @@ export class MessageService {
         const log = logger.forMethod('storeDecryptedMessages');
         const storedIds = [];
         for (const message of decrypted) {
-            const result = await this.db.transaction('rw', this.db.messages, this.db.discussions, async () => {
-                const discussion = await this.db.getDiscussionByOwnerAndContact(ownerUserId, message.senderId);
-                if (!discussion) {
-                    log.error('no discussion for incoming message', {
-                        senderId: message.senderId,
-                        preview: message.content.slice(0, 50),
-                    });
-                    return null;
-                }
-                // 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', {
-                        senderId: message.senderId,
-                        preview: message.content.slice(0, 30),
-                    });
-                    return null;
-                }
-                if (message.replyTo?.originalMsgId) {
-                    const original = await this.findMessageByMsgId(message.replyTo.originalMsgId, ownerUserId, message.senderId);
-                    if (!original) {
-                        log.warn('reply target not found', {
-                            originalMsgId: encodeToBase64(message.replyTo.originalMsgId),
-                        });
-                    }
-                }
-                const id = await this.db.messages.add({
-                    ownerUserId,
-                    contactUserId: discussion.contactUserId,
-                    content: message.content,
-                    type: message.type,
-                    direction: MessageDirection.INCOMING,
-                    status: MessageStatus.DELIVERED,
-                    timestamp: message.sentAt,
-                    metadata: {},
-                    messageId: message.messageId,
-                    replyTo: message.replyTo
-                        ? {
-                            originalMsgId: message.replyTo.originalMsgId,
-                        }
-                        : undefined,
-                    forwardOf: message.forwardOf
-                        ? {
-                            originalContent: message.forwardOf.originalContent,
-                            originalContactId: message.forwardOf.originalContactId,
-                        }
-                        : undefined,
+            const discussion = await getDiscussionByOwnerAndContact(ownerUserId, message.senderId);
+            if (!discussion) {
+                log.error('no discussion for incoming message', {
+                    senderId: message.senderId,
+                    preview: message.content.slice(0, 50),
                 });
-                const now = new Date();
-                await this.db.discussions.update(discussion.id, {
-                    lastMessageId: id,
-                    lastMessageContent: message.content,
-                    lastMessageTimestamp: message.sentAt,
-                    updatedAt: now,
-                    lastSyncTimestamp: now,
-                    unreadCount: discussion.unreadCount + 1,
+                continue;
+            }
+            // 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', {
+                    senderId: message.senderId,
+                    preview: message.content.slice(0, 30),
                 });
-                return id;
-            });
-            if (result === null) {
                 continue;
             }
-            const id = result;
+            if (message.replyTo?.originalMsgId) {
+                const original = await this.findMessageByMsgId(message.replyTo.originalMsgId, ownerUserId, message.senderId);
+                if (!original) {
+                    log.warn('reply target not found', {
+                        originalMsgId: encodeToBase64(message.replyTo.originalMsgId),
+                    });
+                }
+            }
+            const id = await insertMessage({
+                messageId: message.messageId,
+                ownerUserId,
+                contactUserId: discussion.contactUserId,
+                content: message.content,
+                type: message.type,
+                direction: MessageDirection.INCOMING,
+                status: MessageStatus.DELIVERED,
+                timestamp: message.sentAt,
+                metadata: serializeMetadata({}),
+                replyTo: serializeReplyTo(message.replyTo),
+                forwardOf: serializeForwardOf(message.forwardOf),
+            });
+            // Update discussion in SQLite
+            const now = new Date();
+            await updateDiscussionById(discussion.id, {
+                lastMessageId: id,
+                lastMessageContent: message.content,
+                lastMessageTimestamp: message.sentAt,
+                updatedAt: now,
+                lastSyncTimestamp: now,
+            });
+            await incrementUnreadCount(discussion.id);
             storedIds.push(id);
             // Emit event for new message
-            const storedMessage = await this.db.messages.get(id);
-            if (storedMessage) {
-                this.eventEmitter.emit(SdkEventType.MESSAGE_RECEIVED, storedMessage);
+            const row = await getMessageById(id);
+            if (row) {
+                this.eventEmitter.emit(SdkEventType.MESSAGE_RECEIVED, rowToMessage(row));
             }
         }
         return storedIds;
     }
     /**
-     * Checks for duplicate incoming messages in the message database based on messageId.
-     *
-     * A message is considered a duplicate if:
-     * - It has the same messageId
-     * - It is from the same sender (contactUserId)
-     * - Belongs to the same conversation (ownerUserId)
-     *
-     * This protects against scenarios where:
-     * 1. A sender successfully delivers a message to the network,
-     * 2. Their app crashes or resets before marking the message as SENT in the local DB,
-     * 3. On restart, the sender's app re-sends the message (possibly with a different seeker),
-     * 4. The receiver gets the same message twice,
-     * 5. Duplicates are prevented by matching messageId byte-for-byte.
-     *
-     * This method uses messageId (usually a 12-byte random value) for exact match detection.
-     * If a duplicate is found, it updates certain fields (e.g., content, replyTo, forwardOf)
-     * on the existing message and returns true.
-     *
-     * @param message - The incoming decrypted message object.
-     * @param ownerUserId - The userId of the message database owner (the recipient).
-     * @returns true if a duplicate message (by messageId) was found; otherwise false.
+     * Checks for duplicate incoming messages based on messageId (12-byte random).
+     * Returns true if a message with the same messageId already exists (skips storage).
      */
     async handleDuplicateMessageId(message, ownerUserId) {
-        // Check for duplicate message using messageId (12 bytes random)
-        if (message.messageId) {
-            const existingWithMessageId = await this.db.messages
-                .where('[ownerUserId+contactUserId]')
-                .equals([ownerUserId, message.senderId])
-                .and(m => {
-                if (!m.messageId || !message.messageId)
-                    return false;
-                if (m.messageId.length !== message.messageId.length)
-                    return false;
-                for (let i = 0; i < m.messageId.length; i++) {
-                    if (m.messageId[i] !== message.messageId[i])
-                        return false;
-                }
-                return true;
-            })
-                .first();
-            if (existingWithMessageId) {
-                await this.db.messages.update(existingWithMessageId.id, {
-                    content: message.content,
-                    replyTo: message.replyTo,
-                    forwardOf: message.forwardOf,
-                });
+        if (message.messageId && message.messageId.length > 0) {
+            const existing = await findMessageByMessageId(ownerUserId, message.senderId, message.messageId);
+            if (existing) {
                 return true;
             }
         }
         return false;
     }
     async findMessageByMsgId(messageId, ownerUserId, contactUserId) {
-        const baseQuery = contactUserId
-            ? this.db.messages
-                .where('[ownerUserId+contactUserId]')
-                .equals([ownerUserId, contactUserId])
-            : this.db.messages.where('ownerUserId').equals(ownerUserId);
-        return await baseQuery
-            .and(m => {
-            if (!m.messageId || m.messageId.length !== messageId.length) {
-                return false;
-            }
-            for (let i = 0; i < messageId.length; i++) {
-                if (m.messageId[i] !== messageId[i])
-                    return false;
-            }
-            return true;
-        })
-            .first();
+        if (!contactUserId) {
+            // Without contactUserId, fall back to seeker-based lookup is not possible
+            // with messageId. Return undefined.
+            return undefined;
+        }
+        const row = await findMessageByMessageId(ownerUserId, contactUserId, messageId);
+        return row ? rowToMessage(row) : undefined;
+    }
+    async findMessageBySeeker(seeker, ownerUserId) {
+        const row = await getMessageByOwnerAndSeeker(ownerUserId, seeker);
+        return row ? rowToMessage(row) : undefined;
     }
     async acknowledgeMessages(seekers, userId) {
         if (seekers.size === 0)
             return;
-        const updatedCount = await this.db.transaction('rw', this.db.messages, async () => {
-            // Mark matching OUTGOING SENT messages as DELIVERED
-            const count = await this.db.messages
-                .where('[ownerUserId+direction+status]')
-                .equals([userId, MessageDirection.OUTGOING, MessageStatus.SENT])
-                .filter(message => message.seeker !== undefined &&
-                seekers.has(encodeToBase64(message.seeker)))
-                .modify({
+        // Find SENT outgoing messages, then filter by seeker match
+        const candidates = await getOutgoingSentMessagesByOwner(userId);
+        const toUpdate = candidates.filter(m => m.seeker != null && seekers.has(encodeToBase64(m.seeker)));
+        // Mark matching OUTGOING SENT messages as DELIVERED and clear encrypted data
+        for (const m of toUpdate) {
+            await updateMessageById(m.id, {
                 status: MessageStatus.DELIVERED,
-                serializedContent: undefined,
-                seeker: undefined,
+                encryptedMessage: null,
+                serializedContent: null,
+                seeker: null,
+                whenToSend: null,
             });
-            // After marking as DELIVERED, clean up DELIVERED keep-alive messages
-            await this.db.messages
-                .where({
-                ownerUserId: userId,
-                status: MessageStatus.DELIVERED,
-                type: MessageType.KEEP_ALIVE,
-            })
-                .delete();
-            return count;
-        });
-        if (updatedCount > 0) {
+        }
+        // After marking as DELIVERED, clean up DELIVERED keep-alive messages
+        await deleteDeliveredKeepAliveMessages(userId);
+        if (toUpdate.length > 0) {
             logger
                 .forMethod('acknowledgeMessages')
-                .info(`acknowledged ${updatedCount} messages`);
+                .info(`acknowledged ${toUpdate.length} messages`);
         }
     }
     async sendMessage(message) {
         const log = logger.forMethod('sendMessage');
         log.info('queueing message', {
-            messageContent: message.content,
             messageType: message.type,
-            messageReplyTo: message.replyTo,
-            messageForwardOf: message.forwardOf,
         });
         const peerId = decodeUserId(message.contactUserId);
         if (peerId.length !== 32) {
@@ -396,37 +435,40 @@ export class MessageService {
                 error: 'Invalid contact userId (must be 32 bytes)',
             };
         }
-        // Run getDiscussionByOwnerAndContact and addMessage in a transaction
-        let discussion;
+        // Look up discussion
+        const discussion = await getDiscussionByOwnerAndContact(message.ownerUserId, message.contactUserId);
+        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
+            ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
+            : undefined;
+        message.messageId = randomMessageId;
+        // Add message as WAITING_SESSION
         let messageId;
-        const error = await this.db.transaction('rw', this.db.discussions, this.db.messages, async () => {
-            discussion = await this.db.getDiscussionByOwnerAndContact(message.ownerUserId, message.contactUserId);
-            if (!discussion) {
-                // If the discussion doesn't exist (it may have been deleted by the user), Dexie aborts the transaction.
-                return new Error('Discussion not found');
-            }
-            try {
-                const randomMessageId = message.type !== MessageType.KEEP_ALIVE
-                    ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
-                    : undefined;
-                message.messageId = randomMessageId;
-                messageId = await this.db.addMessage({
-                    ...message,
-                    status: MessageStatus.WAITING_SESSION,
-                });
-            }
-            catch (error) {
-                return new Error('Failed to add message to database, got error: ' + error);
-            }
-        });
-        if (error) {
-            return { success: false, error: error.message };
+        try {
+            messageId = await this.addMessageAndUpdateDiscussion({
+                ...message,
+                status: MessageStatus.WAITING_SESSION,
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                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.
+        */
+        await this.refreshService?.stateUpdate();
         return {
             success: true,
             message: queuedMessage,
@@ -490,11 +532,11 @@ export class MessageService {
             for (const msg of retryMessages) {
                 if (!msg.id)
                     continue;
-                await this.db.messages.update(msg.id, {
+                await updateMessageById(msg.id, {
                     status: MessageStatus.WAITING_SESSION,
-                    encryptedMessage: undefined,
-                    seeker: undefined,
-                    whenToSend: undefined,
+                    encryptedMessage: null,
+                    seeker: null,
+                    whenToSend: null,
                 });
             }
             await this.processSendQueueForContact(contactId);
@@ -517,7 +559,7 @@ export class MessageService {
         }
         this.processingContacts.add(contactUserId);
         try {
-            const discussion = await this.db.getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
+            const discussion = await getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
             const weAccepted = discussion?.weAccepted;
             if (!discussion || !weAccepted) {
                 return {
@@ -537,13 +579,8 @@ export class MessageService {
                     error: new Error('Session not active or self requested'),
                 };
             }
-            // retrieve all message in send queue that need to be updated for this contact
-            const pendingMessages = await this.db.messages
-                .where('[ownerUserId+contactUserId]')
-                .equals([ownerUserId, contactUserId])
-                .and(msg => msg.direction === MessageDirection.OUTGOING &&
-                [MessageStatus.WAITING_SESSION, MessageStatus.READY].includes(msg.status))
-                .sortBy('timestamp');
+            // retrieve all messages in send queue that need to be updated for this contact
+            const pendingMessages = (await getSendQueueMessages(ownerUserId, contactUserId)).map(rowToMessage);
             log.debug('pending messages', {
                 pendingMessages: pendingMessages.map(msg => ({
                     id: msg.id,
@@ -592,7 +629,7 @@ export class MessageService {
                     encryptedMessage = sendOutput.data;
                     seeker = sendOutput.seeker;
                     whenToSend = new Date();
-                    await this.db.messages.update(msg.id, {
+                    await updateMessageById(msg.id, {
                         status: MessageStatus.READY,
                         encryptedMessage,
                         seeker,
@@ -622,11 +659,11 @@ export class MessageService {
                         continue;
                     }
                     if (!encryptedMessage || !seeker) {
-                        await this.db.messages.update(msg.id, {
+                        await updateMessageById(msg.id, {
                             status: MessageStatus.WAITING_SESSION,
-                            encryptedMessage: undefined,
-                            seeker: undefined,
-                            whenToSend: undefined,
+                            encryptedMessage: null,
+                            seeker: null,
+                            whenToSend: null,
                         });
                         log.debug('message has no encryptedMessage or seeker, updated to WAITING_SESSION', {
                             messageId: msg.id,
@@ -646,30 +683,20 @@ export class MessageService {
                             seeker,
                             ciphertext: encryptedMessage,
                         });
-                        // update the db
-                        const sent = await this.db.transaction('rw', this.db.messages, async () => {
-                            try {
-                                const latest = await this.db.messages.get(msg.id);
-                                if (latest && // ensure the discussion has not been deleted
-                                    latest.status === MessageStatus.READY // ensure the discussion has not been reset with all pending messages reset to WAITING_SESSION
-                                ) {
-                                    await this.db.messages.update(msg.id, {
-                                        status: MessageStatus.SENT,
-                                        encryptedMessage: undefined,
-                                        whenToSend: undefined,
-                                    });
-                                    return true;
-                                }
-                            }
-                            catch (error) {
-                                log.error('failed to update message status to SENT', {
-                                    messageId: msg.id,
-                                    error,
-                                });
-                                return false;
-                            }
-                            return false;
-                        });
+                        // update the db — check latest state to avoid race conditions
+                        const latestRow = await getMessageById(msg.id);
+                        let sent = false;
+                        if (latestRow && // ensure the discussion has not been deleted
+                            latestRow.status === MessageStatus.READY // ensure the discussion has not been reset with all pending messages reset to WAITING_SESSION
+                        ) {
+                            await updateMessageById(msg.id, {
+                                status: MessageStatus.SENT,
+                                encryptedMessage: null,
+                                serializedContent: null,
+                                whenToSend: null,
+                            });
+                            sent = true;
+                        }
                         if (sent) {
                             sentCount++;
                             log.debug('message sent', {
@@ -698,16 +725,14 @@ export class MessageService {
                             messageId: msg.id,
                             error,
                         });
-                        await this.db.transaction('rw', this.db.messages, async () => {
-                            const latest = await this.db.messages.get(msg.id);
-                            if (latest && // ensure the discussion has not been deleted
-                                latest.status === MessageStatus.READY // ensure the discussion has not been reset with all pending messages reset to WAITING_SESSION
-                            ) {
-                                await this.db.messages.update(msg.id, {
-                                    whenToSend: new Date(Date.now() + this.config.messages.retryDelayMs),
-                                });
-                            }
-                        });
+                        const latestRow = await getMessageById(msg.id);
+                        if (latestRow && // ensure the discussion has not been deleted
+                            latestRow.status === MessageStatus.READY // ensure the discussion has not been reset with all pending messages reset to WAITING_SESSION
+                        ) {
+                            await updateMessageById(msg.id, {
+                                whenToSend: new Date(Date.now() + this.config.messages.retryDelayMs),
+                            });
+                        }
                     }
                 }
             }
@@ -722,12 +747,8 @@ export class MessageService {
      */
     async getPendingSendCount(contactUserId) {
         const ownerUserId = this.session.userIdEncoded;
-        return await this.db.messages
-            .where('[ownerUserId+contactUserId]')
-            .equals([ownerUserId, contactUserId])
-            .and(msg => msg.direction === MessageDirection.OUTGOING &&
-            [MessageStatus.WAITING_SESSION, MessageStatus.READY].includes(msg.status))
-            .count();
+        const rows = await getSendQueueMessages(ownerUserId, contactUserId);
+        return rows.length;
     }
     /**
      * Send a keep-alive message without adding it to the message history.
@@ -765,34 +786,25 @@ export class MessageService {
      */
     async getWaitingMessageCount(contactUserId) {
         const ownerUserId = this.session.userIdEncoded;
-        return await this.db.messages
-            .where('[ownerUserId+contactUserId+status]')
-            .equals([ownerUserId, contactUserId, MessageStatus.WAITING_SESSION])
-            .count();
+        return getWaitingCount(ownerUserId, contactUserId);
     }
     // 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) {
-        return await this.db.transaction('rw', [this.db.messages, this.db.discussions], async () => {
-            // Check current message status from DB to avoid race conditions
-            const message = await this.db.messages.get(id);
-            if (!message || message.status !== MessageStatus.DELIVERED) {
-                // Message was already marked as read or doesn't exist
-                return false;
-            }
-            // Update message status
-            await this.db.messages.update(id, {
-                status: MessageStatus.READ,
-            });
-            // Decrement discussion unread count
-            await this.db.discussions
-                .where('[ownerUserId+contactUserId]')
-                .equals([message.ownerUserId, message.contactUserId])
-                .modify(discussion => {
-                if (discussion.unreadCount > 0) {
-                    discussion.unreadCount -= 1;
-                }
-            });
-            return true;
-        });
+        // Check current message status from DB to avoid race conditions
+        const row = await getMessageById(id);
+        if (!row || row.status !== MessageStatus.DELIVERED) {
+            // Message was already marked as read or doesn't exist
+            return false;
+        }
+        const message = rowToMessage(row);
+        // Update message status
+        await updateMessageById(id, { status: MessageStatus.READ });
+        // Atomically decrement discussion unread count
+        const discussion = await getDiscussionByOwnerAndContact(message.ownerUserId, message.contactUserId);
+        if (discussion) {
+            await decrementUnreadCount(discussion.id);
+        }
+        this.eventEmitter.emit(SdkEventType.MESSAGE_READ, id);
+        return true;
     }
 }