@massalabs/gossip-sdk 0.0.2-dev.20260212071538 → 0.0.2-dev.20260217093203

package/README.md

@@ -125,8 +125,8 @@ const result = await sdk.messages.send({
 // Fetch new messages from server
 const fetchResult = await sdk.messages.fetch();
 
-// Find message by seeker
-const msg = await sdk.messages.findBySeeker(seeker, ownerUserId);
+// Find message by messageId
+const msg = await gossipSdk.messages.findByMsgId(messageId, ownerUserId);
 
 // Mark as read
 await sdk.messages.markAsRead(messageId);

package/dist/api/index.d.ts

@@ -0,0 +1 @@
+export { restMessageProtocol, RestMessageProtocol, type EncryptedMessage, } from './messageProtocol';

package/dist/api/index.js

@@ -0,0 +1 @@
+export { restMessageProtocol, RestMessageProtocol, } from './messageProtocol';

package/dist/api/messageProtocol/index.d.ts

@@ -4,16 +4,14 @@
  * Factory functions and exports for message protocol implementations.
  */
 export type { EncryptedMessage, IMessageProtocol, MessageProtocolResponse, BulletinItem, } from './types';
-export { RestMessageProtocol } from './rest';
-export { MessageProtocol } from './mock';
 import type { IMessageProtocol } from './types';
-import { type MessageProtocolType } from '../../config/protocol';
 /**
  * Factory function to create message protocol instances
  */
-export declare function createMessageProtocol(type?: MessageProtocolType, config?: Partial<{
+export declare function createMessageProtocol(config?: Partial<{
     baseUrl: string;
     timeout: number;
     retryAttempts: number;
 }>): IMessageProtocol;
 export declare const restMessageProtocol: IMessageProtocol;
+export { RestMessageProtocol } from './rest';

package/dist/api/messageProtocol/index.js

@@ -3,24 +3,13 @@
  *
  * Factory functions and exports for message protocol implementations.
  */
-export { RestMessageProtocol } from './rest';
-export { MessageProtocol } from './mock';
-import { defaultMessageProtocol, protocolConfig, } from '../../config/protocol';
+import { protocolConfig } from '../../config/protocol';
 import { RestMessageProtocol } from './rest';
-import { MessageProtocol } from './mock';
 /**
  * Factory function to create message protocol instances
  */
-export function createMessageProtocol(type = defaultMessageProtocol, config) {
-    switch (type) {
-        case 'rest': {
-            return new RestMessageProtocol(config?.baseUrl || protocolConfig.baseUrl, config?.timeout || 10000, config?.retryAttempts || 3);
-        }
-        case 'mock': {
-            return new MessageProtocol(config?.baseUrl || protocolConfig.baseUrl, config?.timeout || 10000, config?.retryAttempts || 3);
-        }
-        default:
-            throw new Error(`Unsupported message protocol type: ${type}`);
-    }
+export function createMessageProtocol(config) {
+    return new RestMessageProtocol(config?.baseUrl ?? protocolConfig.baseUrl, config?.timeout ?? protocolConfig.timeout, config?.retryAttempts ?? protocolConfig.retryAttempts);
 }
 export const restMessageProtocol = createMessageProtocol();
+export { RestMessageProtocol } from './rest';

package/dist/crypto/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bip39';
+export * from './encryption';

package/dist/crypto/index.js

@@ -0,0 +1,2 @@
+export * from './bip39';
+export * from './encryption';

package/dist/db.d.ts

@@ -6,6 +6,7 @@
  */
 import Dexie, { Table } from 'dexie';
 export type AuthMethod = 'capacitor' | 'webauthn' | 'password';
+export declare const MESSAGE_ID_SIZE = 12;
 export interface Contact {
     id?: number;
     ownerUserId: string;
@@ -19,6 +20,7 @@ export interface Contact {
 }
 export interface Message {
     id?: number;
+    messageId?: Uint8Array;
     ownerUserId: string;
     contactUserId: string;
     content: string;
@@ -32,12 +34,11 @@ export interface Message {
     metadata?: Record<string, unknown>;
     seeker?: Uint8Array;
     replyTo?: {
-        originalContent?: string;
-        originalSeeker: Uint8Array;
+        originalMsgId: Uint8Array;
     };
     forwardOf?: {
         originalContent?: string;
-        originalSeeker: Uint8Array;
+        originalContactId?: Uint8Array;
     };
 }
 export interface UserProfile {

package/dist/db.js

@@ -5,6 +5,8 @@
  * Provides tables for contacts, messages, discussions, user profiles, and more.
  */
 import Dexie from 'dexie';
+// Constants
+export const MESSAGE_ID_SIZE = 12;
 export var DiscussionDirection;
 (function (DiscussionDirection) {
     DiscussionDirection["RECEIVED"] = "received";

package/dist/{gossipSdk.d.ts → gossip.d.ts}

@@ -174,8 +174,8 @@ interface MessageServiceAPI {
     send(message: Omit<Message, 'id'>): Promise<SendMessageResult>;
     /** Fetch and decrypt messages from the protocol */
     fetch(): Promise<MessageResult>;
-    /** Find a message by its seeker */
-    findBySeeker(seeker: Uint8Array, ownerUserId: string): Promise<Message | undefined>;
+    /** Find a message by its messageId */
+    findByMsgId(messageId: Uint8Array, ownerUserId: string, contactUserId?: string): Promise<Message | undefined>;
     /** Mark a message as read */
     markAsRead(id: number): Promise<boolean>;
 }

package/dist/{gossipSdk.js → gossip.js}

@@ -60,9 +60,6 @@ import { SessionManagerWrapper, } from './wasm/bindings';
 import { SdkEventEmitter, SdkEventType, } from './core/SdkEventEmitter';
 import { SdkPolling } from './core/SdkPolling';
 export { SdkEventType };
-// ─────────────────────────────────────────────────────────────────────────────
-// Types
-// ─────────────────────────────────────────────────────────────────────────────
 export var SdkStatus;
 (function (SdkStatus) {
     SdkStatus["UNINITIALIZED"] = "uninitialized";
@@ -270,7 +267,7 @@ class GossipSdk {
                 return result;
             }),
             fetch: () => this._message.fetchMessages(),
-            findBySeeker: (seeker, ownerUserId) => this._message.findMessageBySeeker(seeker, ownerUserId),
+            findByMsgId: (messageId, ownerUserId, contactUserId) => this._message.findMessageByMsgId(messageId, ownerUserId, contactUserId),
             markAsRead: id => this._message.markAsRead(id),
         };
         this._discussionsAPI = {

package/dist/index.d.ts

@@ -12,21 +12,9 @@
  *
  * @packageDocumentation
  */
-export { createGossipSdk, GossipSdk, SdkEventType } from './gossipSdk';
-export type { GossipSdkInitOptions, OpenSessionOptions, SdkEventHandlers, } from './gossipSdk';
+export * from './api';
+export * from './crypto';
 export * from './db';
-export * from './utils/userId';
-export * from './utils/base64';
-export * from './utils/validation';
-export * from './utils/announcementPayload';
-export * from './utils/discussions';
-export * from './utils/contacts';
-export type { Result } from './utils/type';
-export * from './crypto/bip39';
-export * from './crypto/encryption';
-export * from './wasm/encryption';
-export * from './wasm/userKeys';
-export { SessionStatus, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './wasm/bindings';
-export { restMessageProtocol, RestMessageProtocol, } from './api/messageProtocol';
-export type { EncryptedMessage } from './api/messageProtocol';
-export type { PublicKeyResult } from './services/auth';
+export * from './gossip';
+export * from './utils';
+export * from './wasm';

package/dist/index.js

@@ -12,35 +12,9 @@
  *
  * @packageDocumentation
  */
-// ─────────────────────────────────────────────────────────────────────────────
-// SDK — Primary API
-// ─────────────────────────────────────────────────────────────────────────────
-export { createGossipSdk, GossipSdk, SdkEventType } from './gossipSdk';
-// ─────────────────────────────────────────────────────────────────────────────
-// Database — entity types, enums, database class
-// ─────────────────────────────────────────────────────────────────────────────
+export * from './api';
+export * from './crypto';
 export * from './db';
-// ─────────────────────────────────────────────────────────────────────────────
-// Utilities — export entire modules (safe: pure functions / types)
-// ─────────────────────────────────────────────────────────────────────────────
-export * from './utils/userId';
-export * from './utils/base64';
-export * from './utils/validation';
-export * from './utils/announcementPayload';
-export * from './utils/discussions';
-export * from './utils/contacts';
-// ─────────────────────────────────────────────────────────────────────────────
-// Crypto — key generation, encryption, mnemonic
-// ─────────────────────────────────────────────────────────────────────────────
-export * from './crypto/bip39';
-export * from './crypto/encryption';
-export * from './wasm/encryption';
-export * from './wasm/userKeys';
-// ─────────────────────────────────────────────────────────────────────────────
-// WASM bindings — session status, public keys, protocol outputs
-// ─────────────────────────────────────────────────────────────────────────────
-export { SessionStatus, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './wasm/bindings';
-// ─────────────────────────────────────────────────────────────────────────────
-// Protocol
-// ─────────────────────────────────────────────────────────────────────────────
-export { restMessageProtocol, RestMessageProtocol, } from './api/messageProtocol';
+export * from './gossip';
+export * from './utils';
+export * from './wasm';

package/dist/proto/generated/message.d.ts

@@ -0,0 +1,18 @@
+export declare enum MessageType {
+    MESSAGE_TYPE_REGULAR = 0,
+    MESSAGE_TYPE_REPLY = 1,
+    MESSAGE_TYPE_FORWARD = 2,
+    MESSAGE_TYPE_KEEP_ALIVE = 3
+}
+export interface Message {
+    messageType?: MessageType;
+    messageId?: Uint8Array;
+    content?: string;
+    citedMsgId?: Uint8Array;
+    citedContactId?: Uint8Array;
+    forwardedContent?: string;
+}
+export declare const Message: {
+    encode(message: Message): Uint8Array;
+    decode(buffer: Uint8Array): Message;
+};

package/dist/proto/generated/message.js

@@ -0,0 +1,141 @@
+// Generated by protoc from: src/proto/message.proto
+// Do not edit manually.
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["MESSAGE_TYPE_REGULAR"] = 0] = "MESSAGE_TYPE_REGULAR";
+    MessageType[MessageType["MESSAGE_TYPE_REPLY"] = 1] = "MESSAGE_TYPE_REPLY";
+    MessageType[MessageType["MESSAGE_TYPE_FORWARD"] = 2] = "MESSAGE_TYPE_FORWARD";
+    MessageType[MessageType["MESSAGE_TYPE_KEEP_ALIVE"] = 3] = "MESSAGE_TYPE_KEEP_ALIVE";
+})(MessageType || (MessageType = {}));
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function encodeVarint(value, out) {
+    let v = value >>> 0;
+    while (v >= 0x80) {
+        out.push((v & 0x7f) | 0x80);
+        v >>>= 7;
+    }
+    out.push(v);
+}
+function decodeVarint(buffer, offset) {
+    let result = 0;
+    let shift = 0;
+    let pos = offset;
+    while (pos < buffer.length) {
+        const byte = buffer[pos++];
+        result |= (byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            return { value: result >>> 0, offset: pos };
+        }
+        shift += 7;
+        if (shift > 35) {
+            throw new Error('Varint too long');
+        }
+    }
+    throw new Error('Truncated varint');
+}
+function writeBytes(fieldNumber, bytes, out) {
+    encodeVarint((fieldNumber << 3) | 2, out);
+    encodeVarint(bytes.length, out);
+    for (let i = 0; i < bytes.length; i++) {
+        out.push(bytes[i]);
+    }
+}
+function writeString(fieldNumber, value, out) {
+    const bytes = textEncoder.encode(value);
+    writeBytes(fieldNumber, bytes, out);
+}
+function skipField(wireType, buffer, offset) {
+    switch (wireType) {
+        case 0: {
+            return decodeVarint(buffer, offset).offset;
+        }
+        case 2: {
+            const { value: length, offset: nextOffset } = decodeVarint(buffer, offset);
+            return nextOffset + length;
+        }
+        default:
+            throw new Error(`Unsupported wire type: ${wireType}`);
+    }
+}
+export const Message = {
+    encode(message) {
+        const out = [];
+        if (message.messageType !== undefined) {
+            encodeVarint(1 << 3, out);
+            encodeVarint(message.messageType, out);
+        }
+        if (message.messageId !== undefined) {
+            writeBytes(2, message.messageId, out);
+        }
+        if (message.content !== undefined) {
+            writeString(3, message.content, out);
+        }
+        if (message.citedMsgId !== undefined) {
+            writeBytes(4, message.citedMsgId, out);
+        }
+        if (message.citedContactId !== undefined) {
+            writeBytes(5, message.citedContactId, out);
+        }
+        if (message.forwardedContent !== undefined) {
+            writeString(6, message.forwardedContent, out);
+        }
+        return new Uint8Array(out);
+    },
+    decode(buffer) {
+        const message = { content: '' };
+        let offset = 0;
+        while (offset < buffer.length) {
+            const { value: key, offset: nextOffset } = decodeVarint(buffer, offset);
+            offset = nextOffset;
+            const fieldNumber = key >> 3;
+            const wireType = key & 0x7;
+            switch (fieldNumber) {
+                case 1: {
+                    const result = decodeVarint(buffer, offset);
+                    message.messageType = result.value;
+                    offset = result.offset;
+                    break;
+                }
+                case 2: {
+                    const { value: length, offset: lengthOffset } = decodeVarint(buffer, offset);
+                    const end = lengthOffset + length;
+                    message.messageId = buffer.slice(lengthOffset, end);
+                    offset = end;
+                    break;
+                }
+                case 3: {
+                    const { value: length, offset: lengthOffset } = decodeVarint(buffer, offset);
+                    const end = lengthOffset + length;
+                    message.content = textDecoder.decode(buffer.slice(lengthOffset, end));
+                    offset = end;
+                    break;
+                }
+                case 4: {
+                    const { value: length, offset: lengthOffset } = decodeVarint(buffer, offset);
+                    const end = lengthOffset + length;
+                    message.citedMsgId = buffer.slice(lengthOffset, end);
+                    offset = end;
+                    break;
+                }
+                case 5: {
+                    const { value: length, offset: lengthOffset } = decodeVarint(buffer, offset);
+                    const end = lengthOffset + length;
+                    message.citedContactId = buffer.slice(lengthOffset, end);
+                    offset = end;
+                    break;
+                }
+                case 6: {
+                    const { value: length, offset: lengthOffset } = decodeVarint(buffer, offset);
+                    const end = lengthOffset + length;
+                    message.forwardedContent = textDecoder.decode(buffer.slice(lengthOffset, end));
+                    offset = end;
+                    break;
+                }
+                default:
+                    offset = skipField(wireType, buffer, offset);
+            }
+        }
+        return message;
+    },
+};

package/dist/services/auth.d.ts

@@ -6,13 +6,6 @@
 import { UserPublicKeys } from '../wasm/bindings';
 import { IMessageProtocol } from '../api/messageProtocol/types';
 import { type GossipDatabase } from '../db';
-export type PublicKeyResult = {
-    publicKey: UserPublicKeys;
-    error?: never;
-} | {
-    publicKey?: never;
-    error: string;
-};
 export declare class AuthService {
     private db;
     messageProtocol: IMessageProtocol;
@@ -21,7 +14,7 @@ export declare class AuthService {
      * Fetch public key by userId
      * @param userId - Bech32-encoded userId (e.g., "gossip1...")
      */
-    fetchPublicKeyByUserId(userId: string): Promise<PublicKeyResult>;
+    fetchPublicKeyByUserId(userId: string): Promise<UserPublicKeys>;
     /**
      * Ensure public key is published (check first, then publish if needed).
      * If no user profile exists, the key is still published so the gossip ID is discoverable.

package/dist/services/auth.js

@@ -28,14 +28,10 @@ export class AuthService {
     async fetchPublicKeyByUserId(userId) {
         try {
             const base64PublicKey = await this.messageProtocol.fetchPublicKeyByUserId(decodeUserId(userId));
-            return {
-                publicKey: UserPublicKeys.from_bytes(decodeFromBase64(base64PublicKey)),
-            };
+            return UserPublicKeys.from_bytes(decodeFromBase64(base64PublicKey));
         }
         catch (err) {
-            return {
-                error: getPublicKeyErrorMessage(err),
-            };
+            throw new Error(getPublicKeyErrorMessage(err));
         }
     }
     /**

package/dist/services/message.d.ts

@@ -35,28 +35,30 @@ export declare class MessageService {
     private decryptMessages;
     private storeDecryptedMessages;
     /**
-     * Check if a message is a duplicate based on content and timestamp.
+     * Checks for duplicate incoming messages in the message database based on messageId.
      *
-     * A message is considered duplicate if:
-     * - Same sender (contactUserId)
-     * - Same content
-     * - Incoming direction
-     * - Timestamp within deduplication window (default 30 seconds)
+     * A message is considered a duplicate if:
+     * - It has the same messageId
+     * - It is from the same sender (contactUserId)
+     * - Belongs to the same conversation (ownerUserId)
      *
-     * This handles the edge case where:
-     * 1. Sender sends message successfully to network
-     * 2. Sender app crashes before updating DB status to SENT
-     * 3. On restart, message is reset to WAITING_SESSION and re-sent
-     * 4. Receiver gets the same message twice with different seekers
+     * This protects against scenarios where:
+     * 1. A sender successfully delivers a message to the network,
+     * 2. Their app crashes or resets before marking the message as SENT in the local DB,
+     * 3. On restart, the sender's app re-sends the message (possibly with a different seeker),
+     * 4. The receiver gets the same message twice,
+     * 5. Duplicates are prevented by matching messageId byte-for-byte.
      *
-     * @param ownerUserId - The owner's user ID
-     * @param contactUserId - The sender's user ID
-     * @param content - The message content
-     * @param timestamp - The message timestamp
-     * @returns true if a duplicate exists
+     * This method uses messageId (usually a 12-byte random value) for exact match detection.
+     * If a duplicate is found, it updates certain fields (e.g., content, replyTo, forwardOf)
+     * on the existing message and returns true.
+     *
+     * @param message - The incoming decrypted message object.
+     * @param ownerUserId - The userId of the message database owner (the recipient).
+     * @returns true if a duplicate message (by messageId) was found; otherwise false.
      */
-    private isDuplicateMessage;
-    findMessageBySeeker(seeker: Uint8Array, ownerUserId: string): Promise<Message | undefined>;
+    private handleDuplicateMessageId;
+    findMessageByMsgId(messageId: Uint8Array, ownerUserId: string, contactUserId?: string): Promise<Message | undefined>;
     private acknowledgeMessages;
     sendMessage(message: Message): Promise<SendMessageResult>;
     private serializeMessage;

package/dist/services/message.js

@@ -4,7 +4,7 @@
  * Handles fetching encrypted messages from the protocol and decrypting them.
  * This service works both in host app contexts and SDK/automation context.
  */
-import { MessageDirection, MessageStatus, MessageType, } from '../db';
+import { MessageDirection, MessageStatus, MessageType, MESSAGE_ID_SIZE, } from '../db';
 import { decodeUserId, encodeUserId } from '../utils/userId';
 import { SessionStatus } from '../wasm/bindings';
 import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, deserializeMessage, } from '../utils/messageSerialization';
@@ -167,25 +167,22 @@ export class MessageService {
                     if (deserialized.type === MessageType.KEEP_ALIVE) {
                         continue;
                     }
+                    if (!deserialized.messageId ||
+                        deserialized.messageId.length !== MESSAGE_ID_SIZE) {
+                        log.warn('missing or invalid messageId, skipping message', {
+                            messageId: deserialized.messageId,
+                        });
+                    }
                     decrypted.push({
                         content: deserialized.content,
                         sentAt: new Date(Number(out.timestamp)),
                         senderId: encodeUserId(out.user_id),
                         seeker: msg.seeker,
+                        messageId: deserialized.messageId ?? new Uint8Array(),
                         encryptedMessage: msg.ciphertext,
                         type: deserialized.type,
-                        replyTo: deserialized.replyTo
-                            ? {
-                                originalContent: deserialized.replyTo.originalContent,
-                                originalSeeker: deserialized.replyTo.originalSeeker,
-                            }
-                            : undefined,
-                        forwardOf: deserialized.forwardOf
-                            ? {
-                                originalContent: deserialized.forwardOf.originalContent,
-                                originalSeeker: deserialized.forwardOf.originalSeeker,
-                            }
-                            : undefined,
+                        replyTo: deserialized.replyTo,
+                        forwardOf: deserialized.forwardOf,
                     });
                 }
                 catch (deserializationError) {
@@ -219,27 +216,22 @@ export class MessageService {
                     });
                     return null;
                 }
-                // Check for duplicate message (same content + similar timestamp from same sender)
-                // This handles edge case: app crashes after network send but before DB update,
-                // message gets re-sent on restart, peer receives duplicate
-                const isDuplicate = await this.isDuplicateMessage(ownerUserId, message.senderId, message.content, message.sentAt);
+                // If received msg has same messageId as a previously received msg
+                const isDuplicate = await this.handleDuplicateMessageId(message, ownerUserId);
                 if (isDuplicate) {
-                    log.info('skipping duplicate message', {
+                    log.info('Duplicate message received, skipping', {
                         senderId: message.senderId,
                         preview: message.content.slice(0, 30),
-                        timestamp: message.sentAt.toISOString(),
                     });
                     return null;
                 }
-                let replyToMessageId;
-                if (message.replyTo?.originalSeeker) {
-                    const original = await this.findMessageBySeeker(message.replyTo.originalSeeker, ownerUserId);
+                if (message.replyTo?.originalMsgId) {
+                    const original = await this.findMessageByMsgId(message.replyTo.originalMsgId, ownerUserId, message.senderId);
                     if (!original) {
                         log.warn('reply target not found', {
-                            originalSeeker: encodeToBase64(message.replyTo.originalSeeker),
+                            originalMsgId: encodeToBase64(message.replyTo.originalMsgId),
                         });
                     }
-                    replyToMessageId = original?.id;
                 }
                 const id = await this.db.messages.add({
                     ownerUserId,
@@ -250,24 +242,16 @@ export class MessageService {
                     status: MessageStatus.DELIVERED,
                     timestamp: message.sentAt,
                     metadata: {},
-                    seeker: message.seeker, // Store the seeker of the incoming message
+                    messageId: message.messageId,
                     replyTo: message.replyTo
                         ? {
-                            // Store the original content as a fallback only if we couldn't find
-                            // the original message in the database (replyToMessageId is undefined).
-                            // If the original message exists, we don't need to store the content
-                            // since we can fetch it using the originalSeeker.
-                            originalContent: replyToMessageId
-                                ? undefined
-                                : message.replyTo.originalContent,
-                            // Store the seeker (used to find the original message)
-                            originalSeeker: message.replyTo.originalSeeker,
+                            originalMsgId: message.replyTo.originalMsgId,
                         }
                         : undefined,
                     forwardOf: message.forwardOf
                         ? {
                             originalContent: message.forwardOf.originalContent,
-                            originalSeeker: message.forwardOf.originalSeeker,
+                            originalContactId: message.forwardOf.originalContactId,
                         }
                         : undefined,
                 });
@@ -296,45 +280,74 @@ export class MessageService {
         return storedIds;
     }
     /**
-     * Check if a message is a duplicate based on content and timestamp.
+     * Checks for duplicate incoming messages in the message database based on messageId.
      *
-     * A message is considered duplicate if:
-     * - Same sender (contactUserId)
-     * - Same content
-     * - Incoming direction
-     * - Timestamp within deduplication window (default 30 seconds)
+     * A message is considered a duplicate if:
+     * - It has the same messageId
+     * - It is from the same sender (contactUserId)
+     * - Belongs to the same conversation (ownerUserId)
      *
-     * This handles the edge case where:
-     * 1. Sender sends message successfully to network
-     * 2. Sender app crashes before updating DB status to SENT
-     * 3. On restart, message is reset to WAITING_SESSION and re-sent
-     * 4. Receiver gets the same message twice with different seekers
+     * This protects against scenarios where:
+     * 1. A sender successfully delivers a message to the network,
+     * 2. Their app crashes or resets before marking the message as SENT in the local DB,
+     * 3. On restart, the sender's app re-sends the message (possibly with a different seeker),
+     * 4. The receiver gets the same message twice,
+     * 5. Duplicates are prevented by matching messageId byte-for-byte.
      *
-     * @param ownerUserId - The owner's user ID
-     * @param contactUserId - The sender's user ID
-     * @param content - The message content
-     * @param timestamp - The message timestamp
-     * @returns true if a duplicate exists
+     * This method uses messageId (usually a 12-byte random value) for exact match detection.
+     * If a duplicate is found, it updates certain fields (e.g., content, replyTo, forwardOf)
+     * on the existing message and returns true.
+     *
+     * @param message - The incoming decrypted message object.
+     * @param ownerUserId - The userId of the message database owner (the recipient).
+     * @returns true if a duplicate message (by messageId) was found; otherwise false.
      */
-    async isDuplicateMessage(ownerUserId, contactUserId, content, timestamp) {
-        const windowMs = this.config.messages.deduplicationWindowMs;
-        const windowStart = new Date(timestamp.getTime() - windowMs);
-        const windowEnd = new Date(timestamp.getTime() + windowMs);
-        // Query for messages from same sender with same content within time window
-        const existing = await this.db.messages
-            .where('[ownerUserId+contactUserId]')
-            .equals([ownerUserId, contactUserId])
-            .and(msg => msg.direction === MessageDirection.INCOMING &&
-            msg.content === content &&
-            msg.timestamp >= windowStart &&
-            msg.timestamp <= windowEnd)
-            .first();
-        return existing !== undefined;
+    async handleDuplicateMessageId(message, ownerUserId) {
+        // Check for duplicate message using messageId (12 bytes random)
+        if (message.messageId) {
+            const existingWithMessageId = await this.db.messages
+                .where('[ownerUserId+contactUserId]')
+                .equals([ownerUserId, message.senderId])
+                .and(m => {
+                if (!m.messageId || !message.messageId)
+                    return false;
+                if (m.messageId.length !== message.messageId.length)
+                    return false;
+                for (let i = 0; i < m.messageId.length; i++) {
+                    if (m.messageId[i] !== message.messageId[i])
+                        return false;
+                }
+                return true;
+            })
+                .first();
+            if (existingWithMessageId) {
+                await this.db.messages.update(existingWithMessageId.id, {
+                    content: message.content,
+                    replyTo: message.replyTo,
+                    forwardOf: message.forwardOf,
+                });
+                return true;
+            }
+        }
+        return false;
     }
-    async findMessageBySeeker(seeker, ownerUserId) {
-        return await this.db.messages
-            .where('[ownerUserId+seeker]')
-            .equals([ownerUserId, seeker])
+    async findMessageByMsgId(messageId, ownerUserId, contactUserId) {
+        const baseQuery = contactUserId
+            ? this.db.messages
+                .where('[ownerUserId+contactUserId]')
+                .equals([ownerUserId, contactUserId])
+            : this.db.messages.where('ownerUserId').equals(ownerUserId);
+        return await baseQuery
+            .and(m => {
+            if (!m.messageId || m.messageId.length !== messageId.length) {
+                return false;
+            }
+            for (let i = 0; i < messageId.length; i++) {
+                if (m.messageId[i] !== messageId[i])
+                    return false;
+            }
+            return true;
+        })
             .first();
     }
     async acknowledgeMessages(seekers, userId) {
@@ -349,8 +362,8 @@ export class MessageService {
                 seekers.has(encodeToBase64(message.seeker)))
                 .modify({
                 status: MessageStatus.DELIVERED,
-                encryptedMessage: undefined,
-                whenToSend: undefined,
+                serializedContent: undefined,
+                seeker: undefined,
             });
             // After marking as DELIVERED, clean up DELIVERED keep-alive messages
             await this.db.messages
@@ -393,6 +406,10 @@ export class MessageService {
                 return new Error('Discussion not found');
             }
             try {
+                const randomMessageId = message.type !== MessageType.KEEP_ALIVE
+                    ? crypto.getRandomValues(new Uint8Array(MESSAGE_ID_SIZE))
+                    : undefined;
+                message.messageId = randomMessageId;
                 messageId = await this.db.addMessage({
                     ...message,
                     status: MessageStatus.WAITING_SESSION,
@@ -417,8 +434,14 @@ export class MessageService {
     }
     async serializeMessage(message) {
         const log = logger.forMethod('serializeMessage');
-        if (message.replyTo?.originalSeeker) {
-            const originalMessage = await this.findMessageBySeeker(message.replyTo.originalSeeker, message.ownerUserId);
+        if (!message.messageId && message.type !== MessageType.KEEP_ALIVE) {
+            return {
+                success: false,
+                error: 'Message ID is required',
+            };
+        }
+        if (message.replyTo) {
+            const originalMessage = await this.findMessageByMsgId(message.replyTo.originalMsgId, message.ownerUserId);
             if (!originalMessage) {
                 return {
                     success: false,
@@ -427,7 +450,7 @@ export class MessageService {
             }
             return {
                 success: true,
-                data: serializeReplyMessage(message.content, originalMessage.content, message.replyTo.originalSeeker),
+                data: serializeReplyMessage(message.content, message.replyTo.originalMsgId, message.messageId),
             };
         }
         else if (message.type === MessageType.KEEP_ALIVE) {
@@ -436,12 +459,11 @@ export class MessageService {
                 data: serializeKeepAliveMessage(),
             };
         }
-        else if (message.forwardOf?.originalContent &&
-            message.forwardOf.originalSeeker) {
+        else if (message.forwardOf) {
             try {
                 return {
                     success: true,
-                    data: serializeForwardMessage(message.forwardOf.originalContent, message.content, message.forwardOf.originalSeeker),
+                    data: serializeForwardMessage(message.forwardOf.originalContent ?? '', message.content, message.messageId, message.forwardOf.originalContactId),
                 };
             }
             catch (error) {
@@ -456,7 +478,7 @@ export class MessageService {
             // Regular message with type tag
             return {
                 success: true,
-                data: serializeRegularMessage(message.content),
+                data: serializeRegularMessage(message.content, message.messageId),
             };
         }
     }
@@ -633,6 +655,8 @@ export class MessageService {
                                 ) {
                                     await this.db.messages.update(msg.id, {
                                         status: MessageStatus.SENT,
+                                        encryptedMessage: undefined,
+                                        whenToSend: undefined,
                                     });
                                     return true;
                                 }

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './announcementPayload';
+export * from './base64';
+export * from './contacts';
+export * from './discussions';
+export * from './queue';
+export * from './type';
+export * from './userId';
+export * from './validation';

package/dist/utils/index.js

@@ -0,0 +1,8 @@
+export * from './announcementPayload';
+export * from './base64';
+export * from './contacts';
+export * from './discussions';
+export * from './queue';
+export * from './type';
+export * from './userId';
+export * from './validation';

package/dist/utils/messageSerialization.d.ts

@@ -5,16 +5,17 @@
  * Supports regular text messages, replies, forwards, and keep-alive messages.
  */
 import { MessageType } from '../db';
-export declare const MESSAGE_TYPE_KEEP_ALIVE = 3;
+import { MessageType as ProtoMessageType } from '../proto/generated/message';
+export declare const MESSAGE_TYPE_KEEP_ALIVE = ProtoMessageType.MESSAGE_TYPE_KEEP_ALIVE;
 export interface DeserializedMessage {
     content: string;
+    messageId?: Uint8Array;
     replyTo?: {
-        originalContent: string;
-        originalSeeker: Uint8Array;
+        originalMsgId: Uint8Array;
     };
     forwardOf?: {
         originalContent: string;
-        originalSeeker: Uint8Array;
+        originalContactId?: Uint8Array;
     };
     type: MessageType;
 }
@@ -26,34 +27,36 @@ export declare function serializeKeepAliveMessage(): Uint8Array;
 /**
  * Serialize a regular text message
  *
- * Format: [type: 1 byte][content: variable]
+ * Format: [type: 1 byte][messageId: 12 bytes][content: variable]
  *
  * @param content - The message content string
+ * @param messageId - 12-byte random message ID
  * @returns Serialized message bytes
  */
-export declare function serializeRegularMessage(content: string): Uint8Array;
+export declare function serializeRegularMessage(content: string, messageId: Uint8Array): Uint8Array;
 /**
  * Serialize a reply message
  *
- * Format: [type: 1 byte][originalContentLen: 4 bytes][originalContent][seeker: 34 bytes][newContent]
+ * Format: protobuf Message with citedMsgId set
  *
  * @param newContent - The reply content
- * @param originalContent - The content being replied to
- * @param originalSeeker - The seeker of the original message
+ * @param originalMsgId - The messageId of the message being replied to
+ * @param messageId - 12-byte random message ID
  * @returns Serialized reply message bytes
  */
-export declare function serializeReplyMessage(newContent: string, originalContent: string, originalSeeker: Uint8Array): Uint8Array;
+export declare function serializeReplyMessage(newContent: string, originalMsgId: Uint8Array, messageId: Uint8Array): Uint8Array;
 /**
  * Serialize a forward message
  *
- * Format: [type: 1 byte][forwardContentLen: 4 bytes][forwardContent][seeker: 34 bytes][newContent]
+ * Format: protobuf Message with citedContactId set
  *
- * @param forwardContent - The content being forwarded
+ * @param forwardedContent - The content being forwarded
  * @param newContent - Optional new content to add (empty string if none)
- * @param originalSeeker - The seeker of the original message
+ * @param originalContactId - The contact ID (32 bytes) of the original message
+ * @param messageId - 12-byte random message ID
  * @returns Serialized forward message bytes
  */
-export declare function serializeForwardMessage(forwardContent: string, newContent: string, originalSeeker: Uint8Array): Uint8Array;
+export declare function serializeForwardMessage(forwardedContent: string, newContent: string, messageId: Uint8Array, originalContactId?: Uint8Array): Uint8Array;
 /**
  * Deserialize a message from bytes
  *

package/dist/utils/messageSerialization.js

@@ -4,110 +4,87 @@
  * Functions for serializing and deserializing messages for the protocol.
  * Supports regular text messages, replies, forwards, and keep-alive messages.
  */
-import { strToBytes, bytesToStr, U32 } from '@massalabs/massa-web3';
-import { MessageType } from '../db';
-// Message type constants (protocol-level)
-const MESSAGE_TYPE_REGULAR = 0x00;
-const MESSAGE_TYPE_REPLY = 0x01;
-const MESSAGE_TYPE_FORWARD = 0x02;
-export const MESSAGE_TYPE_KEEP_ALIVE = 0x03;
-// Seeker size: 1 byte length prefix + 32 bytes hash + 1 byte key index
-const SEEKER_SIZE = 34;
+import { MessageType, MESSAGE_ID_SIZE } from '../db';
+import { Message as ProtoMessage, MessageType as ProtoMessageType, } from '../proto/generated/message';
+export const MESSAGE_TYPE_KEEP_ALIVE = ProtoMessageType.MESSAGE_TYPE_KEEP_ALIVE;
 /**
  * Serialize a keep-alive message
  * Keep-alive messages are used to maintain session activity
  */
 export function serializeKeepAliveMessage() {
-    return new Uint8Array([MESSAGE_TYPE_KEEP_ALIVE]);
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_KEEP_ALIVE,
+        content: '',
+    });
 }
 /**
  * Serialize a regular text message
  *
- * Format: [type: 1 byte][content: variable]
+ * Format: [type: 1 byte][messageId: 12 bytes][content: variable]
  *
  * @param content - The message content string
+ * @param messageId - 12-byte random message ID
  * @returns Serialized message bytes
  */
-export function serializeRegularMessage(content) {
-    const contentBytes = strToBytes(content);
-    const result = new Uint8Array(1 + contentBytes.length);
-    result[0] = MESSAGE_TYPE_REGULAR;
-    result.set(contentBytes, 1);
-    return result;
+export function serializeRegularMessage(content, messageId) {
+    if (messageId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`messageId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_REGULAR,
+        messageId,
+        content,
+    });
 }
 /**
  * Serialize a reply message
  *
- * Format: [type: 1 byte][originalContentLen: 4 bytes][originalContent][seeker: 34 bytes][newContent]
+ * Format: protobuf Message with citedMsgId set
  *
  * @param newContent - The reply content
- * @param originalContent - The content being replied to
- * @param originalSeeker - The seeker of the original message
+ * @param originalMsgId - The messageId of the message being replied to
+ * @param messageId - 12-byte random message ID
  * @returns Serialized reply message bytes
  */
-export function serializeReplyMessage(newContent, originalContent, originalSeeker) {
-    const newContentBytes = strToBytes(newContent);
-    const originalContentBytes = strToBytes(originalContent);
-    const originalContentLenBytes = U32.toBytes(BigInt(originalContentBytes.length));
-    // Calculate total size
-    const totalSize = 1 + // type
-        originalContentLenBytes.length + // length prefix (4 bytes)
-        originalContentBytes.length + // original content
-        SEEKER_SIZE + // seeker
-        newContentBytes.length; // new content
-    const result = new Uint8Array(totalSize);
-    let offset = 0;
-    // Type byte
-    result[offset++] = MESSAGE_TYPE_REPLY;
-    // Original content length (4 bytes)
-    result.set(originalContentLenBytes, offset);
-    offset += originalContentLenBytes.length;
-    // Original content
-    result.set(originalContentBytes, offset);
-    offset += originalContentBytes.length;
-    // Seeker (34 bytes)
-    result.set(originalSeeker, offset);
-    offset += SEEKER_SIZE;
-    // New content
-    result.set(newContentBytes, offset);
-    return result;
+export function serializeReplyMessage(newContent, originalMsgId, messageId) {
+    if (messageId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`messageId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    if (originalMsgId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`originalMsgId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_REPLY,
+        messageId,
+        content: newContent,
+        citedMsgId: originalMsgId,
+    });
 }
 /**
  * Serialize a forward message
  *
- * Format: [type: 1 byte][forwardContentLen: 4 bytes][forwardContent][seeker: 34 bytes][newContent]
+ * Format: protobuf Message with citedContactId set
  *
- * @param forwardContent - The content being forwarded
+ * @param forwardedContent - The content being forwarded
  * @param newContent - Optional new content to add (empty string if none)
- * @param originalSeeker - The seeker of the original message
+ * @param originalContactId - The contact ID (32 bytes) of the original message
+ * @param messageId - 12-byte random message ID
  * @returns Serialized forward message bytes
  */
-export function serializeForwardMessage(forwardContent, newContent, originalSeeker) {
-    const newContentBytes = strToBytes(newContent);
-    const forwardContentBytes = strToBytes(forwardContent);
-    const forwardContentLenBytes = U32.toBytes(BigInt(forwardContentBytes.length));
-    // Calculate total size
-    const totalSize = 1 + // type
-        forwardContentLenBytes.length + // length prefix (4 bytes)
-        forwardContentBytes.length + // forward content
-        SEEKER_SIZE + // seeker
-        newContentBytes.length; // new content
-    const result = new Uint8Array(totalSize);
-    let offset = 0;
-    // Type byte
-    result[offset++] = MESSAGE_TYPE_FORWARD;
-    // Forward content length (4 bytes)
-    result.set(forwardContentLenBytes, offset);
-    offset += forwardContentLenBytes.length;
-    // Forward content
-    result.set(forwardContentBytes, offset);
-    offset += forwardContentBytes.length;
-    // Seeker (34 bytes)
-    result.set(originalSeeker, offset);
-    offset += SEEKER_SIZE;
-    // New content
-    result.set(newContentBytes, offset);
-    return result;
+export function serializeForwardMessage(forwardedContent, newContent, messageId, originalContactId) {
+    if (messageId.length !== MESSAGE_ID_SIZE) {
+        throw new Error(`messageId must be ${MESSAGE_ID_SIZE} bytes`);
+    }
+    if (originalContactId && originalContactId.length !== 32) {
+        throw new Error('originalContactId must be 32 bytes');
+    }
+    return ProtoMessage.encode({
+        messageType: ProtoMessageType.MESSAGE_TYPE_FORWARD,
+        messageId,
+        content: newContent,
+        citedContactId: originalContactId,
+        forwardedContent,
+    });
 }
 /**
  * Deserialize a message from bytes
@@ -117,68 +94,50 @@ export function serializeForwardMessage(forwardContent, newContent, originalSeek
  * @throws Error if message format is invalid
  */
 export function deserializeMessage(buffer) {
-    if (buffer.length < 1) {
+    if (buffer.length === 0) {
         throw new Error('Empty message buffer');
     }
-    const messageType = buffer[0];
-    switch (messageType) {
-        case MESSAGE_TYPE_KEEP_ALIVE:
-            return {
-                content: '',
-                type: MessageType.KEEP_ALIVE,
-            };
-        case MESSAGE_TYPE_REGULAR:
-            return {
-                content: bytesToStr(buffer.slice(1)),
-                type: MessageType.TEXT,
-            };
-        case MESSAGE_TYPE_REPLY: {
-            // Format: [type: 1][originalContentLen: 4][originalContent][seeker: 34][newContent]
-            let offset = 1;
-            // Read original content length (4 bytes)
-            const originalContentLen = Number(U32.fromBytes(buffer.slice(offset, offset + 4)));
-            offset += 4;
-            // Read original content
-            const originalContent = bytesToStr(buffer.slice(offset, offset + originalContentLen));
-            offset += originalContentLen;
-            // Read seeker (34 bytes)
-            const originalSeeker = buffer.slice(offset, offset + SEEKER_SIZE);
-            offset += SEEKER_SIZE;
-            // Read new content (rest of buffer)
-            const content = bytesToStr(buffer.slice(offset));
-            return {
-                content,
-                replyTo: {
-                    originalContent,
-                    originalSeeker,
-                },
-                type: MessageType.TEXT,
+    const decoded = ProtoMessage.decode(buffer);
+    const protoType = decoded.messageType ?? ProtoMessageType.MESSAGE_TYPE_REGULAR;
+    if (protoType === ProtoMessageType.MESSAGE_TYPE_KEEP_ALIVE) {
+        return {
+            content: '',
+            type: MessageType.KEEP_ALIVE,
+        };
+    }
+    const content = decoded.content ?? '';
+    const messageId = decoded.messageId;
+    const citedMsgId = decoded.citedMsgId;
+    let replyTo = undefined;
+    if (protoType === ProtoMessageType.MESSAGE_TYPE_REPLY) {
+        if (citedMsgId && citedMsgId.length === MESSAGE_ID_SIZE) {
+            replyTo = {
+                originalMsgId: citedMsgId,
             };
         }
-        case MESSAGE_TYPE_FORWARD: {
-            // Format: [type: 1][forwardContentLen: 4][forwardContent][seeker: 34][newContent]
-            let offset = 1;
-            // Read forward content length (4 bytes)
-            const forwardContentLen = Number(U32.fromBytes(buffer.slice(offset, offset + 4)));
-            offset += 4;
-            // Read forward content
-            const originalContent = bytesToStr(buffer.slice(offset, offset + forwardContentLen));
-            offset += forwardContentLen;
-            // Read seeker (34 bytes)
-            const originalSeeker = buffer.slice(offset, offset + SEEKER_SIZE);
-            offset += SEEKER_SIZE;
-            // Read new content (rest of buffer)
-            const content = bytesToStr(buffer.slice(offset));
-            return {
-                content,
-                forwardOf: {
-                    originalContent,
-                    originalSeeker,
-                },
-                type: MessageType.TEXT,
+        else {
+            throw new Error(`invalid message format: message of type reply but citedMsgId empty or not correct size (${MESSAGE_ID_SIZE})`);
+        }
+    }
+    let forwardOf = undefined;
+    if (protoType === ProtoMessageType.MESSAGE_TYPE_FORWARD) {
+        if (decoded.forwardedContent &&
+            decoded.citedContactId &&
+            decoded.citedContactId.length === 32) {
+            forwardOf = {
+                originalContent: decoded.forwardedContent,
+                originalContactId: decoded.citedContactId,
             };
         }
-        default:
-            throw new Error(`Unknown message type: ${messageType}`);
+        else {
+            throw new Error(`invalid message format: message of type forward but forwardedContent empty or not correct size (${MESSAGE_ID_SIZE}) or citedContactId empty or not correct size (32)`);
+        }
     }
+    return {
+        content,
+        messageId,
+        replyTo,
+        forwardOf,
+        type: MessageType.TEXT,
+    };
 }

package/dist/wasm/index.d.ts

@@ -8,3 +8,4 @@ export { SessionModule, sessionStatusToString } from './session';
 export { initializeWasm, ensureWasmInitialized, startWasmInitialization, } from './loader';
 export * from './encryption';
 export * from './userKeys';
+export { SessionStatus, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './bindings';

package/dist/wasm/index.js

@@ -11,3 +11,4 @@ export { initializeWasm, ensureWasmInitialized, startWasmInitialization, } from
 // Export specialized WASM functionality
 export * from './encryption';
 export * from './userKeys';
+export { SessionStatus, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './bindings';

package/package.json

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