@massalabs/gossip-sdk 0.0.2-dev.20260428144322 → 0.0.2-dev.20260429045217

package/dist/core/SdkEventEmitter.d.ts

@@ -18,6 +18,7 @@ export declare enum SdkEventType {
     SESSION_STATUS_CHANGED = "sessionStatusChanged",
     DISCUSSION_UPDATED = "discussionUpdated",
     MESSAGE_ACKNOWLEDGED = "messageAcknowledged",
+    CONTACT_DELETED = "contactDeleted",
     ERROR = "error"
 }
 export type SdkEvents = {
@@ -53,6 +54,9 @@ export type SdkEvents = {
         contactUserId: string;
         messageDbId: number;
     };
+    [SdkEventType.CONTACT_DELETED]: {
+        contactUserId: string;
+    };
     [SdkEventType.ERROR]: {
         error: Error;
         context: string;

package/dist/core/SdkEventEmitter.js

@@ -18,6 +18,7 @@ export var SdkEventType;
     SdkEventType["SESSION_STATUS_CHANGED"] = "sessionStatusChanged";
     SdkEventType["DISCUSSION_UPDATED"] = "discussionUpdated";
     SdkEventType["MESSAGE_ACKNOWLEDGED"] = "messageAcknowledged";
+    SdkEventType["CONTACT_DELETED"] = "contactDeleted";
     SdkEventType["ERROR"] = "error";
 })(SdkEventType || (SdkEventType = {}));
 export class SdkEventEmitter {

package/dist/db/migrate.d.ts

@@ -5,7 +5,7 @@
  * pending ones. Each migration executes in its own transaction so
  * a failure at migration N leaves 0..N-1 committed.
  */
-type ExecRaw = (sql: string, params?: unknown[]) => Promise<unknown[][]>;
-type WithTransaction = <T>(fn: () => Promise<T>) => Promise<T>;
+export type ExecRaw = (sql: string, params?: unknown[]) => Promise<unknown[][]>;
+type WithTransaction = <T>(fn: (txExecRaw: ExecRaw) => Promise<T>) => Promise<T>;
 export declare function runMigrations(execRaw: ExecRaw, withTransaction: WithTransaction): Promise<void>;
 export {};

package/dist/db/migrate.js

@@ -25,11 +25,11 @@ export async function runMigrations(execRaw, withTransaction) {
     const maxApplied = rows[0][0];
     const pending = MIGRATIONS.filter(m => m.idx > (maxApplied ?? -1));
     for (const migration of pending) {
-        await withTransaction(async () => {
+        await withTransaction(async (txExecRaw) => {
             for (const stmt of migration.statements) {
-                await execRaw(makeCreateStatementsIdempotent(stmt));
+                await txExecRaw(makeCreateStatementsIdempotent(stmt));
             }
-            await execRaw('INSERT INTO _migrations (idx, tag, applied_at) VALUES (?, ?, ?)', [migration.idx, migration.tag, Date.now()]);
+            await txExecRaw('INSERT INTO _migrations (idx, tag, applied_at) VALUES (?, ?, ?)', [migration.idx, migration.tag, Date.now()]);
         });
     }
 }

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

@@ -1,5 +1,5 @@
 import * as schema from '../schema/index.js';
-import type { DatabaseConnection } from '../sqlite.js';
+import type { DatabaseConnection, GossipSqliteTx } from '../sqlite.js';
 import type { Contact } from '../db.js';
 export type ContactRow = typeof schema.contacts.$inferSelect;
 type ContactInsert = typeof schema.contacts.$inferInsert;
@@ -10,7 +10,7 @@ export declare class ContactQueries {
     getByOwner(ownerUserId: string): Promise<Contact[]>;
     insert(values: ContactInsert): Promise<number>;
     updateByOwnerAndUser(ownerUserId: string, userId: string, data: Partial<ContactInsert>): Promise<void>;
-    deleteByOwnerAndUser(ownerUserId: string, userId: string): Promise<void>;
+    deleteByOwnerAndUser(ownerUserId: string, userId: string, tx?: GossipSqliteTx): Promise<void>;
     getNamesByPrefix(ownerUserId: string, prefix: string): Promise<{
         name: string;
     }[]>;

package/dist/db/queries/contacts.js

@@ -37,8 +37,8 @@ export class ContactQueries {
             .set(data)
             .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)));
     }
-    async deleteByOwnerAndUser(ownerUserId, userId) {
-        await this.conn.db
+    async deleteByOwnerAndUser(ownerUserId, userId, tx) {
+        await (tx ?? this.conn.db)
             .delete(schema.contacts)
             .where(and(eq(schema.contacts.ownerUserId, ownerUserId), eq(schema.contacts.userId, userId)));
     }

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

@@ -14,7 +14,7 @@ export declare class DiscussionQueries {
     updateById(id: number, data: Partial<DiscussionInsert>, tx?: GossipSqliteTx): Promise<void>;
     updateByOwnerAndContact(ownerUserId: string, contactUserId: string, data: Partial<DiscussionInsert>): Promise<void>;
     deleteById(id: number): Promise<void>;
-    deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
+    deleteByOwnerAndContact(ownerUserId: string, contactUserId: string, tx?: GossipSqliteTx): Promise<void>;
     incrementUnreadCount(discussionId: number, tx?: GossipSqliteTx): Promise<void>;
     decrementUnreadCount(discussionId: number, tx?: GossipSqliteTx): Promise<void>;
 }

package/dist/db/queries/discussions.js

@@ -61,8 +61,8 @@ export class DiscussionQueries {
             .delete(schema.discussions)
             .where(eq(schema.discussions.id, id));
     }
-    async deleteByOwnerAndContact(ownerUserId, contactUserId) {
-        await this.conn.db
+    async deleteByOwnerAndContact(ownerUserId, contactUserId, tx) {
+        await (tx ?? this.conn.db)
             .delete(schema.discussions)
             .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.contactUserId, contactUserId)));
     }

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

@@ -17,8 +17,8 @@ export declare class MessageQueries {
     insert(values: MessageInsert, tx?: GossipSqliteTx): Promise<number>;
     batchInsert(values: MessageInsert[]): Promise<void>;
     updateById(id: number, data: Partial<MessageInsert>, tx?: GossipSqliteTx): Promise<void>;
-    deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
-    deleteById(id: number): Promise<void>;
+    deleteByOwnerAndContact(ownerUserId: string, contactUserId: string, tx?: GossipSqliteTx): Promise<void>;
+    deleteById(id: number, tx?: GossipSqliteTx): Promise<void>;
     deleteReactionsForMessage(ownerUserId: string, contactUserId: string, messageIdBase64: string): Promise<void>;
     deleteDeliveredKeepAlive(ownerUserId: string): Promise<void>;
     getOutgoingSentByOwner(ownerUserId: string): Promise<MessageRow[]>;
@@ -27,12 +27,7 @@ export declare class MessageQueries {
     getByStatus(ownerUserId: string, status: MessageStatus): Promise<MessageRow[]>;
     resetSendQueue(ownerUserId: string, contactUserId: string): Promise<void>;
     getAnnouncementsByContact(ownerUserId: string, contactUserId: string): Promise<MessageRow[]>;
-    /**
-     * Hard-delete messages older than each discussion's retention duration.
-     * Only processes discussions that have a non-null messageRetentionDuration.
-     * Skips KEEP_ALIVE and ANNOUNCEMENT types.
-     */
-    deleteExpiredByOwner(ownerUserId: string, discussions: DiscussionRow[]): Promise<void>;
+    getExpiredByOwner(ownerUserId: string, discussions: DiscussionRow[]): Promise<MessageRow[]>;
     findDuplicateIncoming(ownerUserId: string, contactUserId: string, content: string, windowStart: Date, windowEnd: Date): Promise<{
         id: number;
     } | undefined>;

package/dist/db/queries/messages.js

@@ -75,8 +75,15 @@ export class MessageQueries {
             .get();
     }
     async insert(values, tx) {
-        await (tx ?? this.conn.db).insert(schema.messages).values(values);
-        return this.conn.getLastInsertRowId();
+        const inserted = await (tx ?? this.conn.db)
+            .insert(schema.messages)
+            .values(values)
+            .returning({ id: schema.messages.id })
+            .get();
+        if (!inserted?.id) {
+            throw new Error('Failed to insert message row');
+        }
+        return inserted.id;
     }
     async batchInsert(values) {
         if (values.length === 0)
@@ -89,13 +96,13 @@ export class MessageQueries {
             .set(data)
             .where(eq(schema.messages.id, id));
     }
-    async deleteByOwnerAndContact(ownerUserId, contactUserId) {
-        await this.conn.db
+    async deleteByOwnerAndContact(ownerUserId, contactUserId, tx) {
+        await (tx ?? this.conn.db)
             .delete(schema.messages)
             .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId)));
     }
-    async deleteById(id) {
-        await this.conn.db
+    async deleteById(id, tx) {
+        await (tx ?? this.conn.db)
             .delete(schema.messages)
             .where(eq(schema.messages.id, id));
     }
@@ -175,26 +182,26 @@ export class MessageQueries {
             .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, contactUserId), eq(schema.messages.direction, MessageDirection.INCOMING), eq(schema.messages.type, MessageType.ANNOUNCEMENT)))
             .all();
     }
-    /**
-     * Hard-delete messages older than each discussion's retention duration.
-     * Only processes discussions that have a non-null messageRetentionDuration.
-     * Skips KEEP_ALIVE and ANNOUNCEMENT types.
-     */
-    async deleteExpiredByOwner(ownerUserId, discussions) {
+    async getExpiredByOwner(ownerUserId, discussions) {
         const now = Date.now();
+        const expiredMessages = [];
         for (const discussion of discussions) {
             if (!discussion.messageRetentionDuration ||
                 discussion.messageRetentionDuration <= 0) {
                 continue;
             }
             const expiryTs = now - discussion.messageRetentionDuration * 1000;
-            // Only delete messages that were sent AFTER the policy was activated.
+            // Only include messages that were sent AFTER the policy was activated.
             // Messages that existed before the policy was set are left untouched.
             const policySetAt = discussion.retentionPolicySetAt ?? 0;
-            await this.conn.db
-                .delete(schema.messages)
-                .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, discussion.contactUserId), lt(schema.messages.timestamp, new Date(expiryTs)), gte(schema.messages.timestamp, new Date(policySetAt)), ne(schema.messages.type, MessageType.KEEP_ALIVE), ne(schema.messages.type, MessageType.ANNOUNCEMENT)));
+            const rows = await this.conn.db
+                .select()
+                .from(schema.messages)
+                .where(and(eq(schema.messages.ownerUserId, ownerUserId), eq(schema.messages.contactUserId, discussion.contactUserId), lt(schema.messages.timestamp, new Date(expiryTs)), gte(schema.messages.timestamp, new Date(policySetAt)), ne(schema.messages.type, MessageType.KEEP_ALIVE), ne(schema.messages.type, MessageType.ANNOUNCEMENT)))
+                .all();
+            expiredMessages.push(...rows);
         }
+        return expiredMessages;
     }
     async findDuplicateIncoming(ownerUserId, contactUserId, content, windowStart, windowEnd) {
         return this.conn.db

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

@@ -0,0 +1,81 @@
+import { QueryBuilder } from 'drizzle-orm/sqlite-core';
+import type { GossipDatabase, GossipSqliteTx } from '../sqlite.js';
+/**
+ * A db context accepted by SqlBatch operations.
+ *
+ * Both the root database instance and an active transaction expose the same
+ * drizzle query-builder API (insert / update / delete / select), so batch ops
+ * can be written generically and replayed on either surface.
+ */
+export type DbContext = GossipDatabase | GossipSqliteTx;
+type BatchOp = (db: DbContext) => Promise<void>;
+/**
+ * A collection of deferred database write operations that can be executed
+ * atomically within an explicit transaction context.
+ *
+ * ## Motivation
+ *
+ * When a helper method needs to produce DB writes that must be committed
+ * together with the caller's own writes, passing a `tx` reference through
+ * every layer couples each helper to whatever transaction the caller happens
+ * to be running.  SqlBatch inverts this: the helper collects its operations
+ * without executing them, returns the batch, and the caller replays it in
+ * whichever transaction it controls.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * // --- building the batch (no DB writes yet) ---
+ * const batch = new SqlBatch();
+ * const values = { content: 'hello', ... };
+ * batch.add(db => db.insert(schema.messages).values(values));
+ * batch.add(db => db.update(schema.discussions).set({ ... }).where(...));
+ *
+ * // --- replaying in the caller's transaction ---
+ * await this.queries.conn.withTransaction(async tx => {
+ *   await doSomethingElse(tx);
+ *   await batch.execute(tx);   // all ops run inside the same tx
+ * });
+ * ```
+ *
+ * ## QueryBuilder
+ *
+ * The `qb` property exposes a connection-less `QueryBuilder` that can be used
+ * to build and inspect queries (e.g. via `.toSQL()`) before capturing them in
+ * a batch op.  It is purely a convenience — most callers will simply use the
+ * `db` argument provided by the op factory.
+ */
+export declare class SqlBatch {
+    /**
+     * A connection-less QueryBuilder for constructing parameterised queries
+     * without a live database connection.  Inspect with `.toSQL()` or capture
+     * the built values in a closure passed to `add()`.
+     */
+    readonly qb: QueryBuilder;
+    private readonly ops;
+    /**
+     * Queue a write operation to be executed later.
+     *
+     * The factory receives the actual db context (transaction or root db) at
+     * execute time.  Use drizzle's standard query builders — `db.insert()`,
+     * `db.update()`, `db.delete()` — with the provided `db` argument.
+     *
+     * Values needed by the operation should be closed over from the surrounding
+     * scope so that the batch remains a self-contained description of what to
+     * write.
+     */
+    add(op: BatchOp): void;
+    /**
+     * Execute all queued operations in insertion order using the provided db
+     * context.
+     *
+     * Pass an active transaction (`tx`) for atomic execution alongside other
+     * operations in the same transaction.  When no transaction is available,
+     * pass the root db instance — each op will then run as its own implicit
+     * transaction.
+     */
+    execute(db: DbContext): Promise<void>;
+    /** Number of queued operations. */
+    get size(): number;
+}
+export {};

package/dist/db/queries/sqlBatch.js

@@ -0,0 +1,90 @@
+import { QueryBuilder } from 'drizzle-orm/sqlite-core';
+/**
+ * A collection of deferred database write operations that can be executed
+ * atomically within an explicit transaction context.
+ *
+ * ## Motivation
+ *
+ * When a helper method needs to produce DB writes that must be committed
+ * together with the caller's own writes, passing a `tx` reference through
+ * every layer couples each helper to whatever transaction the caller happens
+ * to be running.  SqlBatch inverts this: the helper collects its operations
+ * without executing them, returns the batch, and the caller replays it in
+ * whichever transaction it controls.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * // --- building the batch (no DB writes yet) ---
+ * const batch = new SqlBatch();
+ * const values = { content: 'hello', ... };
+ * batch.add(db => db.insert(schema.messages).values(values));
+ * batch.add(db => db.update(schema.discussions).set({ ... }).where(...));
+ *
+ * // --- replaying in the caller's transaction ---
+ * await this.queries.conn.withTransaction(async tx => {
+ *   await doSomethingElse(tx);
+ *   await batch.execute(tx);   // all ops run inside the same tx
+ * });
+ * ```
+ *
+ * ## QueryBuilder
+ *
+ * The `qb` property exposes a connection-less `QueryBuilder` that can be used
+ * to build and inspect queries (e.g. via `.toSQL()`) before capturing them in
+ * a batch op.  It is purely a convenience — most callers will simply use the
+ * `db` argument provided by the op factory.
+ */
+export class SqlBatch {
+    constructor() {
+        /**
+         * A connection-less QueryBuilder for constructing parameterised queries
+         * without a live database connection.  Inspect with `.toSQL()` or capture
+         * the built values in a closure passed to `add()`.
+         */
+        Object.defineProperty(this, "qb", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new QueryBuilder()
+        });
+        Object.defineProperty(this, "ops", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    /**
+     * Queue a write operation to be executed later.
+     *
+     * The factory receives the actual db context (transaction or root db) at
+     * execute time.  Use drizzle's standard query builders — `db.insert()`,
+     * `db.update()`, `db.delete()` — with the provided `db` argument.
+     *
+     * Values needed by the operation should be closed over from the surrounding
+     * scope so that the batch remains a self-contained description of what to
+     * write.
+     */
+    add(op) {
+        this.ops.push(op);
+    }
+    /**
+     * Execute all queued operations in insertion order using the provided db
+     * context.
+     *
+     * Pass an active transaction (`tx`) for atomic execution alongside other
+     * operations in the same transaction.  When no transaction is available,
+     * pass the root db instance — each op will then run as its own implicit
+     * transaction.
+     */
+    async execute(db) {
+        for (const op of this.ops) {
+            await op(db);
+        }
+    }
+    /** Number of queued operations. */
+    get size() {
+        return this.ops.length;
+    }
+}

package/dist/db/sqlite.d.ts

@@ -54,7 +54,11 @@ export declare class DatabaseConnection {
     private execRawInProcess;
     private init;
     getLastInsertRowId(): Promise<number>;
-    withTransaction<T>(fn: () => Promise<T>): Promise<T>;
+    withTransaction<T>(fn: (tx: GossipSqliteTx) => Promise<T>, behavior?: 'deferred' | 'immediate' | 'exclusive'): Promise<T>;
+    private withRawTransaction;
+    private withSavepoint;
+    private runInTxScope;
+    private initTxScopeGuard;
     close(): Promise<void>;
     clearAllTables(): Promise<void>;
     /** Delete only the data belonging to a specific account. */

package/dist/db/sqlite.js

@@ -29,13 +29,14 @@ function createDefaultState() {
         useWorker: false,
         drizzleDb: null,
         dbLock: Promise.resolve(),
-        inTransaction: false,
+        txScopeGuard: null,
     };
 }
 /** PRAGMAs applied before migrations (in-memory / browser worker). */
 const PRAGMAS = `
   PRAGMA journal_mode=MEMORY;
   PRAGMA temp_store=MEMORY;
+  PRAGMA busy_timeout = 10000;
 `;
 /** PRAGMAs for file-based persistence (Node.js). WAL gives crash recovery. */
 const PRAGMAS_FILE = `
@@ -102,18 +103,27 @@ export class DatabaseConnection {
             this.state.worker.postMessage({ ...msg, id }, transfer);
         });
     }
-    createDrizzleInstance() {
-        return drizzle(async (sql, params, method) => {
-            const rows = await this.execRaw(sql, params);
+    createDrizzleInstance(isTx = false, txContext) {
+        const drizzleDb = drizzle(async (sql, params, method) => {
+            const rows = isTx
+                ? await this.execRawDirect(sql, params)
+                : await this.execRaw(sql, params);
             if (method === 'get') {
                 return { rows: rows[0] };
             }
             return { rows };
         }, { schema });
+        drizzleDb.transaction = async (fn) => {
+            if (txContext?.isActive) {
+                return this.withSavepoint(txContext, fn);
+            }
+            return this.withTransaction(fn);
+        };
+        return drizzleDb;
     }
     async execRaw(sql, params = []) {
-        if (this.state.inTransaction) {
-            return this.execRawDirect(sql, params);
+        if (this.state.txScopeGuard?.getStore()) {
+            throw new Error('Detected root db query inside a transaction callback. Use the provided transaction (tx) instance instead of root db.');
         }
         const prev = this.state.dbLock;
         let release;
@@ -144,6 +154,7 @@ export class DatabaseConnection {
     async init(options) {
         if (this.state.drizzleDb)
             return;
+        await this.initTxScopeGuard();
         const storage = options.storage ?? { type: 'memory' };
         switch (storage.type) {
             case 'opfs':
@@ -207,7 +218,10 @@ export class DatabaseConnection {
                 break;
             }
         }
-        await runMigrations((sql, params) => this.execRaw(sql, params), fn => this.withTransaction(fn));
+        await runMigrations((sql, params) => this.execRaw(sql, params), fn => {
+            const txExecRaw = this.execRawDirect.bind(this);
+            return this.withRawTransaction(() => fn(txExecRaw));
+        });
         this.state.drizzleDb = this.createDrizzleInstance();
     }
     // ─── Public methods ────────────────────────────────────────────
@@ -218,16 +232,31 @@ export class DatabaseConnection {
         const rows = await this.execRaw('SELECT last_insert_rowid()');
         return rows[0][0];
     }
-    async withTransaction(fn) {
+    async withTransaction(fn, behavior = 'immediate') {
+        const txContext = {
+            nextSavepointId: 0,
+            isActive: false,
+        };
+        const tx = this.createDrizzleInstance(true, txContext);
+        return this.withRawTransaction(async () => {
+            txContext.isActive = true;
+            try {
+                return await fn(tx);
+            }
+            finally {
+                txContext.isActive = false;
+            }
+        }, behavior);
+    }
+    async withRawTransaction(fn, behavior = 'immediate') {
         const prev = this.state.dbLock;
         let release;
         this.state.dbLock = new Promise(r => (release = r));
         await prev;
         try {
-            await this.execRawDirect('BEGIN');
-            this.state.inTransaction = true;
+            await this.execRawDirect(`BEGIN ${behavior.toUpperCase()}`);
             try {
-                const result = await fn();
+                const result = await this.runInTxScope(fn);
                 await this.execRawDirect('COMMIT');
                 return result;
             }
@@ -235,14 +264,52 @@ export class DatabaseConnection {
                 await this.execRawDirect('ROLLBACK');
                 throw e;
             }
-            finally {
-                this.state.inTransaction = false;
-            }
         }
         finally {
             release();
         }
     }
+    async withSavepoint(txContext, fn) {
+        const savepointName = `sp_${txContext.nextSavepointId++}`;
+        const tx = this.createDrizzleInstance(true, txContext);
+        await this.execRawDirect(`SAVEPOINT ${savepointName}`);
+        try {
+            const result = await fn(tx);
+            await this.execRawDirect(`RELEASE SAVEPOINT ${savepointName}`);
+            return result;
+        }
+        catch (e) {
+            await this.execRawDirect(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+            await this.execRawDirect(`RELEASE SAVEPOINT ${savepointName}`);
+            throw e;
+        }
+    }
+    async runInTxScope(fn) {
+        const guard = this.state.txScopeGuard;
+        if (!guard) {
+            return fn();
+        }
+        return guard.run(true, fn);
+    }
+    async initTxScopeGuard() {
+        // AsyncLocalStorage is Node-only. This guard is intentionally enabled only
+        // in Node/test environments; browser/worker runtimes skip it gracefully.
+        if (typeof process === 'undefined' ||
+            typeof process.versions?.node !== 'string') {
+            return;
+        }
+        try {
+            const { AsyncLocalStorage } = await import('node:async_hooks');
+            const guard = new AsyncLocalStorage();
+            this.state.txScopeGuard = {
+                run: (inTransaction, fn) => guard.run(inTransaction, fn),
+                getStore: () => guard.getStore() ?? false,
+            };
+        }
+        catch {
+            this.state.txScopeGuard = null;
+        }
+    }
     async close() {
         if (this.state.useWorker && this.state.worker) {
             await this.postToWorker({ type: 'close' });
@@ -254,49 +321,49 @@ export class DatabaseConnection {
         this.state = createDefaultState();
     }
     async clearAllTables() {
-        await this.withTransaction(async () => {
-            await this.db.delete(schema.messages);
-            await this.db.delete(schema.discussions);
-            await this.db.delete(schema.contacts);
-            await this.db.delete(schema.userProfile);
-            await this.db.delete(schema.pendingEncryptedMessages);
-            await this.db.delete(schema.pendingAnnouncements);
-            await this.db.delete(schema.activeSeekers);
-            await this.db.delete(schema.announcementCursors);
+        await this.withTransaction(async (tx) => {
+            await tx.delete(schema.messages);
+            await tx.delete(schema.discussions);
+            await tx.delete(schema.contacts);
+            await tx.delete(schema.userProfile);
+            await tx.delete(schema.pendingEncryptedMessages);
+            await tx.delete(schema.pendingAnnouncements);
+            await tx.delete(schema.activeSeekers);
+            await tx.delete(schema.announcementCursors);
         });
     }
     /** Delete only the data belonging to a specific account. */
     async clearAccountData(userId) {
-        await this.withTransaction(async () => {
+        await this.withTransaction(async (tx) => {
             // Tables with ownerUserId
-            await this.db
+            await tx
                 .delete(schema.messages)
                 .where(eq(schema.messages.ownerUserId, userId));
-            await this.db
+            await tx
                 .delete(schema.discussions)
                 .where(eq(schema.discussions.ownerUserId, userId));
-            await this.db
+            await tx
                 .delete(schema.contacts)
                 .where(eq(schema.contacts.ownerUserId, userId));
             // Profile table keyed by userId
-            await this.db
+            await tx
                 .delete(schema.userProfile)
                 .where(eq(schema.userProfile.userId, userId));
             // Announcement cursor keyed by userId
-            await this.db
+            await tx
                 .delete(schema.announcementCursors)
                 .where(eq(schema.announcementCursors.userId, userId));
             // Session-specific tables (no user column — safe to clear for current session)
-            await this.db.delete(schema.pendingEncryptedMessages);
-            await this.db.delete(schema.pendingAnnouncements);
-            await this.db.delete(schema.activeSeekers);
+            await tx.delete(schema.pendingEncryptedMessages);
+            await tx.delete(schema.pendingAnnouncements);
+            await tx.delete(schema.activeSeekers);
         });
     }
     async clearConversationTables() {
-        await this.withTransaction(async () => {
-            await this.db.delete(schema.messages);
-            await this.db.delete(schema.discussions);
-            await this.db.delete(schema.contacts);
+        await this.withTransaction(async (tx) => {
+            await tx.delete(schema.messages);
+            await tx.delete(schema.discussions);
+            await tx.delete(schema.contacts);
         });
     }
 }

package/dist/gossip.js

@@ -256,7 +256,6 @@ class GossipSdk {
         });
         // Now set refreshService on services (circular dependency resolved via setter)
         this._discussion.setRefreshService(this._refresh);
-        this._message.setRefreshService(this._refresh);
         this._announcement.setRefreshService(this._refresh);
         // Reset any messages stuck in SENDING status to WAITING_SESSION
         // This handles app crash/close during message send
@@ -272,7 +271,7 @@ class GossipSdk {
             onPersist: options.onPersist,
         };
         // Wire up cross-service dependencies
-        this._contact = new ContactService(session, queries, this._auth);
+        this._contact = new ContactService(session, queries, this._auth, this.eventEmitter);
         this._message.setQueueManager(this.messageQueues);
         this._discussion.setAuthService(this._auth);
         // Auto-start polling if enabled in config

package/dist/services/contact.d.ts

@@ -10,11 +10,13 @@ import type { SessionModule } from '../wasm/session.js';
 import type { AuthService } from './auth.js';
 import { type AddContactResult, type UpdateContactNameResult, type DeleteContactResult } from '../utils/contacts.js';
 import { Queries } from '../db/queries/index.js';
+import { SdkEventEmitter } from '../core/SdkEventEmitter.js';
 export declare class ContactService {
     private session;
     private queries;
     private authService;
-    constructor(session: SessionModule, queries: Queries, authService: AuthService);
+    private eventEmitter;
+    constructor(session: SessionModule, queries: Queries, authService: AuthService, eventEmitter: SdkEventEmitter);
     private get owner();
     list(): Promise<Contact[]>;
     get(contactUserId: string): Promise<Contact | null>;

package/dist/services/contact.js

@@ -5,8 +5,9 @@
  * Created during openSession().
  */
 import { addContact, updateContactName, deleteContact, } from '../utils/contacts.js';
+import { SdkEventType } from '../core/SdkEventEmitter.js';
 export class ContactService {
-    constructor(session, queries, authService) {
+    constructor(session, queries, authService, eventEmitter) {
         Object.defineProperty(this, "session", {
             enumerable: true,
             configurable: true,
@@ -25,9 +26,16 @@ export class ContactService {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "eventEmitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.session = session;
         this.queries = queries;
         this.authService = authService;
+        this.eventEmitter = eventEmitter;
     }
     get owner() {
         return this.session.userIdEncoded;
@@ -46,6 +54,10 @@ export class ContactService {
         return updateContactName(this.owner, contactUserId, newName, this.queries);
     }
     async delete(contactUserId) {
-        return deleteContact(this.owner, contactUserId, this.session, this.queries);
+        const result = await deleteContact(this.owner, contactUserId, this.session, this.queries);
+        if (result.success) {
+            this.eventEmitter.emit(SdkEventType.CONTACT_DELETED, { contactUserId });
+        }
+        return result;
     }
 }

package/dist/services/message.d.ts

@@ -11,7 +11,6 @@ import { SessionModule } from '../wasm/index.js';
 import { Result } from '../utils/type.js';
 import { SdkConfig } from '../config/sdk.js';
 import { SdkEventEmitter } from '../core/SdkEventEmitter.js';
-import type { RefreshService } from './refresh.js';
 import { Queries } from '../db/queries/index.js';
 import { QueueManager } from '../utils/queue.js';
 import { GossipSqliteTx } from '../db/sqlite.js';
@@ -41,7 +40,6 @@ export declare class MessageService {
     private session;
     private eventEmitter;
     private config;
-    private refreshService?;
     private queueManager?;
     private processingContacts;
     private isFetchingMessages;
@@ -57,7 +55,6 @@ export declare class MessageService {
     /** Emit MESSAGE_RECEIVED with a Message that may not have a DB id yet */
     private emitMessageReceived;
     constructor(messageProtocol: IMessageProtocol, session: SessionModule, eventEmitter: SdkEventEmitter, config: SdkConfig | undefined, queries: Queries);
-    setRefreshService(refreshService: RefreshService): void;
     setQueueManager(queueManager: QueueManager): void;
     fetchMessages(): Promise<MessageResult>;
     /**

package/dist/services/message.js

@@ -175,12 +175,6 @@ export class MessageService {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "refreshService", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "queueManager", {
             enumerable: true,
             configurable: true,
@@ -224,9 +218,6 @@ export class MessageService {
         this.config = config;
         this.queries = queries;
     }
-    setRefreshService(refreshService) {
-        this.refreshService = refreshService;
-    }
     setQueueManager(queueManager) {
         this.queueManager = queueManager;
     }
@@ -313,8 +304,7 @@ export class MessageService {
      * Add a message to SQLite and update the corresponding discussion.
      */
     async addMessageAndUpdateDiscussion(message, parentTx) {
-        const db = parentTx ?? this.queries.conn.db;
-        const result = await db.transaction(async (tx) => {
+        const result = await (parentTx ?? this.queries.conn.db).transaction(async (tx) => {
             const messageId = await this.queries.messages.insert({
                 messageId: message.messageId,
                 ownerUserId: message.ownerUserId,
@@ -336,7 +326,9 @@ export class MessageService {
                 whenToSend: message.whenToSend,
             }, tx);
             const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId, tx);
-            if (discussion && POST_MESSAGE_TYPES.includes(message.type)) {
+            if (discussion &&
+                POST_MESSAGE_TYPES.includes(message.type) &&
+                !message.editOf) {
                 await this.queries.discussions.updateById(discussion.id, {
                     lastMessageId: messageId,
                     lastMessageContent: message.content,
@@ -350,7 +342,7 @@ export class MessageService {
             }
             return { messageId, updatedDiscussionId: null };
         });
-        if (result.updatedDiscussionId) {
+        if (result.updatedDiscussionId && !parentTx) {
             this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, result.updatedDiscussionId);
         }
         return result.messageId;
@@ -672,6 +664,17 @@ export class MessageService {
                 error: 'Failed to add message to database, got error: ' + error,
             };
         }
+        if (parentTx) {
+            // When called inside an existing SQL transaction, avoid lock re-entry
+            // (queue processing + plain read paths run through conn.db/execRaw queue).
+            return {
+                success: true,
+                message: {
+                    ...message,
+                    id: messageIdDb,
+                },
+            };
+        }
         /*
         Trigger a sending queue state update for contact in order to send the new message.
         If the processSendQueueForContact function is already running, it will be skipped.
@@ -1108,26 +1111,28 @@ export class MessageService {
             ...(options?.metadata && { metadata: options.metadata }),
         };
         const result = await this.send(message);
-        await this.refreshService?.stateUpdate();
         return result;
     }
     /** Fetch and decrypt messages from the protocol (alias) */
     async fetch() {
         return this.fetchMessages();
     }
-    async PerformDeleteMessage(message, tx) {
+    async PerformDeleteMessage(message, parentTx) {
         if (!message.id) {
             return { success: false, error: new Error('Message ID is required') };
         }
-        const db = tx ?? this.queries.conn.db;
         if (message.type === MessageType.REACTION) {
             // Reaction delete: hard-delete the row, not "[Message deleted]"
             try {
-                await this.queries.messages.deleteById(message.id);
-                this.eventEmitter.emit(SdkEventType.MESSAGE_DELETED, {
-                    messages: [message],
-                });
-                return { success: true, data: null };
+                await this.queries.messages.deleteById(message.id, parentTx);
+                return {
+                    success: true,
+                    data: () => {
+                        this.eventEmitter.emit(SdkEventType.MESSAGE_DELETED, {
+                            messages: [message],
+                        });
+                    },
+                };
             }
             catch (error) {
                 return {
@@ -1140,64 +1145,51 @@ export class MessageService {
         }
         let deletedMessages = [];
         let updatedMessages = [];
-        let discussionId;
-        try {
-            // Run all operations inside an explicit transaction for atomicity
-            await db.transaction(async (trx) => {
-                const discussion = await trx
-                    .select()
-                    .from(schema.discussions)
-                    .where(and(eq(schema.discussions.ownerUserId, message.ownerUserId), eq(schema.discussions.contactUserId, message.contactUserId)))
-                    .get();
-                if (!discussion) {
-                    throw new Error('Discussion not found');
+        let discussionUpdated = false;
+        const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId, parentTx);
+        if (!discussion) {
+            return { success: false, error: new Error('Discussion not found') };
+        }
+        await (parentTx ?? this.queries.conn.db).transaction(async (trx) => {
+            // delete the message : MessageType.DELETED '[Message deleted]' in  db
+            await this.queries.messages.updateById(message.id, // message.id is guaranteed to be not null because we checked it above
+            {
+                content: '[Message deleted]',
+                type: MessageType.DELETED,
+            }, trx);
+            if (POST_MESSAGE_TYPES.includes(message.type)) {
+                // If the message to delete is the last text message in the discussion, update the discussion to the previous last text message
+                if (discussion.lastMessageId === message.id) {
+                    const lastMessage = await this.queries.discussions.getLastTextMessage(message.contactUserId, trx);
+                    await this.queries.discussions.updateById(discussion.id, {
+                        lastMessageId: lastMessage?.id ?? null,
+                        lastMessageContent: lastMessage?.content ?? null,
+                        lastMessageTimestamp: lastMessage?.timestamp ?? null,
+                        updatedAt: new Date(),
+                    }, trx);
+                    discussionUpdated = true;
                 }
-                // delete the message : MessageType.DELETED '[Message deleted]' in  db
-                await this.queries.messages.updateById(message.id, // message.id is guaranteed to be not null because we checked it above
-                {
-                    content: '[Message deleted]',
-                    type: MessageType.DELETED,
-                }, trx);
-                if (POST_MESSAGE_TYPES.includes(message.type)) {
-                    // If the message to delete is the last text message in the discussion, update the discussion to the previous last text message
-                    if (discussion.lastMessageId === message.id) {
-                        const lastMessage = await this.queries.discussions.getLastTextMessage(message.contactUserId, trx);
-                        await this.queries.discussions.updateById(discussion.id, {
-                            lastMessageId: lastMessage?.id ?? null,
-                            lastMessageContent: lastMessage?.content ?? null,
-                            lastMessageTimestamp: lastMessage?.timestamp ?? null,
-                            updatedAt: new Date(),
-                        }, trx);
-                        discussionId = discussion.id;
-                    }
-                    // If deleted message is not read yet, decrement the discussion unread count
-                    if (message.status !== MessageStatus.READ &&
-                        message.direction === MessageDirection.INCOMING) {
-                        await this.queries.discussions.decrementUnreadCount(discussion.id, trx);
-                        discussionId = discussion.id;
-                    }
-                    // Delete all REACTION messages for this contact referencing this message
-                    const deletedReactionMessages = await trx
-                        .delete(schema.messages)
-                        .where(and(eq(schema.messages.contactUserId, message.contactUserId), eq(schema.messages.type, MessageType.REACTION), sql `json_extract(${schema.messages.reactionOf}, '$.originalMsgId') = ${encodeToBase64(message.messageId)}`))
-                        .returning();
-                    deletedMessages = deletedReactionMessages.map(rowToMessage);
-                    // Also update all messages REPLYING to this message by setting their replyTo to null
-                    const updatedMessagesDb = await trx
-                        .update(schema.messages)
-                        .set({ replyTo: null })
-                        .where(and(eq(schema.messages.contactUserId, message.contactUserId), sql `json_extract(${schema.messages.replyTo}, '$.originalMsgId') = ${encodeToBase64(message.messageId)}`))
-                        .returning();
-                    updatedMessages = updatedMessagesDb.map(row => rowToMessage(row));
+                // If deleted message is not read yet, decrement the discussion unread count
+                if (message.status !== MessageStatus.READ &&
+                    message.direction === MessageDirection.INCOMING) {
+                    await this.queries.discussions.decrementUnreadCount(discussion.id, trx);
+                    discussionUpdated = true;
                 }
-            });
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
+                // Delete all REACTION messages for this contact referencing this message
+                const deletedReactionMessages = await trx
+                    .delete(schema.messages)
+                    .where(and(eq(schema.messages.contactUserId, message.contactUserId), eq(schema.messages.type, MessageType.REACTION), sql `json_extract(${schema.messages.reactionOf}, '$.originalMsgId') = ${encodeToBase64(message.messageId)}`))
+                    .returning();
+                deletedMessages = deletedReactionMessages.map(rowToMessage);
+                // Also update all messages REPLYING to this message by setting their replyTo to null
+                const updatedMessagesDb = await trx
+                    .update(schema.messages)
+                    .set({ replyTo: null })
+                    .where(and(eq(schema.messages.contactUserId, message.contactUserId), sql `json_extract(${schema.messages.replyTo}, '$.originalMsgId') = ${encodeToBase64(message.messageId)}`))
+                    .returning();
+                updatedMessages = updatedMessagesDb.map(row => rowToMessage(row));
+            }
+        });
         // function to be called after the db transaction is committed.
         // Send events only when we are sure corresponding operation are saved in db
         const postDbCommit = () => {
@@ -1209,11 +1201,11 @@ export class MessageService {
                     messages: updatedMessages,
                 });
             }
-            if (discussionId) {
-                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussionId);
+            if (discussionUpdated) {
+                this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussion.id);
             }
         };
-        if (!tx) {
+        if (!parentTx) {
             // if we are not in a db transaction, we can just emit the event and return
             postDbCommit();
             return { success: true, data: null };
@@ -1237,7 +1229,7 @@ export class MessageService {
         if (!row.messageId)
             throw new Error('Cannot delete a message that has no messageId');
         const ownerUserId = this.session.userIdEncoded;
-        const callbackAfterDbCommit = await this.queries.conn.db.transaction(async (tx) => {
+        const callbackAfterDbCommit = await this.queries.conn.withTransaction(async (tx) => {
             const res = await this.PerformDeleteMessage(rowToMessage(row), tx);
             if (!res.success) {
                 tx.rollback(); // if deleting the message from the db fails, rollback the transaction
@@ -1260,10 +1252,11 @@ export class MessageService {
                 throw new Error(result.error ?? 'Failed to enqueue delete message');
             }
             return res.data;
-        });
+        }, 'immediate');
         if (callbackAfterDbCommit) {
             callbackAfterDbCommit();
         }
+        await this.processSendQueueForContact(row.contactUserId);
         return true;
     }
     async sendReaction(contactUserId, emoji, originalMsgId) {
@@ -1341,7 +1334,7 @@ export class MessageService {
         const ownerUserId = this.session.userIdEncoded;
         const existingMetadata = deserializeMetadata(row.metadata) ?? {};
         const mergedMetadata = { ...existingMetadata, edited: true };
-        const callbackAfterDbCommit = await this.queries.conn.db.transaction(async (tx) => {
+        const callbackAfterDbCommit = await this.queries.conn.withTransaction(async (tx) => {
             const res = await this.performEditMessage(newContent, rowToMessage(row), mergedMetadata, tx);
             if (!res.success) {
                 tx.rollback();
@@ -1364,10 +1357,11 @@ export class MessageService {
                 throw new Error(result.error ?? 'Failed to enqueue edit message');
             }
             return res.data;
-        });
+        }, 'immediate');
         if (callbackAfterDbCommit) {
             callbackAfterDbCommit();
         }
+        await this.processSendQueueForContact(row.contactUserId);
         return true;
     }
     /**
@@ -1380,7 +1374,15 @@ export class MessageService {
         const withRetention = allRows.filter(d => d.messageRetentionDuration != null && d.messageRetentionDuration > 0);
         if (withRetention.length === 0)
             return;
-        await this.queries.messages.deleteExpiredByOwner(ownerUserId, withRetention);
+        const expiredRows = await this.queries.messages.getExpiredByOwner(ownerUserId, withRetention);
+        if (expiredRows.length === 0)
+            return;
+        await Promise.all(expiredRows.map(async (row) => {
+            const result = await this.PerformDeleteMessage(rowToMessage(row));
+            if (!result.success) {
+                throw result.error ?? new Error('Failed to delete expired message');
+            }
+        }));
     }
     // 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) {
@@ -1392,7 +1394,7 @@ export class MessageService {
         }
         const message = rowToMessage(row);
         // Perform message status update and unread count decrement atomically in a transaction
-        const discussionId = await this.queries.conn.db.transaction(async (tx) => {
+        const discussionId = await this.queries.conn.withTransaction(async (tx) => {
             // Update message status
             await this.queries.messages.updateById(id, { status: MessageStatus.READ }, tx);
             // Atomically decrement discussion unread count
@@ -1404,7 +1406,7 @@ export class MessageService {
                 await this.queries.discussions.decrementUnreadCount(discussion.id, tx);
             }
             return discussion.id;
-        });
+        }, 'immediate');
         this.eventEmitter.emit(SdkEventType.MESSAGE_READ, id);
         this.eventEmitter.emit(SdkEventType.DISCUSSION_UPDATED, discussionId);
         return true;

package/dist/utils/contacts.js

@@ -78,10 +78,10 @@ export async function deleteContact(ownerUserId, contactUserId, session, queries
             };
         }
         // Delete contact, discussions, and messages atomically
-        await queries.conn.withTransaction(async () => {
-            await queries.contacts.deleteByOwnerAndUser(ownerUserId, contactUserId);
-            await queries.discussions.deleteByOwnerAndContact(ownerUserId, contactUserId);
-            await queries.messages.deleteByOwnerAndContact(ownerUserId, contactUserId);
+        await queries.conn.withTransaction(async (tx) => {
+            await queries.contacts.deleteByOwnerAndUser(ownerUserId, contactUserId, tx);
+            await queries.discussions.deleteByOwnerAndContact(ownerUserId, contactUserId, tx);
+            await queries.messages.deleteByOwnerAndContact(ownerUserId, contactUserId, tx);
         });
         // Discard peer from session manager (WASM state, outside transaction)
         await session.peerDiscard(decodeUserId(contactUserId));

package/package.json

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