@massalabs/gossip-sdk 0.0.2-dev.20260128094509 → 0.0.2-dev.20260128111120

package/dist/services/announcement.js

@@ -0,0 +1,491 @@
+/**
+ * Announcement Service
+ *
+ * Handles broadcasting and processing of session announcements.
+ */
+import { DiscussionStatus, DiscussionDirection, } from '../db';
+import { decodeUserId, encodeUserId } from '../utils/userId';
+import { SessionStatus, } from '../assets/generated/wasm/gossip_wasm';
+import { sessionStatusToString } from '../wasm/session';
+import { Logger } from '../utils/logs';
+import { defaultSdkConfig } from '../config/sdk';
+const logger = new Logger('AnnouncementService');
+export const EstablishSessionError = 'Session manager failed to establish outgoing session';
+export class AnnouncementService {
+    constructor(db, messageProtocol, session, events = {}, config = defaultSdkConfig) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "messageProtocol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isProcessingAnnouncements", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.db = db;
+        this.messageProtocol = messageProtocol;
+        this.session = session;
+        this.events = events;
+        this.config = config;
+    }
+    setMessageProtocol(messageProtocol) {
+        this.messageProtocol = messageProtocol;
+    }
+    async sendAnnouncement(announcement) {
+        const log = logger.forMethod('sendAnnouncement');
+        try {
+            const counter = await this.messageProtocol.sendAnnouncement(announcement);
+            log.info('broadcast successful', { counter });
+            return { success: true, counter };
+        }
+        catch (error) {
+            log.error('broadcast failed', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    async establishSession(contactPublicKeys, userData) {
+        const log = logger.forMethod('establishSession');
+        const contactUserId = encodeUserId(contactPublicKeys.derive_id());
+        // CRITICAL: await to ensure session state is persisted before sending
+        const announcement = await this.session.establishOutgoingSession(contactPublicKeys, userData);
+        if (announcement.length === 0) {
+            log.error('empty announcement returned', { contactUserId });
+            return {
+                success: false,
+                error: EstablishSessionError,
+                announcement,
+            };
+        }
+        const result = await this.sendAnnouncement(announcement);
+        if (!result.success) {
+            log.error('failed to broadcast announcement', {
+                contactUserId,
+                error: result.error,
+            });
+            return {
+                success: false,
+                error: result.error,
+                announcement,
+            };
+        }
+        log.info('announcement sent successfully', { contactUserId });
+        return { success: true, announcement };
+    }
+    async fetchAndProcessAnnouncements() {
+        const log = logger.forMethod('fetchAndProcessAnnouncements');
+        if (this.isProcessingAnnouncements) {
+            log.info('fetch already in progress, skipping');
+            return { success: true, newAnnouncementsCount: 0 };
+        }
+        const errors = [];
+        let announcements = [];
+        let fetchedCounters = [];
+        this.isProcessingAnnouncements = true;
+        try {
+            const pending = await this.db.pendingAnnouncements.toArray();
+            const successfullyProcessedPendingIds = [];
+            if (pending.length > 0) {
+                log.info(`processing ${pending.length} pending announcements from IndexedDB`);
+                // Process pending announcements one by one, tracking successes
+                let newAnnouncementsCount = 0;
+                for (const item of pending) {
+                    try {
+                        const result = await this._processIncomingAnnouncement(item.announcement);
+                        // Mark as successfully processed (even if announcement was for unknown peer)
+                        // Only keep if processing threw an error
+                        if (item.id !== undefined) {
+                            successfullyProcessedPendingIds.push(item.id);
+                        }
+                        if (result.success && result.contactUserId) {
+                            newAnnouncementsCount++;
+                            log.info(`processed pending announcement #${newAnnouncementsCount}`, {
+                                contactUserId: result.contactUserId,
+                            });
+                        }
+                        if (item.counter)
+                            fetchedCounters.push(item.counter);
+                        if (result.error)
+                            errors.push(result.error);
+                    }
+                    catch (error) {
+                        // Don't mark as processed - will be retried next time
+                        log.error('failed to process pending announcement, will retry', {
+                            id: item.id,
+                            error,
+                        });
+                        errors.push(error instanceof Error ? error.message : 'Unknown error');
+                    }
+                }
+                // Delete only successfully processed pending announcements
+                if (successfullyProcessedPendingIds.length > 0) {
+                    await this.db.pendingAnnouncements.bulkDelete(successfullyProcessedPendingIds);
+                    log.info(`deleted ${successfullyProcessedPendingIds.length} processed pending announcements`);
+                }
+                if (fetchedCounters.length > 0) {
+                    const highestCounter = fetchedCounters.reduce((a, b) => Number(a) > Number(b) ? a : b);
+                    await this.db.userProfile.update(this.session.userIdEncoded, {
+                        lastBulletinCounter: highestCounter,
+                    });
+                    log.info('updated lastBulletinCounter', { highestCounter });
+                }
+                return {
+                    success: errors.length === 0 || newAnnouncementsCount > 0,
+                    newAnnouncementsCount,
+                    error: errors.length > 0 ? errors.join(', ') : undefined,
+                };
+            }
+            // No pending - fetch from API
+            const cursor = (await this.db.userProfile.get(this.session.userIdEncoded))
+                ?.lastBulletinCounter;
+            const fetched = await this._fetchAnnouncements(cursor);
+            announcements = fetched.map(a => a.data);
+            fetchedCounters = fetched.map(a => a.counter);
+            let newAnnouncementsCount = 0;
+            for (const announcement of announcements) {
+                try {
+                    const result = await this._processIncomingAnnouncement(announcement);
+                    if (result.success && result.contactUserId) {
+                        newAnnouncementsCount++;
+                        log.info(`processed new announcement #${newAnnouncementsCount}`, {
+                            contactUserId: result.contactUserId,
+                        });
+                    }
+                    if (result.error)
+                        errors.push(result.error);
+                }
+                catch (error) {
+                    errors.push(error instanceof Error ? error.message : 'Unknown error');
+                }
+            }
+            if (fetchedCounters.length > 0) {
+                const highestCounter = fetchedCounters.reduce((a, b) => Number(a) > Number(b) ? a : b);
+                await this.db.userProfile.update(this.session.userIdEncoded, {
+                    lastBulletinCounter: highestCounter,
+                });
+                log.info('updated lastBulletinCounter', { highestCounter });
+            }
+            return {
+                success: errors.length === 0 || newAnnouncementsCount > 0,
+                newAnnouncementsCount,
+                error: errors.length > 0 ? errors.join(', ') : undefined,
+            };
+        }
+        catch (error) {
+            log.error('unexpected error during fetch/process', error);
+            return {
+                success: false,
+                newAnnouncementsCount: 0,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+        finally {
+            this.isProcessingAnnouncements = false;
+        }
+    }
+    async resendAnnouncements(failedDiscussions) {
+        const log = logger.forMethod('resendAnnouncements');
+        if (!failedDiscussions.length) {
+            log.info('no failed discussions to resend');
+            return;
+        }
+        log.info(`starting resend for ${failedDiscussions.length} failed discussions`);
+        const sentDiscussions = [];
+        const brokenDiscussions = [];
+        for (const discussion of failedDiscussions) {
+            const { ownerUserId, contactUserId } = discussion;
+            try {
+                const result = await this.sendAnnouncement(discussion.initiationAnnouncement);
+                if (result.success) {
+                    log.info('resent successfully', { ownerUserId, contactUserId });
+                    sentDiscussions.push(discussion);
+                    continue;
+                }
+                log.info('network send failed (retry)', { ownerUserId, contactUserId });
+                const ageMs = Date.now() - (discussion.updatedAt.getTime() ?? 0);
+                if (ageMs > this.config.announcements.brokenThresholdMs) {
+                    log.info(`marking as broken (too old: ${Math.round(ageMs / 60000)}min)`, {
+                        ownerUserId,
+                        contactUserId,
+                    });
+                    brokenDiscussions.push(discussion.id);
+                }
+            }
+            catch (error) {
+                log.error('exception during resend', {
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    ownerUserId,
+                    contactUserId,
+                });
+            }
+        }
+        if (sentDiscussions.length > 0 || brokenDiscussions.length > 0) {
+            await this.db.transaction('rw', this.db.discussions, async () => {
+                const now = new Date();
+                if (sentDiscussions.length > 0) {
+                    await Promise.all(sentDiscussions.map(async (discussion) => {
+                        const status = this.session.peerSessionStatus(decodeUserId(discussion.contactUserId));
+                        const statusStr = sessionStatusToString(status);
+                        if (status !== SessionStatus.Active &&
+                            status !== SessionStatus.SelfRequested) {
+                            log.info('skipping DB update - session not ready', {
+                                contactUserId: discussion.contactUserId,
+                                status: statusStr,
+                            });
+                            return;
+                        }
+                        const newStatus = status === SessionStatus.Active
+                            ? DiscussionStatus.ACTIVE
+                            : DiscussionStatus.PENDING;
+                        await this.db.discussions.update(discussion.id, {
+                            status: newStatus,
+                            updatedAt: now,
+                        });
+                        log.info('updated discussion status in DB', {
+                            contactUserId: discussion.contactUserId,
+                            newStatus,
+                        });
+                        // Emit status change event
+                        const updatedDiscussion = await this.db.discussions.get(discussion.id);
+                        if (updatedDiscussion) {
+                            this.events.onDiscussionStatusChanged?.(updatedDiscussion);
+                        }
+                    }));
+                }
+                if (brokenDiscussions.length > 0) {
+                    // Per spec: announcement failures should trigger session renewal, not BROKEN status
+                    // Clear the failed announcement and trigger renewal
+                    log.info(`${brokenDiscussions.length} announcements timed out, triggering renewal`);
+                    await Promise.all(brokenDiscussions.map(async (id) => {
+                        await this.db.discussions.update(id, {
+                            initiationAnnouncement: undefined,
+                            updatedAt: now,
+                        });
+                        // Emit renewal needed event
+                        const discussion = await this.db.discussions.get(id);
+                        if (discussion) {
+                            this.events.onSessionRenewalNeeded?.(discussion.contactUserId);
+                        }
+                    }));
+                }
+            });
+        }
+        log.info('resend completed', {
+            sent: sentDiscussions.length,
+            broken: brokenDiscussions.length,
+        });
+    }
+    async _fetchAnnouncements(cursor, limit) {
+        const fetchLimit = limit ?? this.config.announcements.fetchLimit;
+        const log = logger.forMethod('_fetchAnnouncements');
+        try {
+            const items = await this.messageProtocol.fetchAnnouncements(fetchLimit, cursor);
+            return items;
+        }
+        catch (error) {
+            log.error('network fetch failed', error);
+            return [];
+        }
+    }
+    async _generateTemporaryContactName(ownerUserId) {
+        const newRequestContacts = await this.db.contacts
+            .where('ownerUserId')
+            .equals(ownerUserId)
+            .filter(contact => contact.name.startsWith('New Request'))
+            .toArray();
+        const numbers = newRequestContacts
+            .map(contact => {
+            const match = contact.name.match(/^New Request (\d+)$/);
+            return match ? parseInt(match[1], 10) : 0;
+        })
+            .filter(number => number > 0);
+        const next = numbers.length ? Math.max(...numbers) + 1 : 1;
+        return `New Request ${next}`;
+    }
+    async _processIncomingAnnouncement(announcementData) {
+        const log = logger.forMethod('_processIncomingAnnouncement');
+        const result = await this.session.feedIncomingAnnouncement(announcementData);
+        if (!result) {
+            return { success: true };
+        }
+        log.info('announcement intended for us — decrypting');
+        let rawMessage;
+        if (result.user_data?.length > 0) {
+            try {
+                rawMessage = new TextDecoder().decode(result.user_data);
+            }
+            catch (error) {
+                log.error('failed to decode user data', error);
+            }
+        }
+        // Parse announcement message format:
+        // - JSON format: {"u":"username","m":"message"} (current)
+        // - Legacy colon format: "username:message" (backwards compat)
+        // - Plain text: "message" (oldest format)
+        // The username is used as the initial contact name if present.
+        // TODO: Remove legacy colon and plain text format support once all clients are updated
+        let extractedUsername;
+        let announcementMessage;
+        if (rawMessage) {
+            // Try JSON format first (starts with '{')
+            if (rawMessage.startsWith('{')) {
+                try {
+                    const parsed = JSON.parse(rawMessage);
+                    extractedUsername = parsed.u?.trim() || undefined;
+                    announcementMessage = parsed.m?.trim() || undefined;
+                }
+                catch {
+                    // Invalid JSON, treat as plain text
+                    announcementMessage = rawMessage;
+                }
+            }
+            else {
+                // Legacy format: check for colon separator
+                const colonIndex = rawMessage.indexOf(':');
+                if (colonIndex !== -1) {
+                    extractedUsername =
+                        rawMessage.slice(0, colonIndex).trim() || undefined;
+                    announcementMessage =
+                        rawMessage.slice(colonIndex + 1).trim() || undefined;
+                }
+                else {
+                    // Plain text (oldest format)
+                    announcementMessage = rawMessage;
+                }
+            }
+        }
+        const announcerPkeys = result.announcer_public_keys;
+        const contactUserIdRaw = announcerPkeys.derive_id();
+        const contactUserId = encodeUserId(contactUserIdRaw);
+        const sessionStatus = this.session.peerSessionStatus(contactUserIdRaw);
+        // Log clearly for debugging
+        console.log(`[Announcement] Received from ${contactUserId.slice(0, 12)}... -> session status: ${sessionStatusToString(sessionStatus)}`);
+        log.info('session updated', {
+            contactUserId,
+            status: sessionStatusToString(sessionStatus),
+        });
+        let contact = await this.db.getContactByOwnerAndUserId(this.session.userIdEncoded, contactUserId);
+        const isNewContact = !contact;
+        if (isNewContact) {
+            // Use extracted username if present, otherwise generate temporary name
+            const name = extractedUsername ||
+                (await this._generateTemporaryContactName(this.session.userIdEncoded));
+            await this.db.contacts.add({
+                ownerUserId: this.session.userIdEncoded,
+                userId: contactUserId,
+                name,
+                publicKeys: announcerPkeys.to_bytes(),
+                avatar: undefined,
+                isOnline: false,
+                lastSeen: new Date(),
+                createdAt: new Date(),
+            });
+            contact = await this.db.getContactByOwnerAndUserId(this.session.userIdEncoded, contactUserId);
+            log.info('created new contact', { contactUserId, name });
+        }
+        if (!contact) {
+            log.error('contact lookup failed after creation');
+            throw new Error('Could not find or create contact');
+        }
+        const { discussionId } = await this._handleReceivedDiscussion(this.session.userIdEncoded, contactUserId, announcementMessage);
+        // Emit event for new discussion request
+        if (this.events.onDiscussionRequest) {
+            const discussion = await this.db.discussions.get(discussionId);
+            if (discussion && contact) {
+                this.events.onDiscussionRequest(discussion, contact);
+            }
+        }
+        // Auto-accept ONLY for existing contacts (session recovery scenario).
+        // For NEW contacts, the user must manually accept the discussion request.
+        // This completes the handshake by sending our announcement back.
+        if (sessionStatus === SessionStatus.PeerRequested && !isNewContact) {
+            log.info('session is PeerRequested for existing contact, triggering auto-accept', { contactUserId });
+            this.events.onSessionAcceptNeeded?.(contactUserId);
+        }
+        else if (sessionStatus === SessionStatus.PeerRequested && isNewContact) {
+            log.info('session is PeerRequested for NEW contact, waiting for manual accept', { contactUserId });
+        }
+        // When session becomes Active after peer accepts our announcement,
+        // trigger processing of WAITING_SESSION messages.
+        // This happens when we initiated (SelfRequested) and peer accepted.
+        if (sessionStatus === SessionStatus.Active) {
+            log.info('session is now Active, triggering WAITING_SESSION message processing', { contactUserId });
+            this.events.onSessionBecameActive?.(contactUserId);
+        }
+        return {
+            success: true,
+            discussionId,
+            contactUserId,
+        };
+    }
+    async _handleReceivedDiscussion(ownerUserId, contactUserId, announcementMessage) {
+        const log = logger.forMethod('handleReceivedDiscussion');
+        const discussionId = await this.db.transaction('rw', this.db.discussions, async () => {
+            const existing = await this.db.getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
+            if (existing) {
+                const updateData = { updatedAt: new Date() };
+                if (announcementMessage)
+                    updateData.announcementMessage = announcementMessage;
+                if (existing.status === DiscussionStatus.PENDING &&
+                    existing.direction === DiscussionDirection.INITIATED) {
+                    updateData.status = DiscussionStatus.ACTIVE;
+                    log.info('transitioning to ACTIVE', {
+                        discussionId: existing.id,
+                        contactUserId,
+                    });
+                }
+                else {
+                    log.info('updating existing discussion', {
+                        discussionId: existing.id,
+                        status: existing.status,
+                        direction: existing.direction,
+                    });
+                }
+                await this.db.discussions.update(existing.id, updateData);
+                return existing.id;
+            }
+            log.info('creating new RECEIVED/PENDING discussion', { contactUserId });
+            return await this.db.discussions.add({
+                ownerUserId,
+                contactUserId,
+                direction: DiscussionDirection.RECEIVED,
+                status: DiscussionStatus.PENDING,
+                nextSeeker: undefined,
+                announcementMessage,
+                unreadCount: 0,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            });
+        });
+        return { discussionId };
+    }
+}

package/dist/services/auth.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Auth Service
+ *
+ * Handles storing and retrieving public keys by userId hash via the auth API.
+ */
+import { UserPublicKeys } from '../assets/generated/wasm/gossip_wasm';
+import { IMessageProtocol } from '../api/messageProtocol/types';
+import { type GossipDatabase } from '../db';
+export type PublicKeyResult = {
+    publicKey: UserPublicKeys;
+    error?: never;
+} | {
+    publicKey?: never;
+    error: string;
+};
+export declare class AuthService {
+    private db;
+    messageProtocol: IMessageProtocol;
+    constructor(db: GossipDatabase, messageProtocol: IMessageProtocol);
+    /**
+     * Fetch public key by userId
+     * @param userId - Bech32-encoded userId (e.g., "gossip1...")
+     */
+    fetchPublicKeyByUserId(userId: string): Promise<PublicKeyResult>;
+    /**
+     * Ensure public key is published (check first, then publish if needed)
+     * @param publicKeys - UserPublicKeys instance
+     * @param userId - Bech32-encoded userId (e.g., "gossip1...")
+     */
+    ensurePublicKeyPublished(publicKeys: UserPublicKeys, userId: string): Promise<void>;
+}
+export declare const PUBLIC_KEY_NOT_FOUND_ERROR = "Public key not found";
+export declare const PUBLIC_KEY_NOT_FOUND_MESSAGE = "Contact public key not found. It may not be published yet.";
+export declare const FAILED_TO_FETCH_ERROR = "Failed to fetch";
+export declare const FAILED_TO_FETCH_MESSAGE = "Failed to retrieve contact public key. Check your internet connection or try again later.";
+export declare const FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR = "Failed to retrieve contact public key";
+export declare function getPublicKeyErrorMessage(error: unknown): string;

package/dist/services/auth.js

@@ -0,0 +1,76 @@
+/**
+ * Auth Service
+ *
+ * Handles storing and retrieving public keys by userId hash via the auth API.
+ */
+import { UserPublicKeys } from '../assets/generated/wasm/gossip_wasm';
+import { decodeUserId } from '../utils/userId';
+import { encodeToBase64, decodeFromBase64 } from '../utils/base64';
+export class AuthService {
+    constructor(db, messageProtocol) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "messageProtocol", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: messageProtocol
+        });
+    }
+    /**
+     * Fetch public key by userId
+     * @param userId - Bech32-encoded userId (e.g., "gossip1...")
+     */
+    async fetchPublicKeyByUserId(userId) {
+        try {
+            const base64PublicKey = await this.messageProtocol.fetchPublicKeyByUserId(decodeUserId(userId));
+            return {
+                publicKey: UserPublicKeys.from_bytes(decodeFromBase64(base64PublicKey)),
+            };
+        }
+        catch (err) {
+            return {
+                error: getPublicKeyErrorMessage(err),
+            };
+        }
+    }
+    /**
+     * Ensure public key is published (check first, then publish if needed)
+     * @param publicKeys - UserPublicKeys instance
+     * @param userId - Bech32-encoded userId (e.g., "gossip1...")
+     */
+    async ensurePublicKeyPublished(publicKeys, userId) {
+        const profile = await this.db.userProfile.get(userId);
+        if (!profile)
+            throw new Error('User profile not found');
+        const lastPush = profile.lastPublicKeyPush;
+        if (lastPush && !moreThanOneWeekAgo(lastPush)) {
+            return;
+        }
+        await this.messageProtocol.postPublicKey(encodeToBase64(publicKeys.to_bytes()));
+        await this.db.userProfile.update(userId, { lastPublicKeyPush: new Date() });
+    }
+}
+const ONE_WEEK_IN_MILLIS = 7 * 24 * 60 * 60 * 1000;
+function moreThanOneWeekAgo(date) {
+    return Date.now() - date.getTime() >= ONE_WEEK_IN_MILLIS;
+}
+export const PUBLIC_KEY_NOT_FOUND_ERROR = 'Public key not found';
+export const PUBLIC_KEY_NOT_FOUND_MESSAGE = 'Contact public key not found. It may not be published yet.';
+export const FAILED_TO_FETCH_ERROR = 'Failed to fetch';
+export const FAILED_TO_FETCH_MESSAGE = 'Failed to retrieve contact public key. Check your internet connection or try again later.';
+export const FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR = 'Failed to retrieve contact public key';
+export function getPublicKeyErrorMessage(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes(PUBLIC_KEY_NOT_FOUND_ERROR)) {
+        return PUBLIC_KEY_NOT_FOUND_MESSAGE;
+    }
+    if (errorMessage.includes(FAILED_TO_FETCH_ERROR)) {
+        return FAILED_TO_FETCH_MESSAGE;
+    }
+    return `${FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR}. ${errorMessage}`;
+}

package/dist/services/discussion.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Discussion Service
+ *
+ * Class-based service for initializing, accepting, and managing discussions.
+ */
+import { type Discussion, type Contact, type GossipDatabase } from '../db';
+import { AnnouncementService } from './announcement';
+import { SessionModule } from '../wasm/session';
+import { GossipSdkEvents } from '../types/events';
+/**
+ * Service for managing discussions between users.
+ *
+ * @example
+ * ```typescript
+ * const discussionService = new DiscussionService(db, announcementService, session);
+ *
+ * // Initialize a new discussion
+ * const result = await discussionService.initialize(contact, 'Hello!');
+ *
+ * // Accept a discussion request
+ * await discussionService.accept(discussion);
+ *
+ * // Renew a broken discussion
+ * await discussionService.renew(contactUserId);
+ * ```
+ */
+export declare class DiscussionService {
+    private db;
+    private announcementService;
+    private session;
+    private events;
+    constructor(db: GossipDatabase, announcementService: AnnouncementService, session: SessionModule, events?: GossipSdkEvents);
+    /**
+     * Initialize a discussion with a contact using SessionManager
+     * @param contact - The contact to start a discussion with
+     * @param message - Optional message to include in the announcement
+     * @returns The discussion ID and the created announcement
+     */
+    initialize(contact: Contact, message?: string): Promise<{
+        discussionId: number;
+        announcement: Uint8Array;
+    }>;
+    /**
+     * Accept a discussion request from a contact using SessionManager
+     * @param discussion - The discussion to accept
+     */
+    accept(discussion: Discussion): Promise<void>;
+    /**
+     * Renew a discussion by resetting sent outgoing messages and sending a new announcement.
+     * @param contactUserId - The user ID of the contact whose discussion should be renewed.
+     */
+    renew(contactUserId: string): Promise<void>;
+    /**
+     * Check if new messages can be sent to session manager for encryption.
+     * Returns false if the discussion is broken or if there are failed messages
+     * that have not been encrypted.
+     *
+     * @param ownerUserId - The owner user ID
+     * @param contactUserId - The contact user ID
+     * @returns true if discussion is in stable state for sending messages
+     */
+    isStableState(ownerUserId: string, contactUserId: string): Promise<boolean>;
+}