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

package/dist/services/discussion.d.ts

@@ -3,13 +3,14 @@
  *
  * Class-based service for initializing, accepting, and managing discussions.
  */
-import { type Discussion, type Contact, type GossipDatabase } from '../db';
+import { type Discussion, type Contact } from '../db';
 import { AnnouncementPayload } from '../utils/announcementPayload';
 import { AnnouncementService } from './announcement';
 import { SessionModule } from '../wasm/session';
+import { RefreshService } from './refresh';
 import { Result } from '../utils/type';
 import { SdkEventEmitter } from '../core/SdkEventEmitter';
-export interface discussionInitializationResult {
+export interface DiscussionInitializationResult {
     discussionId: number;
     announcement: Uint8Array;
 }
@@ -18,7 +19,7 @@ export interface discussionInitializationResult {
  *
  * @example
  * ```typescript
- * const discussionService = new DiscussionService(db, announcementService, session, refreshService);
+ * const discussionService = new DiscussionService(announcementService, session, eventEmitter, refreshService);
  *
  * // Initialize a new discussion
  * const result = await discussionService.initialize(contact, 'Hello!');
@@ -31,11 +32,12 @@ export interface discussionInitializationResult {
  * ```
  */
 export declare class DiscussionService {
-    private db;
     private announcementService;
     private session;
     private eventEmitter;
-    constructor(db: GossipDatabase, announcementService: AnnouncementService, session: SessionModule, eventEmitter: SdkEventEmitter);
+    private refreshService?;
+    constructor(announcementService: AnnouncementService, session: SessionModule, eventEmitter: SdkEventEmitter, refreshService?: RefreshService);
+    setRefreshService(refreshService: RefreshService): void;
     /**
      * Initialize a discussion with a contact using SessionManager
      * @param contact - The contact to start a discussion with
@@ -53,7 +55,7 @@ export declare class DiscussionService {
      *   await discussionService.initialize(contact, payload);
      * ```
      */
-    initialize(contact: Contact, payload?: AnnouncementPayload): Promise<Result<discussionInitializationResult, Error>>;
+    initialize(contact: Contact, payload?: AnnouncementPayload): Promise<Result<DiscussionInitializationResult, Error>>;
     /**
      * Accept a discussion request from a contact using SessionManager
      * @param discussion - The discussion to accept
@@ -69,12 +71,3 @@ export declare class DiscussionService {
      */
     createSessionForContact(contactUserId: string, userData: Uint8Array): Promise<Result<Uint8Array, Error>>;
 }
-/**
- * Reset the send queue for a contact.
- * All messages that are not yet delivered (i.e. READY, SENDING, SENT) are reset to WAITING_SESSION.
- * @param db - The database instance
- * @param ownerUserId - The user ID of the owner
- * @param contactUserId - The user ID of the contact
- * @returns A Promise that resolves when the send queue is reset
- */
-export declare function resetSendQueue(db: GossipDatabase, ownerUserId: string, contactUserId: string): Promise<void>;

package/dist/services/discussion.js

@@ -3,18 +3,20 @@
  *
  * Class-based service for initializing, accepting, and managing discussions.
  */
-import { DiscussionDirection, MessageDirection, MessageStatus, MessageType, } from '../db';
+import { DiscussionDirection, DiscussionStatus, MessageDirection, MessageStatus, MessageType, serializeSendAnnouncement, } from '../db';
+import { toDiscussion } from '../utils/discussions';
 import { encodeAnnouncementPayload, } from '../utils/announcementPayload';
 import { UserPublicKeys } from '../wasm/bindings';
 import { Logger } from '../utils/logs';
 import { SdkEventType } from '../core/SdkEventEmitter';
+import { getContactByOwnerAndUser, getDiscussionByOwnerAndContact, getDiscussionById, insertDiscussion, updateDiscussionById, deleteDiscussionById, insertMessage, resetSendQueueMessages, } from '../queries';
 const logger = new Logger('DiscussionService');
 /**
  * Service for managing discussions between users.
  *
  * @example
  * ```typescript
- * const discussionService = new DiscussionService(db, announcementService, session, refreshService);
+ * const discussionService = new DiscussionService(announcementService, session, eventEmitter, refreshService);
  *
  * // Initialize a new discussion
  * const result = await discussionService.initialize(contact, 'Hello!');
@@ -27,35 +29,38 @@ const logger = new Logger('DiscussionService');
  * ```
  */
 export class DiscussionService {
-    constructor(db, announcementService, session, eventEmitter) {
-        Object.defineProperty(this, "db", {
+    constructor(announcementService, session, eventEmitter, refreshService) {
+        Object.defineProperty(this, "announcementService", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "announcementService", {
+        Object.defineProperty(this, "session", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "session", {
+        Object.defineProperty(this, "eventEmitter", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "eventEmitter", {
+        Object.defineProperty(this, "refreshService", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.db = db;
         this.announcementService = announcementService;
         this.session = session;
         this.eventEmitter = eventEmitter;
+        this.refreshService = refreshService;
+    }
+    setRefreshService(refreshService) {
+        this.refreshService = refreshService;
     }
     /**
      * Initialize a discussion with a contact using SessionManager
@@ -78,20 +83,20 @@ export class DiscussionService {
         const log = logger.forMethod('initialize');
         try {
             const userId = this.session.userIdEncoded;
-            const existing = await this.db.getDiscussionByOwnerAndContact(userId, contact.userId);
+            const existing = await getDiscussionByOwnerAndContact(userId, contact.userId);
             if (existing?.id) {
                 return {
                     success: false,
                     error: new Error('Discussion already exists'),
                 };
             }
-            const discussionId = await this.db.discussions.add({
+            log.info(`${userId} is establishing session with contact ${contact.name}`);
+            const discussionId = await insertDiscussion({
                 ownerUserId: userId,
                 contactUserId: contact.userId,
                 weAccepted: true,
-                sendAnnouncement: null,
-                lastAnnouncementMessage: payload?.message,
                 direction: DiscussionDirection.INITIATED,
+                status: DiscussionStatus.PENDING,
                 unreadCount: 0,
                 createdAt: new Date(),
                 updatedAt: new Date(),
@@ -103,11 +108,11 @@ export class DiscussionService {
             }
             const result = await this.createSessionForContact(contact.userId, payloadBytes ?? new Uint8Array(0));
             if (!result.success) {
-                await this.db.discussions.delete(discussionId);
+                await deleteDiscussionById(discussionId);
                 return { success: false, error: result.error };
             }
             if (payload?.message) {
-                await this.db.addMessage({
+                await insertMessage({
                     ownerUserId: userId,
                     contactUserId: contact.userId,
                     content: payload.message,
@@ -116,11 +121,15 @@ export class DiscussionService {
                     status: MessageStatus.READ, // Announcement message are not like other msg. they are set as read to prevent them from being sent again if session is renewed
                     timestamp: new Date(),
                 });
+                // Store the announcement message on the discussion so the UI can display it
+                await updateDiscussionById(discussionId, {
+                    announcementMessage: payload.message,
+                });
             }
             // Emit status change event
-            const discussion = await this.db.discussions.get(discussionId);
+            const discussion = await getDiscussionById(discussionId);
             if (discussion) {
-                this.eventEmitter.emit(SdkEventType.SESSION_CREATED, discussion);
+                this.eventEmitter.emit(SdkEventType.SESSION_CREATED, toDiscussion(discussion));
             }
             return {
                 success: true,
@@ -151,7 +160,7 @@ export class DiscussionService {
                     bytes: result.data?.length ?? 0,
                 });
                 // Emit status change event
-                const updatedDiscussion = await this.db.discussions.get(discussion.id);
+                const updatedDiscussion = await getDiscussionById(discussion.id);
                 if (updatedDiscussion) {
                     this.eventEmitter.emit(SdkEventType.SESSION_ACCEPTED, updatedDiscussion.contactUserId);
                 }
@@ -177,11 +186,11 @@ export class DiscussionService {
     async createSessionForContact(contactUserId, userData) {
         const log = logger.forMethod('createSessionForContact');
         const ownerUserId = this.session.userIdEncoded;
-        const discussion = await this.db.getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
+        const discussion = await getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
         if (!discussion) {
             return { success: false, error: new Error('Discussion not found') };
         }
-        const contact = await this.db.getContactByOwnerAndUserId(ownerUserId, contactUserId);
+        const contact = await getContactByOwnerAndUser(ownerUserId, contactUserId);
         if (!contact) {
             return { success: false, error: new Error('Contact not found') };
         }
@@ -195,50 +204,41 @@ export class DiscussionService {
             return sessionResult;
         }
         const now = new Date();
-        // Wrap discussion update and queue reset in a transaction for atomicity
-        const err = await this.db.transaction('rw', this.db.discussions, this.db.messages, async () => {
-            try {
-                // add the new announcement to the discussion
-                await this.db.discussions.update(discussion.id, {
-                    weAccepted: true,
-                    sendAnnouncement: {
-                        announcement_bytes: sessionResult.data,
-                        when_to_send: now,
-                    },
-                    updatedAt: now,
-                });
-                // reset all messages in send queue to WAITING_SESSION for this contact
-                await resetSendQueue(this.db, ownerUserId, contactUserId);
-                return undefined;
-            }
-            catch (error) {
-                return new Error('Failed to update discussion: ' + error);
-            }
-        });
-        if (err) {
-            return { success: false, error: err };
+        try {
+            // add the new announcement to the discussion
+            await updateDiscussionById(discussion.id, {
+                weAccepted: true,
+                sendAnnouncement: serializeSendAnnouncement({
+                    announcement_bytes: sessionResult.data,
+                    when_to_send: now,
+                }),
+                initiationAnnouncement: sessionResult.data,
+                updatedAt: now,
+            });
+            // reset all messages in send queue to WAITING_SESSION for this contact
+            await resetSendQueueMessages(ownerUserId, contactUserId, [
+                MessageStatus.READY,
+                MessageStatus.SENT,
+            ]);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: new Error('Failed to update discussion: ' + error),
+            };
+        }
+        try {
+            /* trigger a state update to send the new announcement
+            If the stateUpdate function is already running, it will be skipped.
+            */
+            await this.refreshService?.stateUpdate();
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: new Error('Failed to trigger state update: ' + error),
+            };
         }
         return { success: true, data: sessionResult.data };
     }
 }
-/**
- * Reset the send queue for a contact.
- * All messages that are not yet delivered (i.e. READY, SENDING, SENT) are reset to WAITING_SESSION.
- * @param db - The database instance
- * @param ownerUserId - The user ID of the owner
- * @param contactUserId - The user ID of the contact
- * @returns A Promise that resolves when the send queue is reset
- */
-export async function resetSendQueue(db, ownerUserId, contactUserId) {
-    await db.messages
-        .where('[ownerUserId+contactUserId]')
-        .equals([ownerUserId, contactUserId])
-        .and(message => message.direction === MessageDirection.OUTGOING &&
-        [MessageStatus.READY, MessageStatus.SENT].includes(message.status))
-        .modify({
-        status: MessageStatus.WAITING_SESSION,
-        encryptedMessage: undefined,
-        seeker: undefined,
-        whenToSend: undefined,
-    });
-}

package/dist/services/message.d.ts

@@ -4,13 +4,16 @@
  * Handles fetching encrypted messages from the protocol and decrypting them.
  * This service works both in host app contexts and SDK/automation context.
  */
-import { type Message, type GossipDatabase } from '../db';
+import { type Message } from '../db';
+import { type MessageRow } from '../queries';
 import { IMessageProtocol } from '../api/messageProtocol';
 import { SessionModule } from '../wasm';
 import { Result } from '../utils/type';
 import { SdkConfig } from '../config/sdk';
-import { DiscussionService } from './discussion';
 import { SdkEventEmitter } from '../core/SdkEventEmitter';
+import type { RefreshService } from './refresh';
+/** Convert a SQLite row from the messages table to a Message object. */
+export declare function rowToMessage(row: MessageRow): Message;
 export interface MessageResult {
     success: boolean;
     newMessagesCount: number;
@@ -22,43 +25,29 @@ export interface SendMessageResult {
     error?: string;
 }
 export declare class MessageService {
-    private db;
     private messageProtocol;
     private session;
-    private discussionService;
     private eventEmitter;
     private config;
+    private refreshService?;
     private processingContacts;
     private isFetchingMessages;
-    constructor(db: GossipDatabase, messageProtocol: IMessageProtocol, session: SessionModule, discussionService: DiscussionService, eventEmitter: SdkEventEmitter, config?: SdkConfig);
+    constructor(messageProtocol: IMessageProtocol, session: SessionModule, eventEmitter: SdkEventEmitter, config?: SdkConfig);
+    setRefreshService(refreshService: RefreshService): void;
     fetchMessages(): Promise<MessageResult>;
+    /**
+     * Add a message to SQLite and update the corresponding discussion.
+     */
+    private addMessageAndUpdateDiscussion;
     private decryptMessages;
     private storeDecryptedMessages;
     /**
-     * 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).
      */
     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>;
     private serializeMessage;