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

package/dist/api/authProtocol.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Auth Protocol — public key publishing & retrieval
+ */
+import { RestClient } from './restClient';
+export interface IAuthProtocol {
+    /** Fetches the base64-encoded public key for the given user ID. */
+    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
+    /** Publishes the given base64-encoded public key to the server. */
+    postPublicKey(base64PublicKeys: string): Promise<string>;
+}
+export declare function createAuthProtocol(config?: Partial<{
+    baseUrl: string;
+    timeout: number;
+    retryAttempts: number;
+}>): IAuthProtocol;
+export declare class RestAuthProtocol extends RestClient implements IAuthProtocol {
+    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
+    postPublicKey(base64PublicKeys: string): Promise<string>;
+}

package/dist/api/authProtocol.js

@@ -0,0 +1,37 @@
+/**
+ * Auth Protocol — public key publishing & retrieval
+ */
+import { RestClient } from './restClient';
+import { encodeToBase64 } from '../utils/base64';
+import { protocolConfig } from '../config/protocol';
+export function createAuthProtocol(config) {
+    return new RestAuthProtocol(config?.baseUrl ?? protocolConfig.baseUrl, config?.timeout ?? protocolConfig.timeout, config?.retryAttempts ?? protocolConfig.retryAttempts);
+}
+export class RestAuthProtocol extends RestClient {
+    async fetchPublicKeyByUserId(userId) {
+        const response = await this.makeRequest(`${this.baseUrl}/auth/retrieve`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key: encodeToBase64(userId) }),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to fetch public key');
+        }
+        if (!response.data.value) {
+            throw new Error('Public key not found');
+        }
+        return response.data.value;
+    }
+    async postPublicKey(base64PublicKeys) {
+        const url = `${this.baseUrl}/auth`;
+        const response = await this.makeRequest(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ value: base64PublicKeys }),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to store public key');
+        }
+        return response.data.value;
+    }
+}

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

@@ -2,22 +2,16 @@
  * REST API implementation of the message protocol
  */
 import { BulletinItem, EncryptedMessage, IMessageProtocol, MessageProtocolResponse } from './types';
+import { RestClient } from '../restClient';
 export type BulletinsPage = {
     counter: string;
     data: string;
 }[];
-export declare class RestMessageProtocol implements IMessageProtocol {
-    private baseUrl;
-    private timeout;
-    private retryAttempts;
-    constructor(baseUrl: string, timeout?: number, retryAttempts?: number);
+export declare class RestMessageProtocol extends RestClient implements IMessageProtocol {
     fetchMessages(seekers: Uint8Array[]): Promise<EncryptedMessage[]>;
     sendMessage(message: EncryptedMessage): Promise<void>;
     sendAnnouncement(announcement: Uint8Array): Promise<string>;
     fetchAnnouncements(limit?: number, cursor?: string): Promise<BulletinItem[]>;
     fetchBulletinCounter(): Promise<string>;
-    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
-    postPublicKey(base64PublicKeys: string): Promise<string>;
-    private makeRequest;
     changeNode(nodeUrl?: string): Promise<MessageProtocolResponse>;
 }

package/dist/api/messageProtocol/rest.js

@@ -1,30 +1,11 @@
 /**
  * REST API implementation of the message protocol
  */
+import { RestClient } from '../restClient';
 import { encodeToBase64, decodeFromBase64 } from '../../utils/base64';
 const BULLETIN_ENDPOINT = '/bulletin';
 const MESSAGES_ENDPOINT = '/messages';
-export class RestMessageProtocol {
-    constructor(baseUrl, timeout = 10000, retryAttempts = 3) {
-        Object.defineProperty(this, "baseUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: baseUrl
-        });
-        Object.defineProperty(this, "timeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: timeout
-        });
-        Object.defineProperty(this, "retryAttempts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: retryAttempts
-        });
-    }
+export class RestMessageProtocol extends RestClient {
     // TODO: Implement a fetch with pagination to avoid fetching all messages at once
     async fetchMessages(seekers) {
         const url = `${this.baseUrl}${MESSAGES_ENDPOINT}/fetch`;
@@ -101,65 +82,6 @@ export class RestMessageProtocol {
         }
         return response.data.counter;
     }
-    async fetchPublicKeyByUserId(userId) {
-        const response = await this.makeRequest(`${this.baseUrl}/auth/retrieve`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ key: encodeToBase64(userId) }),
-        });
-        if (!response.success || !response.data) {
-            throw new Error(response.error || 'Failed to fetch public key');
-        }
-        if (!response.data.value) {
-            throw new Error('Public key not found');
-        }
-        return response.data.value;
-    }
-    async postPublicKey(base64PublicKeys) {
-        const url = `${this.baseUrl}/auth`;
-        const response = await this.makeRequest(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ value: base64PublicKeys }),
-        });
-        if (!response.success || !response.data) {
-            const errorMessage = response.error || 'Failed to store public key';
-            throw new Error(errorMessage);
-        }
-        return response.data.value;
-    }
-    async makeRequest(url, options) {
-        let lastError = null;
-        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-                const response = await fetch(url, {
-                    ...options,
-                    signal: controller.signal,
-                });
-                clearTimeout(timeoutId);
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                const data = await response.json();
-                return { success: true, data };
-            }
-            catch (error) {
-                lastError = error;
-                console.warn(`Request attempt ${attempt} failed:`, error);
-                if (attempt < this.retryAttempts) {
-                    // Exponential backoff
-                    const delay = Math.pow(2, attempt) * 1000;
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                }
-            }
-        }
-        return {
-            success: false,
-            error: lastError?.message || 'Request failed after all retry attempts',
-        };
-    }
     async changeNode(nodeUrl) {
         return {
             success: true,

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

@@ -44,18 +44,6 @@ export interface IMessageProtocol {
      * Fetch the latest bulletin counter from the API without downloading announcement data.
      */
     fetchBulletinCounter(): Promise<string>;
-    /**
-     * Fetch public key by userId hash (base64 string)
-     * @param userId - Decoded userId bytes
-     * @returns Base64-encoded public keys
-     */
-    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
-    /**
-     * Store public key in the auth API
-     * @param base64PublicKeys - Base64-encoded public keys
-     * @returns The hash key (hex string) returned by the API
-     */
-    postPublicKey(base64PublicKeys: string): Promise<string>;
     /**
      * Change the current node provider
      * @param nodeUrl - The URL of the new node

package/dist/api/restClient.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Base REST client with retry and timeout support.
+ * Shared by RestMessageProtocol and RestAuthProtocol.
+ */
+export interface RestResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export declare class RestClient {
+    protected baseUrl: string;
+    protected timeout: number;
+    protected retryAttempts: number;
+    constructor(baseUrl: string, timeout?: number, retryAttempts?: number);
+    protected makeRequest<T>(url: string, options: RequestInit): Promise<RestResponse<T>>;
+}

package/dist/api/restClient.js

@@ -0,0 +1,57 @@
+/**
+ * Base REST client with retry and timeout support.
+ * Shared by RestMessageProtocol and RestAuthProtocol.
+ */
+export class RestClient {
+    constructor(baseUrl, timeout = 10000, retryAttempts = 3) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: baseUrl
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: timeout
+        });
+        Object.defineProperty(this, "retryAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: retryAttempts
+        });
+    }
+    async makeRequest(url, options) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const response = await fetch(url, {
+                    ...options,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const data = await response.json();
+                return { success: true, data };
+            }
+            catch (error) {
+                lastError = error;
+                console.warn(`Request attempt ${attempt} failed:`, error);
+                if (attempt < this.retryAttempts) {
+                    const delay = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        return {
+            success: false,
+            error: lastError?.message || 'Request failed after all retry attempts',
+        };
+    }
+}

package/dist/gossip.js

@@ -41,6 +41,7 @@
 import { MessageStatus, } from './db';
 import { toDiscussion, toSortedDiscussions } from './utils/discussions';
 import { createMessageProtocol } from './api/messageProtocol';
+import { createAuthProtocol } from './api/authProtocol';
 import { setProtocolBaseUrl } from './config/protocol';
 import { defaultSdkConfig, mergeConfig, } from './config/sdk';
 import { startWasmInitialization, ensureWasmInitialized } from './wasm/loader';
@@ -180,8 +181,8 @@ class GossipSdk {
         console.log('[GossipSdk] SQLite initialized');
         // Create message protocol
         const messageProtocol = createMessageProtocol();
-        // Create auth service (doesn't need session)
-        this._auth = new AuthService(messageProtocol);
+        // Create auth protocol + service (doesn't need session)
+        this._auth = new AuthService(createAuthProtocol());
         this.state = {
             status: SdkStatus.INITIALIZED,
             messageProtocol,

package/dist/services/auth.d.ts

@@ -4,18 +4,17 @@
  * Handles storing and retrieving public keys by userId hash via the auth API.
  */
 import { UserPublicKeys } from '../wasm/bindings';
-import { IMessageProtocol } from '../api/messageProtocol/types';
+import { IAuthProtocol } from '../api/authProtocol';
 export declare class AuthService {
-    messageProtocol: IMessageProtocol;
-    constructor(messageProtocol: IMessageProtocol);
+    authProtocol: IAuthProtocol;
+    constructor(authProtocol: IAuthProtocol);
     /**
      * Fetch public key by userId
      * @param userId - Bech32-encoded userId (e.g., "gossip1...")
      */
     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.
+     * Ensure public key is published. Checks the server first, only publishes if not found.
      * @param publicKeys - UserPublicKeys instance
      * @param userId - Bech32-encoded userId (e.g., "gossip1...")
      */

package/dist/services/auth.js

@@ -6,14 +6,13 @@
 import { UserPublicKeys } from '../wasm/bindings';
 import { decodeUserId } from '../utils/userId';
 import { encodeToBase64, decodeFromBase64 } from '../utils/base64';
-import { getUserProfileField, updateUserProfileById } from '../queries';
 export class AuthService {
-    constructor(messageProtocol) {
-        Object.defineProperty(this, "messageProtocol", {
+    constructor(authProtocol) {
+        Object.defineProperty(this, "authProtocol", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: messageProtocol
+            value: authProtocol
         });
     }
     /**
@@ -22,7 +21,7 @@ export class AuthService {
      */
     async fetchPublicKeyByUserId(userId) {
         try {
-            const base64PublicKey = await this.messageProtocol.fetchPublicKeyByUserId(decodeUserId(userId));
+            const base64PublicKey = await this.authProtocol.fetchPublicKeyByUserId(decodeUserId(userId));
             return UserPublicKeys.from_bytes(decodeFromBase64(base64PublicKey));
         }
         catch (err) {
@@ -30,29 +29,22 @@ export class AuthService {
         }
     }
     /**
-     * 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.
+     * Ensure public key is published. Checks the server first, only publishes if not found.
      * @param publicKeys - UserPublicKeys instance
      * @param userId - Bech32-encoded userId (e.g., "gossip1...")
      */
     async ensurePublicKeyPublished(publicKeys, userId) {
-        const profile = await getUserProfileField(userId);
-        if (profile) {
-            const lastPush = profile.lastPublicKeyPush;
-            if (lastPush && !moreThanOneWeekAgo(lastPush)) {
-                return;
-            }
+        // Check if our key is already on the server
+        try {
+            await this.authProtocol.fetchPublicKeyByUserId(decodeUserId(userId));
+            return; // Key exists on server, nothing to do
         }
-        await this.messageProtocol.postPublicKey(encodeToBase64(publicKeys.to_bytes()));
-        if (profile) {
-            await updateUserProfileById(userId, { lastPublicKeyPush: new Date() });
+        catch {
+            // Key not found on server — publish it
         }
+        await this.authProtocol.postPublicKey(encodeToBase64(publicKeys.to_bytes()));
     }
 }
-const ONE_WEEK_IN_MILLIS = 7 * 24 * 60 * 60 * 1000;
-function moreThanOneWeekAgo(date) {
-    return Date.now() - date.getTime() >= ONE_WEEK_IN_MILLIS;
-}
 export const PUBLIC_KEY_NOT_FOUND_ERROR = 'Public key not found';
 export const PUBLIC_KEY_NOT_FOUND_MESSAGE = 'Contact public key not found. It may not be published yet.';
 export const FAILED_TO_FETCH_ERROR = 'Failed to fetch';

package/dist/services/message.js

@@ -483,7 +483,7 @@ export class MessageService {
             };
         }
         if (message.replyTo) {
-            const originalMessage = await this.findMessageByMsgId(message.replyTo.originalMsgId, message.ownerUserId);
+            const originalMessage = await this.findMessageByMsgId(message.replyTo.originalMsgId, message.ownerUserId, message.contactUserId);
             if (!originalMessage) {
                 return {
                     success: false,

package/package.json

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