@massalabs/gossip-sdk 0.0.2-dev.20260410095334 → 0.0.2-dev.20260410113627

package/README.md

@@ -293,9 +293,6 @@ const utils = sdk.utils;
 const result = utils.validateUserId(userId);
 if (!result.valid) console.error(result.error);
 
-// Validate username format
-const result = utils.validateUsername(username);
-
 // Encode/decode user IDs
 const encoded = utils.encodeUserId(rawBytes);
 const decoded = utils.decodeUserId(encodedString);

package/dist/gossip.d.ts

@@ -155,8 +155,6 @@ declare class GossipSdk {
 interface SdkUtils {
     /** Validate a user ID format */
     validateUserId(userId: string): ValidationResult;
-    /** Validate a username format */
-    validateUsername(username: string): ValidationResult;
     /** Encode raw bytes to user ID string */
     encodeUserId(rawId: Uint8Array): string;
     /** Decode user ID string to raw bytes */

package/dist/gossip.js

@@ -48,7 +48,7 @@ import { AuthService } from './services/auth.js';
 import { ProfileService } from './services/profile.js';
 import { ContactService } from './services/contact.js';
 import { SelfMessageService } from './services/selfMessage.js';
-import { validateUserIdFormat, validateUsernameFormat, } from './utils/validation.js';
+import { validateUserIdFormat, } from './utils/validation.js';
 import { QueueManager } from './utils/queue.js';
 import { encodeUserId, decodeUserId } from './utils/userId.js';
 import { MessageStatus } from './db/index.js';
@@ -463,7 +463,6 @@ class GossipSdk {
     get utils() {
         return {
             validateUserId: validateUserIdFormat,
-            validateUsername: validateUsernameFormat,
             encodeUserId,
             decodeUserId,
         };

package/dist/services/message.d.ts

@@ -45,6 +45,14 @@ export declare class MessageService {
     private processingContacts;
     private isFetchingMessages;
     private queries;
+    /**
+     * Message ids currently being sent via `sendMessageFastPath`. The row is
+     * WAITING_SESSION in the DB while the fast path runs INSERT + encrypt +
+     * POST in parallel. Without this guard, a concurrent `stateUpdate` could
+     * pick up the same WAITING_SESSION row via `processSendQueueForContact`
+     * and send a duplicate.
+     */
+    private inFlightFastPath;
     /** 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);
@@ -66,6 +74,22 @@ export declare class MessageService {
     findMessageBySeeker(seeker: Uint8Array, ownerUserId: string): Promise<Message | undefined>;
     private acknowledgeMessages;
     sendMessage(message: Message): Promise<SendMessageResult>;
+    /**
+     * Happy-path send: peer session is Active, so we can encrypt locally,
+     * fire the network POST, and INSERT the row in parallel. The three
+     * pieces are independent up until the final `UPDATE → SENT`, which
+     * needs both the row id (from INSERT) and a successful network ack.
+     *
+     *   ┌── INSERT (~440 ms) ───────────────┐
+     *   │                                   ├── UPDATE → SENT (background)
+     *   └── encrypt (~150 ms) → POST (~620 ms)
+     *                                       │
+     *                                       └── emit MESSAGE_SENT
+     *
+     * Returns `null` if the fast path can't run (encrypt declined, network
+     * threw, etc.) so the caller can fall back to the slow path.
+     */
+    private sendMessageFastPath;
     private serializeMessage;
     resendMessages(messages: Map<string, Message[]>): Promise<void>;
     /**

package/dist/services/message.js

@@ -202,6 +202,19 @@ export class MessageService {
             writable: true,
             value: void 0
         });
+        /**
+         * Message ids currently being sent via `sendMessageFastPath`. The row is
+         * WAITING_SESSION in the DB while the fast path runs INSERT + encrypt +
+         * POST in parallel. Without this guard, a concurrent `stateUpdate` could
+         * pick up the same WAITING_SESSION row via `processSendQueueForContact`
+         * and send a duplicate.
+         */
+        Object.defineProperty(this, "inFlightFastPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         this.messageProtocol = messageProtocol;
         this.session = session;
         this.eventEmitter = eventEmitter;
@@ -297,42 +310,44 @@ export class MessageService {
      * Add a message to SQLite and update the corresponding discussion.
      */
     async addMessageAndUpdateDiscussion(message) {
-        const messageId = await this.queries.messages.insert({
-            messageId: message.messageId,
-            ownerUserId: message.ownerUserId,
-            contactUserId: message.contactUserId,
-            content: message.content,
-            serializedContent: message.serializedContent,
-            type: message.type,
-            direction: message.direction,
-            status: message.status,
-            timestamp: message.timestamp,
-            metadata: serializeMetadata(message.metadata),
-            seeker: message.seeker,
-            replyTo: serializeReplyTo(message.replyTo),
-            forwardOf: serializeForwardOf(message.forwardOf),
-            deleteOf: serializeDeleteOf(message.deleteOf),
-            editOf: serializeEditOf(message.editOf),
-            reactionOf: serializeReactionOf(message.reactionOf),
-            encryptedMessage: message.encryptedMessage,
-            whenToSend: message.whenToSend,
-        });
-        const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId);
-        if (discussion &&
-            message.type !== MessageType.KEEP_ALIVE &&
-            message.type !== MessageType.REACTION &&
-            message.type !== MessageType.RETENTION_POLICY) {
-            await this.queries.discussions.updateById(discussion.id, {
-                lastMessageId: messageId,
-                lastMessageContent: message.content,
-                lastMessageTimestamp: message.timestamp,
-                updatedAt: new Date(),
+        return this.queries.conn.withTransaction(async () => {
+            const messageId = await this.queries.messages.insert({
+                messageId: message.messageId,
+                ownerUserId: message.ownerUserId,
+                contactUserId: message.contactUserId,
+                content: message.content,
+                serializedContent: message.serializedContent,
+                type: message.type,
+                direction: message.direction,
+                status: message.status,
+                timestamp: message.timestamp,
+                metadata: serializeMetadata(message.metadata),
+                seeker: message.seeker,
+                replyTo: serializeReplyTo(message.replyTo),
+                forwardOf: serializeForwardOf(message.forwardOf),
+                deleteOf: serializeDeleteOf(message.deleteOf),
+                editOf: serializeEditOf(message.editOf),
+                reactionOf: serializeReactionOf(message.reactionOf),
+                encryptedMessage: message.encryptedMessage,
+                whenToSend: message.whenToSend,
             });
-            if (message.direction === MessageDirection.INCOMING) {
-                await this.queries.discussions.incrementUnreadCount(discussion.id);
+            const discussion = await this.queries.discussions.getByOwnerAndContact(message.ownerUserId, message.contactUserId);
+            if (discussion &&
+                message.type !== MessageType.KEEP_ALIVE &&
+                message.type !== MessageType.REACTION &&
+                message.type !== MessageType.RETENTION_POLICY) {
+                await this.queries.discussions.updateById(discussion.id, {
+                    lastMessageId: messageId,
+                    lastMessageContent: message.content,
+                    lastMessageTimestamp: message.timestamp,
+                    updatedAt: new Date(),
+                });
+                if (message.direction === MessageDirection.INCOMING) {
+                    await this.queries.discussions.incrementUnreadCount(discussion.id);
+                }
             }
-        }
-        return messageId;
+            return messageId;
+        });
     }
     async decryptMessages(encrypted) {
         const log = logger.forMethod('decryptMessages');
@@ -647,7 +662,23 @@ export class MessageService {
                 : undefined;
             message.messageId = randomMessageId;
         }
-        // Add message as WAITING_SESSION
+        // Fast path: if the peer's session is already Active we can encrypt
+        // and ship the message in parallel with the local INSERT instead of
+        // waiting for `addMessageAndUpdateDiscussion` to commit before
+        // `processSendQueueForContact` even starts. The user-perceived
+        // latency drops from `INSERT + encrypt + POST` (sequential) to
+        // `max(INSERT, encrypt + POST)` — ~440 ms saved on prod where the
+        // network round-trip dominates.
+        const sessionStatus = this.session.peerSessionStatus(peerId);
+        if (sessionStatus === SessionStatus.Active) {
+            const fastPathResult = await this.sendMessageFastPath(message, peerId);
+            if (fastPathResult) {
+                return fastPathResult;
+            }
+            // Fast path bailed (encrypt returned null, etc.) — fall back to
+            // the slow path below.
+        }
+        // Slow path: INSERT first, let stateUpdate handle the encrypt + send.
         let messageId;
         try {
             messageId = await this.addMessageAndUpdateDiscussion({
@@ -676,6 +707,173 @@ export class MessageService {
             message: queuedMessage,
         };
     }
+    /**
+     * Happy-path send: peer session is Active, so we can encrypt locally,
+     * fire the network POST, and INSERT the row in parallel. The three
+     * pieces are independent up until the final `UPDATE → SENT`, which
+     * needs both the row id (from INSERT) and a successful network ack.
+     *
+     *   ┌── INSERT (~440 ms) ───────────────┐
+     *   │                                   ├── UPDATE → SENT (background)
+     *   └── encrypt (~150 ms) → POST (~620 ms)
+     *                                       │
+     *                                       └── emit MESSAGE_SENT
+     *
+     * Returns `null` if the fast path can't run (encrypt declined, network
+     * threw, etc.) so the caller can fall back to the slow path.
+     */
+    async sendMessageFastPath(message, peerId) {
+        const log = logger.forMethod('sendMessageFastPath');
+        // 1. Serialize synchronously — needed before encrypt.
+        const serializeResult = await this.serializeMessage(message);
+        if (!serializeResult.success) {
+            log.error('failed to serialize message for fast path', {
+                error: serializeResult.error,
+            });
+            return null;
+        }
+        const serializedContent = serializeResult.data;
+        // 2. Kick off the local INSERT and the encrypt in parallel.
+        //    encrypt is fast (~150 ms with rayon) and doesn't depend on
+        //    the row id; INSERT is slow (~440 ms) and only the row id is
+        //    later needed for the SENT update.
+        const insertPromise = this.addMessageAndUpdateDiscussion({
+            ...message,
+            status: MessageStatus.WAITING_SESSION,
+        })
+            .then(id => {
+            this.inFlightFastPath.add(id);
+            return id;
+        })
+            .catch(error => {
+            log.error('addMessageAndUpdateDiscussion failed in fast path', {
+                error,
+            });
+            return null;
+        });
+        let sendOutput;
+        try {
+            sendOutput = await this.session.sendMessage(peerId, serializedContent);
+        }
+        catch (error) {
+            log.error('session.sendMessage threw in fast path, falling back', {
+                error,
+            });
+            sendOutput = undefined;
+        }
+        if (!sendOutput) {
+            // Session became inactive between status check and encrypt.
+            // Wait for the INSERT to land then bail out so the slow path
+            // can take over.
+            const messageId = await insertPromise;
+            if (messageId === null) {
+                return {
+                    success: false,
+                    error: 'Failed to add message to database',
+                };
+            }
+            log.info('encrypt returned null in fast path, falling back to slow path', { messageId });
+            this.inFlightFastPath.delete(messageId);
+            void this.refreshService?.stateUpdate();
+            return {
+                success: true,
+                message: {
+                    ...message,
+                    id: messageId,
+                    status: MessageStatus.WAITING_SESSION,
+                },
+            };
+        }
+        // 3. Encrypt succeeded. Network POST runs in parallel with the
+        //    still-in-flight INSERT.
+        const networkPromise = this.messageProtocol
+            .sendMessage({
+            seeker: sendOutput.seeker,
+            ciphertext: sendOutput.data,
+        })
+            .then(() => true)
+            .catch(error => {
+            log.error('network send failed in fast path', { error });
+            return false;
+        });
+        const [messageId, networkOk] = await Promise.all([
+            insertPromise,
+            networkPromise,
+        ]);
+        if (messageId === null) {
+            return {
+                success: false,
+                error: 'Failed to add message to database',
+            };
+        }
+        if (!networkOk) {
+            // Network failed: persist READY so the next retry doesn't
+            // re-encrypt, and let stateUpdate pick it up.
+            this.inFlightFastPath.delete(messageId);
+            await this.queries.messages.updateById(messageId, {
+                status: MessageStatus.READY,
+                encryptedMessage: sendOutput.data,
+                seeker: sendOutput.seeker,
+                whenToSend: new Date(Date.now() + this.config.messages.retryDelayMs),
+                serializedContent,
+            });
+            void this.refreshService?.stateUpdate();
+            return {
+                success: true,
+                message: {
+                    ...message,
+                    id: messageId,
+                    status: MessageStatus.READY,
+                },
+            };
+        }
+        // 4. Both succeeded. Race-check then UPDATE → SENT.
+        const latestRow = await this.queries.messages.getById(messageId);
+        if (!latestRow || latestRow.status !== MessageStatus.WAITING_SESSION) {
+            log.debug('message gone or status changed during fast-path send, skipping SENT update', { messageId, currentStatus: latestRow?.status });
+            this.inFlightFastPath.delete(messageId);
+            return {
+                success: true,
+                message: {
+                    ...message,
+                    id: messageId,
+                    status: MessageStatus.SENT,
+                },
+            };
+        }
+        await this.queries.messages.updateById(messageId, {
+            status: MessageStatus.SENT,
+            seeker: sendOutput.seeker,
+            encryptedMessage: null,
+            serializedContent: null,
+            whenToSend: null,
+        });
+        this.inFlightFastPath.delete(messageId);
+        const isControlMessage = !!(message.deleteOf || message.editOf);
+        if (!isControlMessage) {
+            try {
+                this.eventEmitter.emit(SdkEventType.MESSAGE_SENT, {
+                    ...message,
+                    id: messageId,
+                    status: MessageStatus.SENT,
+                });
+            }
+            catch (error) {
+                log.error('failed to emit message sent event from fast path', {
+                    messageId,
+                    error,
+                });
+            }
+        }
+        return {
+            success: true,
+            message: {
+                ...message,
+                id: messageId,
+                status: MessageStatus.SENT,
+            },
+        };
+    }
     async serializeMessage(message) {
         const log = logger.forMethod('serializeMessage');
         if (!message.messageId &&
@@ -853,11 +1051,17 @@ export class MessageService {
             for (const msg of pendingMessages) {
                 if (!msg.id)
                     continue;
-                let currentStatus = msg.status;
+                if (this.inFlightFastPath.has(msg.id))
+                    continue;
+                const currentStatus = msg.status;
                 let encryptedMessage = msg.encryptedMessage;
                 let seeker = msg.seeker;
-                let whenToSend = msg.whenToSend;
-                // If the sessions is saturated it can't send messages on session manager
+                const whenToSend = msg.whenToSend;
+                // Happy path: WAITING_SESSION + Active session.
+                // Encrypt → network → SENT directly, skipping the intermediate
+                // READY SQL write. The READY block below still handles retries
+                // (delayed sends, post-failure retries), where the encrypted
+                // bytes need to survive a restart.
                 if (currentStatus === MessageStatus.WAITING_SESSION &&
                     sessionStatus === SessionStatus.Active) {
                     let serializedContent = msg.serializedContent;
@@ -883,22 +1087,73 @@ export class MessageService {
                     }
                     encryptedMessage = sendOutput.data;
                     seeker = sendOutput.seeker;
-                    whenToSend = new Date();
+                    // Try the network synchronously. On success, skip READY entirely
+                    // and write SENT in the background. On failure, fall back to
+                    // persisting READY so the next retry doesn't have to re-encrypt.
+                    try {
+                        await this.messageProtocol.sendMessage({
+                            seeker,
+                            ciphertext: encryptedMessage,
+                        });
+                    }
+                    catch (error) {
+                        log.error('network send failed for fresh message', {
+                            messageId: msg.id,
+                            error,
+                        });
+                        await this.queries.messages.updateById(msg.id, {
+                            status: MessageStatus.READY,
+                            encryptedMessage,
+                            seeker,
+                            whenToSend: new Date(Date.now() + this.config.messages.retryDelayMs),
+                            serializedContent,
+                        });
+                        continue;
+                    }
+                    // Network success. Race-check: most resets only touch
+                    // READY/SENT rows so they leave us alone, but the discussion
+                    // could have been deleted while we were on the wire — bail
+                    // out if the row is gone or has moved to a non-WAITING state.
+                    const latestRow = await this.queries.messages.getById(msg.id);
+                    if (!latestRow ||
+                        latestRow.status !== MessageStatus.WAITING_SESSION) {
+                        log.debug('message gone or status changed during network send, skipping SENT update', {
+                            messageId: msg.id,
+                            currentStatus: latestRow?.status,
+                        });
+                        continue;
+                    }
                     await this.queries.messages.updateById(msg.id, {
-                        status: MessageStatus.READY,
-                        encryptedMessage,
+                        status: MessageStatus.SENT,
                         seeker,
-                        whenToSend,
-                        serializedContent,
+                        encryptedMessage: null,
+                        serializedContent: null,
+                        whenToSend: null,
                     });
-                    currentStatus = MessageStatus.READY;
-                    log.debug('message updated to READY', {
+                    sentCount++;
+                    log.debug('message sent (skipped READY)', {
                         messageId: msg.id,
-                        status: currentStatus,
+                        status: MessageStatus.SENT,
                         content: msg.content,
                         type: msg.type,
                         direction: msg.direction,
                     });
+                    const isControlMessage = !!(msg.deleteOf || msg.editOf);
+                    if (!isControlMessage) {
+                        try {
+                            this.eventEmitter.emit(SdkEventType.MESSAGE_SENT, {
+                                ...msg,
+                                status: MessageStatus.SENT,
+                            });
+                        }
+                        catch (error) {
+                            log.error('failed to emit message sent event', {
+                                messageId: msg.id,
+                                error,
+                            });
+                        }
+                    }
+                    continue;
                 }
                 if (currentStatus === MessageStatus.READY) {
                     const sendAt = whenToSend ?? new Date();

package/dist/services/profile.d.ts

@@ -6,7 +6,6 @@
  */
 import { type UserProfile } from '../db/index.js';
 import { Queries } from '../db/queries/index.js';
-import { type ValidationResult } from '../utils/validation.js';
 export declare class ProfileService {
     private queries;
     constructor(queries: Queries);
@@ -16,7 +15,6 @@ export declare class ProfileService {
     getCount(): Promise<number>;
     save(profile: UserProfile): Promise<void>;
     delete(userId: string): Promise<void>;
-    validateUsername(username: string): Promise<ValidationResult>;
     isUsernameTaken(username: string, excludeUserId?: string): Promise<boolean>;
     createOrUpdate(username: string, userId: string, security: UserProfile['security'], session: Uint8Array): Promise<UserProfile>;
 }

package/dist/services/profile.js

@@ -5,7 +5,6 @@
  * Only requires Queries — no session needed, so it can be created at init() time.
  */
 import { rowToUserProfile, userProfileToRow, } from '../db/queries/index.js';
-import { validateUsernameFormatAndAvailability, } from '../utils/validation.js';
 export class ProfileService {
     constructor(queries) {
         Object.defineProperty(this, "queries", {
@@ -37,9 +36,6 @@ export class ProfileService {
     delete(userId) {
         return this.queries.userProfiles.delete(userId);
     }
-    validateUsername(username) {
-        return validateUsernameFormatAndAvailability(username, this.queries);
-    }
     async isUsernameTaken(username, excludeUserId) {
         const match = excludeUserId
             ? await this.queries.userProfiles.getByUsernameLowerExcluding(username, excludeUserId)

package/dist/utils/validation.d.ts

@@ -3,7 +3,6 @@
  *
  * Functions for validating user input like usernames, passwords, and user IDs.
  */
-import { Queries } from '../db/queries/index.js';
 export type ValidationResult = {
     valid: true;
     error?: never;
@@ -18,28 +17,13 @@ export type ValidationResult = {
  * @returns Validation result
  */
 export declare function validatePassword(value: string): ValidationResult;
-/**
- * Validate a username format (without checking availability)
- *
- * @param value - The username to validate
- * @returns Validation result
- */
-export declare function validateUsernameFormat(value: string): ValidationResult;
 /**
  * Validate a username is available (not already in use)
  *
- * @param value - The username to check
- * @returns Validation result
- */
-export declare function validateUsernameAvailability(value: string, queries: Queries): Promise<ValidationResult>;
-/**
- * Validate a username format and availability
- *
- * @param value - The username to validate
- * @param db - Database instance
- * @returns Validation result
- */
-export declare function validateUsernameFormatAndAvailability(value: string, queries: Queries): Promise<ValidationResult>;
+
+
+
+
 /**
  * Validate a user ID format (Bech32 gossip1... format)
  *

package/dist/utils/validation.js

@@ -22,72 +22,13 @@ export function validatePassword(value) {
     }
     return { valid: true };
 }
-/**
- * Validate a username format (without checking availability)
- *
- * @param value - The username to validate
- * @returns Validation result
- */
-export function validateUsernameFormat(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return { valid: false, error: 'Username is required' };
-    }
-    // Disallow any whitespace inside the username (single token only)
-    if (/\s/.test(trimmed)) {
-        return {
-            valid: false,
-            error: 'Username cannot contain spaces',
-        };
-    }
-    if (trimmed.length < 3) {
-        return {
-            valid: false,
-            error: 'Username must be at least 3 characters long',
-        };
-    }
-    return { valid: true };
-}
 /**
  * Validate a username is available (not already in use)
  *
- * @param value - The username to check
- * @returns Validation result
- */
-export async function validateUsernameAvailability(value, queries) {
-    try {
-        const existingProfile = await queries.userProfiles.getByUsernameLower(value);
-        if (existingProfile) {
-            return {
-                valid: false,
-                error: 'This username is already in use. Please choose another.',
-            };
-        }
-        return { valid: true };
-    }
-    catch (error) {
-        return {
-            valid: false,
-            error: error instanceof Error
-                ? error.message
-                : 'Unable to verify username availability. Please try again.',
-        };
-    }
-}
-/**
- * Validate a username format and availability
- *
- * @param value - The username to validate
- * @param db - Database instance
- * @returns Validation result
- */
-export async function validateUsernameFormatAndAvailability(value, queries) {
-    const result = validateUsernameFormat(value);
-    if (!result.valid) {
-        return result;
-    }
-    return await validateUsernameAvailability(value, queries);
-}
+
+
+
+
 /**
  * Validate a user ID format (Bech32 gossip1... format)
  *

package/package.json

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