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

package/dist/schema.js

@@ -0,0 +1,164 @@
+/**
+ * Drizzle ORM schema for the Gossip SDK database.
+ *
+ * IMPORTANT: The raw DDL in sqlite.ts must stay in sync with these definitions.
+ * When adding/removing/renaming columns, tables, or indexes, update BOTH files.
+ *
+ * Type mappings from SQLite:
+ *   Date       → integer (epoch milliseconds)
+ *   boolean    → integer (0/1)
+ *   Uint8Array → blob (wa-sqlite handles natively)
+ *   JSON       → text (JSON.stringify/parse in service layer)
+ */
+import { sqliteTable, text, integer, index, uniqueIndex, customType, } from 'drizzle-orm/sqlite-core';
+// Custom blob type — wa-sqlite returns Uint8Array natively for BLOB columns.
+// Drizzle's built-in blob mode converts to/from hex strings, which breaks
+// with wa-sqlite's direct Uint8Array handling. This custom type passes through.
+const bytes = customType({
+    dataType() {
+        return 'blob';
+    },
+    fromDriver(value) {
+        return value;
+    },
+    toDriver(value) {
+        return value;
+    },
+});
+// ---------------------------------------------------------------------------
+// contacts
+// ---------------------------------------------------------------------------
+export const contacts = sqliteTable('contacts', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    ownerUserId: text('ownerUserId').notNull(),
+    userId: text('userId').notNull(),
+    name: text('name').notNull(),
+    avatar: text('avatar'),
+    publicKeys: bytes('publicKeys').notNull(),
+    isOnline: integer('isOnline', { mode: 'boolean' }).notNull(),
+    lastSeen: integer('lastSeen', { mode: 'timestamp_ms' }).notNull(),
+    createdAt: integer('createdAt', { mode: 'timestamp_ms' }).notNull(),
+}, table => [
+    index('contacts_owner_user_idx').on(table.ownerUserId, table.userId),
+    index('contacts_owner_name_idx').on(table.ownerUserId, table.name),
+]);
+// ---------------------------------------------------------------------------
+// messages
+// ---------------------------------------------------------------------------
+export const messages = sqliteTable('messages', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    ownerUserId: text('ownerUserId').notNull(),
+    contactUserId: text('contactUserId').notNull(),
+    messageId: bytes('messageId'), // 12-byte random ID for deduplication
+    content: text('content').notNull(),
+    serializedContent: bytes('serializedContent'),
+    type: text('type').$type().notNull(),
+    direction: text('direction').$type().notNull(),
+    status: text('status').$type().notNull(),
+    timestamp: integer('timestamp', { mode: 'timestamp_ms' }).notNull(),
+    metadata: text('metadata'), // JSON — service layer handles stringify/parse
+    seeker: bytes('seeker'),
+    replyTo: text('replyTo'), // JSON — contains Uint8Array fields (base64 encoded)
+    forwardOf: text('forwardOf'), // JSON — contains Uint8Array fields (base64 encoded)
+    encryptedMessage: bytes('encryptedMessage'),
+    whenToSend: integer('whenToSend', { mode: 'timestamp_ms' }),
+}, table => [
+    index('messages_owner_contact_idx').on(table.ownerUserId, table.contactUserId),
+    index('messages_owner_status_idx').on(table.ownerUserId, table.status),
+    index('messages_owner_contact_status_idx').on(table.ownerUserId, table.contactUserId, table.status),
+    index('messages_owner_seeker_idx').on(table.ownerUserId, table.seeker),
+    index('messages_owner_contact_dir_idx').on(table.ownerUserId, table.contactUserId, table.direction),
+    index('messages_owner_dir_status_idx').on(table.ownerUserId, table.direction, table.status),
+    index('messages_timestamp_idx').on(table.timestamp),
+]);
+// ---------------------------------------------------------------------------
+// userProfile
+// ---------------------------------------------------------------------------
+export const userProfile = sqliteTable('userProfile', {
+    userId: text('userId').primaryKey(),
+    username: text('username').notNull(),
+    avatar: text('avatar'),
+    bio: text('bio'),
+    status: text('status').notNull(),
+    lastSeen: integer('lastSeen', { mode: 'timestamp_ms' }).notNull(),
+    createdAt: integer('createdAt', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updatedAt', { mode: 'timestamp_ms' }).notNull(),
+    lastPublicKeyPush: integer('lastPublicKeyPush', {
+        mode: 'timestamp_ms',
+    }),
+    security: text('security').notNull(), // JSON — contains Uint8Array fields (base64 encoded)
+    session: bytes('session').notNull(),
+}, table => [
+    index('userProfile_username_idx').on(table.username),
+    index('userProfile_status_idx').on(table.status),
+]);
+// ---------------------------------------------------------------------------
+// discussions
+// ---------------------------------------------------------------------------
+export const discussions = sqliteTable('discussions', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    ownerUserId: text('ownerUserId').notNull(),
+    contactUserId: text('contactUserId').notNull(),
+    weAccepted: integer('weAccepted', { mode: 'boolean' })
+        .notNull()
+        .default(false),
+    sendAnnouncement: text('sendAnnouncement'), // JSON — nullable
+    direction: text('direction').$type().notNull(),
+    status: text('status').$type().notNull(),
+    nextSeeker: bytes('nextSeeker'),
+    initiationAnnouncement: bytes('initiationAnnouncement'),
+    announcementMessage: text('announcementMessage'),
+    lastSyncTimestamp: integer('lastSyncTimestamp', {
+        mode: 'timestamp_ms',
+    }),
+    customName: text('customName'),
+    lastMessageId: integer('lastMessageId'),
+    lastMessageContent: text('lastMessageContent'),
+    lastMessageTimestamp: integer('lastMessageTimestamp', {
+        mode: 'timestamp_ms',
+    }),
+    unreadCount: integer('unreadCount').notNull().default(0),
+    createdAt: integer('createdAt', { mode: 'timestamp_ms' }).notNull(),
+    updatedAt: integer('updatedAt', { mode: 'timestamp_ms' }).notNull(),
+}, table => [
+    uniqueIndex('discussions_owner_contact_idx').on(table.ownerUserId, table.contactUserId),
+    index('discussions_owner_status_idx').on(table.ownerUserId, table.status),
+]);
+// ---------------------------------------------------------------------------
+// pendingEncryptedMessages
+// ---------------------------------------------------------------------------
+export const pendingEncryptedMessages = sqliteTable('pendingEncryptedMessages', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    seeker: bytes('seeker').notNull(),
+    ciphertext: bytes('ciphertext').notNull(),
+    fetchedAt: integer('fetchedAt', { mode: 'timestamp_ms' }).notNull(),
+}, table => [
+    index('pending_encrypted_seeker_idx').on(table.seeker),
+    index('pending_encrypted_fetchedAt_idx').on(table.fetchedAt),
+]);
+// ---------------------------------------------------------------------------
+// pendingAnnouncements
+// ---------------------------------------------------------------------------
+export const pendingAnnouncements = sqliteTable('pendingAnnouncements', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    announcement: bytes('announcement').notNull(),
+    fetchedAt: integer('fetchedAt', { mode: 'timestamp_ms' }).notNull(),
+    counter: text('counter'),
+}, table => [
+    uniqueIndex('pending_announcements_announcement_idx').on(table.announcement),
+    index('pending_announcements_fetchedAt_idx').on(table.fetchedAt),
+]);
+// ---------------------------------------------------------------------------
+// activeSeekers
+// ---------------------------------------------------------------------------
+export const activeSeekers = sqliteTable('activeSeekers', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    seeker: bytes('seeker').notNull(),
+}, table => [index('active_seekers_seeker_idx').on(table.seeker)]);
+// ---------------------------------------------------------------------------
+// announcementCursors
+// ---------------------------------------------------------------------------
+export const announcementCursors = sqliteTable('announcementCursors', {
+    userId: text('userId').primaryKey(),
+    counter: text('counter').notNull(),
+});

package/dist/services/announcement.d.ts

@@ -3,13 +3,14 @@
  *
  * Handles broadcasting and processing of session announcements.
  */
-import { type Discussion, type GossipDatabase } from '../db';
+import { type Discussion } from '../db';
 import { IMessageProtocol } from '../api/messageProtocol';
 import { UserPublicKeys } from '../wasm/bindings';
 import { SessionModule } from '../wasm/session';
 import { SdkConfig } from '../config/sdk';
 import { Result } from '../utils/type';
 import { SdkEventEmitter } from '../core/SdkEventEmitter';
+import type { RefreshService } from './refresh';
 export interface AnnouncementReceptionResult {
     success: boolean;
     newAnnouncementsCount: number;
@@ -17,13 +18,14 @@ export interface AnnouncementReceptionResult {
 }
 export declare const EstablishSessionError = "Session manager failed to establish outgoing session";
 export declare class AnnouncementService {
-    private db;
     private messageProtocol;
     private session;
     private isProcessingAnnouncements;
     private eventEmitter;
     private config;
-    constructor(db: GossipDatabase, messageProtocol: IMessageProtocol, session: SessionModule, eventEmitter: SdkEventEmitter, config?: SdkConfig);
+    private refreshService?;
+    constructor(messageProtocol: IMessageProtocol, session: SessionModule, eventEmitter: SdkEventEmitter, config?: SdkConfig);
+    setRefreshService(refreshService: RefreshService): void;
     setMessageProtocol(messageProtocol: IMessageProtocol): void;
     sendAnnouncement(announcement: Uint8Array): Promise<{
         success: boolean;
@@ -34,15 +36,14 @@ export declare class AnnouncementService {
     processOutgoingAnnouncements(discussions: Discussion[]): Promise<void>;
     fetchAndProcessAnnouncements(): Promise<AnnouncementReceptionResult>;
     /**
-     * Persist lastBulletinCounter for the current user.
-     * Only updates an existing profile row — never creates a partial one,
-     * since a row without `security`/`session` would crash downstream code.
+     * Persist the bulletin polling cursor for the current user.
+     * Stored in a dedicated announcementCursors table (not userProfile).
      */
     private _upsertLastBulletinCounter;
     /**
      * Fetch the latest bulletin counter from the API and persist it so that
      * historical announcements (undecryptable by a new account) are skipped.
-     * No-op if a counter already exists or if the profile hasn't been created yet.
+     * No-op if a counter already exists.
      */
     skipHistoricalAnnouncements(): Promise<void>;
     private _fetchAnnouncements;

package/dist/services/announcement.js

@@ -3,25 +3,20 @@
  *
  * Handles broadcasting and processing of session announcements.
  */
-import { DiscussionDirection, MessageDirection, MessageStatus, MessageType, } from '../db';
+import { DiscussionDirection, DiscussionStatus, MessageDirection, MessageStatus, MessageType, serializeSendAnnouncement, } from '../db';
+import { toDiscussion } from '../utils/discussions';
 import { decodeUserId, encodeUserId } from '../utils/userId';
 import { SessionStatus } from '../wasm/bindings';
 import { sessionStatusToString } from '../wasm/session';
 import { Logger } from '../utils/logs';
 import { defaultSdkConfig } from '../config/sdk';
 import { decodeAnnouncementPayload } from '../utils/announcementPayload';
-import { resetSendQueue } from './discussion';
 import { SdkEventType } from '../core/SdkEventEmitter';
+import { getContactByOwnerAndUser, insertContact, getContactNamesByPrefix, getDiscussionByOwnerAndContact, getDiscussionById, insertDiscussion, updateDiscussionById, insertMessage, getAnnouncementMessagesByContact, resetSendQueueMessages, getAllPendingAnnouncements, deletePendingAnnouncementsByIds, getAnnouncementCursor, upsertAnnouncementCursor, } from '../queries';
 const logger = new Logger('AnnouncementService');
 export const EstablishSessionError = 'Session manager failed to establish outgoing session';
 export class AnnouncementService {
-    constructor(db, messageProtocol, session, 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,
@@ -52,12 +47,20 @@ export class AnnouncementService {
             writable: true,
             value: void 0
         });
-        this.db = db;
+        Object.defineProperty(this, "refreshService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.messageProtocol = messageProtocol;
         this.session = session;
         this.eventEmitter = eventEmitter;
         this.config = config;
     }
+    setRefreshService(refreshService) {
+        this.refreshService = refreshService;
+    }
     setMessageProtocol(messageProtocol) {
         this.messageProtocol = messageProtocol;
     }
@@ -100,7 +103,7 @@ export class AnnouncementService {
         for (const discussion of discussions) {
             if (!discussion.id)
                 continue;
-            // ensure the announcement is not null
+            // sendAnnouncement is deserialized by toDiscussion() before reaching here
             if (discussion.sendAnnouncement === null)
                 continue;
             const { announcement_bytes, when_to_send } = discussion.sendAnnouncement;
@@ -109,7 +112,7 @@ export class AnnouncementService {
                     discussionId: discussion.id,
                     contactUserId: discussion.contactUserId,
                 });
-                await this.db.discussions.update(discussion.id, {
+                await updateDiscussionById(discussion.id, {
                     sendAnnouncement: null,
                     updatedAt: new Date(),
                 });
@@ -126,28 +129,26 @@ export class AnnouncementService {
             }
             // Send the announcement and handle updates after transaction
             const result = await this.sendAnnouncement(announcement_bytes);
-            // update discussion state after sending, inside a new transaction
-            await this.db.transaction('rw', [this.db.discussions], async () => {
-                const latest = await this.db.discussions.get(discussion.id);
-                if (!latest || latest.sendAnnouncement === null) {
-                    return;
-                }
-                if (result.success) {
-                    await this.db.discussions.update(discussion.id, {
-                        sendAnnouncement: null,
-                        updatedAt: new Date(),
-                    });
-                }
-                else {
-                    await this.db.discussions.update(discussion.id, {
-                        sendAnnouncement: {
-                            announcement_bytes,
-                            when_to_send: new Date(Date.now() + this.config.announcements.retryDelayMs),
-                        },
-                        updatedAt: new Date(),
-                    });
-                }
-            });
+            // update discussion state after sending
+            const latest = await getDiscussionById(discussion.id);
+            if (!latest || latest.sendAnnouncement === null) {
+                continue;
+            }
+            if (result.success) {
+                await updateDiscussionById(discussion.id, {
+                    sendAnnouncement: null,
+                    updatedAt: new Date(),
+                });
+            }
+            else {
+                await updateDiscussionById(discussion.id, {
+                    sendAnnouncement: serializeSendAnnouncement({
+                        announcement_bytes,
+                        when_to_send: new Date(Date.now() + this.config.announcements.retryDelayMs),
+                    }),
+                    updatedAt: new Date(),
+                });
+            }
         }
     }
     async fetchAndProcessAnnouncements() {
@@ -161,10 +162,10 @@ export class AnnouncementService {
         let fetchedCounters = [];
         this.isProcessingAnnouncements = true;
         try {
-            const pending = await this.db.pendingAnnouncements.toArray();
+            const pending = await getAllPendingAnnouncements();
             const successfullyProcessedPendingIds = [];
             if (pending.length > 0) {
-                log.info(`processing ${pending.length} pending announcements from IndexedDB`);
+                log.info(`processing ${pending.length} pending announcements from SQLite`);
                 // Process pending announcements one by one, tracking successes
                 let newAnnouncementsCount = 0;
                 for (const item of pending) {
@@ -197,7 +198,7 @@ export class AnnouncementService {
                 }
                 // Delete only successfully processed pending announcements
                 if (successfullyProcessedPendingIds.length > 0) {
-                    await this.db.pendingAnnouncements.bulkDelete(successfullyProcessedPendingIds);
+                    await deletePendingAnnouncementsByIds(successfullyProcessedPendingIds);
                     log.info(`deleted ${successfullyProcessedPendingIds.length} processed pending announcements`);
                 }
                 if (fetchedCounters.length > 0) {
@@ -212,8 +213,7 @@ export class AnnouncementService {
                 };
             }
             // No pending - fetch from API
-            const cursor = (await this.db.userProfile.get(this.session.userIdEncoded))
-                ?.lastBulletinCounter;
+            const cursor = await getAnnouncementCursor(this.session.userIdEncoded);
             // fetch from node all announcements since the last retrieved announcement
             const fetched = await this._fetchAnnouncements(cursor);
             announcements = fetched.map(a => a.data);
@@ -266,37 +266,21 @@ export class AnnouncementService {
         }
     }
     /**
-     * Persist lastBulletinCounter for the current user.
-     * Only updates an existing profile row — never creates a partial one,
-     * since a row without `security`/`session` would crash downstream code.
+     * Persist the bulletin polling cursor for the current user.
+     * Stored in a dedicated announcementCursors table (not userProfile).
      */
     async _upsertLastBulletinCounter(nextCounter) {
-        const userId = this.session.userIdEncoded;
-        const existing = await this.db.userProfile.get(userId);
-        if (!existing) {
-            logger
-                .forMethod('_upsertLastBulletinCounter')
-                .debug('no profile row yet — skipping counter write');
-            return;
-        }
-        await this.db.userProfile.update(userId, {
-            lastBulletinCounter: nextCounter,
-            updatedAt: new Date(),
-        });
+        await upsertAnnouncementCursor(this.session.userIdEncoded, nextCounter);
     }
     /**
      * Fetch the latest bulletin counter from the API and persist it so that
      * historical announcements (undecryptable by a new account) are skipped.
-     * No-op if a counter already exists or if the profile hasn't been created yet.
+     * No-op if a counter already exists.
      */
     async skipHistoricalAnnouncements() {
         const log = logger.forMethod('skipHistoricalAnnouncements');
-        const existing = await this.db.userProfile.get(this.session.userIdEncoded);
-        if (!existing) {
-            log.debug('no profile row yet — skipping');
-            return;
-        }
-        if (existing.lastBulletinCounter !== undefined)
+        const existing = await getAnnouncementCursor(this.session.userIdEncoded);
+        if (existing !== undefined)
             return;
         try {
             const counter = await this.messageProtocol.fetchBulletinCounter();
@@ -321,11 +305,7 @@ export class AnnouncementService {
         }
     }
     async _generateTemporaryContactName(ownerUserId) {
-        const newRequestContacts = await this.db.contacts
-            .where('ownerUserId')
-            .equals(ownerUserId)
-            .filter(contact => contact.name.startsWith('New Request'))
-            .toArray();
+        const newRequestContacts = await getContactNamesByPrefix(ownerUserId, 'New Request');
         const numbers = newRequestContacts
             .map(contact => {
             const match = contact.name.match(/^New Request (\d+)$/);
@@ -349,29 +329,26 @@ export class AnnouncementService {
         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', {
+        log.info('announcement received', {
             contactUserId,
             status: sessionStatusToString(sessionStatus),
         });
-        let contact = await this.db.getContactByOwnerAndUserId(this.session.userIdEncoded, contactUserId);
+        let contact = await getContactByOwnerAndUser(this.session.userIdEncoded, contactUserId);
         const isNewContact = !contact;
         if (isNewContact) {
             // Use extracted username if present, otherwise generate temporary name
             const name = username ||
                 (await this._generateTemporaryContactName(this.session.userIdEncoded));
-            await this.db.contacts.add({
+            await insertContact({
                 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);
+            contact = await getContactByOwnerAndUser(this.session.userIdEncoded, contactUserId);
             log.info('created new contact', { contactUserId, name });
         }
         if (!contact) {
@@ -384,17 +361,13 @@ export class AnnouncementService {
             const timestamp = new Date(result.timestamp);
             const windowStart = new Date(timestamp.getTime() - 1000);
             const windowEnd = new Date(timestamp.getTime() + 1000);
-            const existing = await this.db.messages
-                .where('[ownerUserId+contactUserId]')
-                .equals([this.session.userIdEncoded, contactUserId])
-                .and(msg => msg.direction === MessageDirection.INCOMING &&
-                msg.type === MessageType.ANNOUNCEMENT &&
-                msg.content === message &&
+            const existing = await getAnnouncementMessagesByContact(this.session.userIdEncoded, contactUserId);
+            // Filter in JS for content match and timestamp window (SQLite timestamp_ms comparison)
+            const duplicate = existing.find(msg => msg.content === message &&
                 msg.timestamp >= windowStart &&
-                msg.timestamp <= windowEnd)
-                .first();
-            if (!existing) {
-                await this.db.addMessage({
+                msg.timestamp <= windowEnd);
+            if (!duplicate) {
+                await insertMessage({
                     ownerUserId: this.session.userIdEncoded,
                     contactUserId,
                     content: message,
@@ -405,6 +378,7 @@ export class AnnouncementService {
                 });
             }
         }
+        await this.refreshService?.stateUpdate();
         return {
             success: true,
             discussionId,
@@ -413,47 +387,47 @@ export class AnnouncementService {
     }
     async _handleReceivedDiscussion(ownerUserId, contactUserId, message) {
         const log = logger.forMethod('handleReceivedDiscussion');
-        const discussionId = await this.db.transaction('rw', this.db.discussions, this.db.messages, this.db.contacts, async () => {
-            const existing = await this.db.getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
-            if (existing) {
-                const updateData = { updatedAt: new Date() };
-                if (message)
-                    updateData.lastAnnouncementMessage = message;
-                log.info('updating existing discussion', {
-                    discussionId: existing.id,
-                    contactUserId,
-                });
-                // Group update and queue reset in the same transaction to ensure atomicity
-                await this.db.discussions.update(existing.id, updateData);
-                // reset all messages in send queue to WAITING_SESSION for this contact
-                await resetSendQueue(this.db, this.session.userIdEncoded, contactUserId);
-                const newDiscussion = await this.db.discussions.get(existing.id);
-                const contact = await this.db.getContactByOwnerAndUserId(ownerUserId, contactUserId);
-                if (newDiscussion &&
-                    contact &&
-                    this.session.peerSessionStatus(decodeUserId(contactUserId)) ===
-                        SessionStatus.PeerRequested) {
-                    this.eventEmitter.emit(SdkEventType.SESSION_REQUESTED, newDiscussion, contact);
-                }
-                return existing.id;
-            }
-            log.info('creating new discussion', { contactUserId });
-            return await this.db.discussions.add({
-                ownerUserId,
+        const existing = await getDiscussionByOwnerAndContact(ownerUserId, contactUserId);
+        if (existing) {
+            const updateData = { updatedAt: new Date() };
+            if (message)
+                updateData.announcementMessage = message;
+            log.info('updating existing discussion', {
+                discussionId: existing.id,
                 contactUserId,
-                weAccepted: false,
-                sendAnnouncement: null,
-                direction: DiscussionDirection.RECEIVED,
-                lastAnnouncementMessage: message,
-                unreadCount: 0,
-                createdAt: new Date(),
-                updatedAt: new Date(),
             });
+            await updateDiscussionById(existing.id, updateData);
+            // reset pending outgoing messages to WAITING_SESSION for this contact
+            // Only reset READY and SENT — DELIVERED messages should not be resent.
+            await resetSendQueueMessages(this.session.userIdEncoded, contactUserId, [
+                MessageStatus.READY,
+                MessageStatus.SENT,
+            ]);
+            const newDiscussion = await getDiscussionById(existing.id);
+            const contactRow = await getContactByOwnerAndUser(ownerUserId, contactUserId);
+            if (newDiscussion &&
+                contactRow &&
+                this.session.peerSessionStatus(decodeUserId(contactUserId)) ===
+                    SessionStatus.PeerRequested) {
+                this.eventEmitter.emit(SdkEventType.SESSION_REQUESTED, toDiscussion(newDiscussion), contactRow);
+            }
+            return { discussionId: existing.id };
+        }
+        log.info('creating new discussion', { contactUserId });
+        const discussionId = await insertDiscussion({
+            ownerUserId,
+            contactUserId,
+            direction: DiscussionDirection.RECEIVED,
+            status: DiscussionStatus.PENDING,
+            announcementMessage: message,
+            unreadCount: 0,
+            createdAt: new Date(),
+            updatedAt: new Date(),
         });
-        const discussion = await this.db.discussions.get(discussionId);
-        const contact = await this.db.getContactByOwnerAndUserId(ownerUserId, contactUserId);
-        if (discussion && contact) {
-            this.eventEmitter.emit(SdkEventType.SESSION_REQUESTED, discussion, contact);
+        const discussion = await getDiscussionById(discussionId);
+        const contactRow = await getContactByOwnerAndUser(ownerUserId, contactUserId);
+        if (discussion && contactRow) {
+            this.eventEmitter.emit(SdkEventType.SESSION_REQUESTED, toDiscussion(discussion), contactRow);
         }
         return { discussionId };
     }

package/dist/services/auth.d.ts

@@ -5,11 +5,9 @@
  */
 import { UserPublicKeys } from '../wasm/bindings';
 import { IMessageProtocol } from '../api/messageProtocol/types';
-import { type GossipDatabase } from '../db';
 export declare class AuthService {
-    private db;
     messageProtocol: IMessageProtocol;
-    constructor(db: GossipDatabase, messageProtocol: IMessageProtocol);
+    constructor(messageProtocol: IMessageProtocol);
     /**
      * Fetch public key by userId
      * @param userId - Bech32-encoded userId (e.g., "gossip1...")

package/dist/services/auth.js

@@ -6,14 +6,9 @@
 import { UserPublicKeys } from '../wasm/bindings';
 import { decodeUserId } from '../utils/userId';
 import { encodeToBase64, decodeFromBase64 } from '../utils/base64';
+import { getUserProfileField, updateUserProfileById } from '../queries';
 export class AuthService {
-    constructor(db, messageProtocol) {
-        Object.defineProperty(this, "db", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: db
-        });
+    constructor(messageProtocol) {
         Object.defineProperty(this, "messageProtocol", {
             enumerable: true,
             configurable: true,
@@ -41,7 +36,7 @@ export class AuthService {
      * @param userId - Bech32-encoded userId (e.g., "gossip1...")
      */
     async ensurePublicKeyPublished(publicKeys, userId) {
-        const profile = await this.db.userProfile.get(userId);
+        const profile = await getUserProfileField(userId);
         if (profile) {
             const lastPush = profile.lastPublicKeyPush;
             if (lastPush && !moreThanOneWeekAgo(lastPush)) {
@@ -50,9 +45,7 @@ export class AuthService {
         }
         await this.messageProtocol.postPublicKey(encodeToBase64(publicKeys.to_bytes()));
         if (profile) {
-            await this.db.userProfile.update(userId, {
-                lastPublicKeyPush: new Date(),
-            });
+            await updateUserProfileById(userId, { lastPublicKeyPush: new Date() });
         }
     }
 }