@massalabs/gossip-sdk 0.0.1 → 0.0.2-dev.20260128111120

package/dist/wasm/session.js

@@ -0,0 +1,226 @@
+/**
+ * Session Module Implementation
+ *
+ * This file contains the real WASM implementation of the SessionModule
+ * using SessionManagerWrapper and related WASM classes.
+ */
+import { SessionManagerWrapper, SessionStatus, SessionConfig, } from '../assets/generated/wasm/gossip_wasm';
+import { encodeUserId } from '../utils/userId';
+export class SessionModule {
+    constructor(userKeys, onPersist, config) {
+        Object.defineProperty(this, "sessionManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "onPersist", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // Async callback for persistence
+        Object.defineProperty(this, "ourPk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ourSk", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "userIdEncoded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.ourPk = userKeys.public_keys();
+        this.ourSk = userKeys.secret_keys();
+        this.userId = this.ourPk.derive_id();
+        this.userIdEncoded = encodeUserId(this.userId);
+        const sessionConfig = config ?? SessionConfig.new_default();
+        this.sessionManager = new SessionManagerWrapper(sessionConfig);
+        this.onPersist = onPersist;
+    }
+    /**
+     * Set the persistence callback
+     */
+    setOnPersist(callback) {
+        this.onPersist = callback;
+    }
+    /**
+     * Helper to trigger persistence after state changes.
+     * Returns a promise that resolves when persistence is complete.
+     * IMPORTANT: Callers should await this before sending data to network
+     * to prevent state loss on app crash.
+     */
+    async persistIfNeeded() {
+        if (this.onPersist) {
+            await this.onPersist();
+        }
+    }
+    /**
+     * Trigger persistence explicitly and wait for completion.
+     * Use this when you need to ensure state is saved before proceeding.
+     */
+    async persist() {
+        await this.persistIfNeeded();
+    }
+    /**
+     * Initialize session from an encrypted blob
+     */
+    load(profile, encryptionKey) {
+        // Clean up existing session if any
+        this.cleanup();
+        this.sessionManager = SessionManagerWrapper.from_encrypted_blob(profile.session, encryptionKey);
+    }
+    /**
+     * Serialize session to an encrypted blob
+     */
+    toEncryptedBlob(key) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        return this.sessionManager.to_encrypted_blob(key);
+    }
+    cleanup() {
+        this.sessionManager?.free();
+        this.sessionManager = null;
+    }
+    /**
+     * Establish an outgoing session with a peer via the underlying WASM wrapper
+     * @param peerPk - The peer's public keys
+     * @param userData - Optional user data to include in the announcement (defaults to empty array)
+     * @returns The announcement bytes to publish
+     */
+    async establishOutgoingSession(peerPk, userData) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        const userDataBytes = userData ?? new Uint8Array(0);
+        const result = this.sessionManager.establish_outgoing_session(peerPk, this.ourPk, this.ourSk, userDataBytes);
+        if (result.length === 0) {
+            throw new Error('Failed to establish outgoing session. Session manager returned empty announcement bytes.');
+        }
+        await this.persistIfNeeded();
+        return result;
+    }
+    /**
+     * Feed an incoming announcement into the session manager
+     * @returns AnnouncementResult containing the announcer's public keys, timestamp, and user data, or undefined if invalid
+     */
+    async feedIncomingAnnouncement(announcementBytes) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        const result = this.sessionManager.feed_incoming_announcement(announcementBytes, this.ourPk, this.ourSk);
+        if (result) {
+            await this.persistIfNeeded();
+        }
+        return result;
+    }
+    /**
+     * Get the list of message board read keys (seekers) to monitor
+     */
+    getMessageBoardReadKeys() {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        return this.sessionManager.get_message_board_read_keys();
+    }
+    /**
+     * Process an incoming ciphertext from the message board
+     */
+    async feedIncomingMessageBoardRead(seeker, ciphertext) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        const result = this.sessionManager.feed_incoming_message_board_read(seeker, ciphertext, this.ourSk);
+        await this.persistIfNeeded();
+        return result;
+    }
+    /**
+     * Send a message to a peer.
+     * IMPORTANT: This persists session state before returning.
+     * The returned output should only be sent to network AFTER this resolves.
+     */
+    async sendMessage(peerId, message) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        const result = this.sessionManager.send_message(peerId, message);
+        // CRITICAL: Persist session state BEFORE returning
+        // This ensures state is saved before the encrypted message goes on the network
+        await this.persistIfNeeded();
+        return result;
+    }
+    /**
+     * List all known peer IDs
+     */
+    peerList() {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        return this.sessionManager.peer_list();
+    }
+    /**
+     * Get the session status for a peer
+     */
+    peerSessionStatus(peerId) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        return this.sessionManager.peer_session_status(peerId);
+    }
+    /**
+     * Discard a peer and all associated session state
+     */
+    async peerDiscard(peerId) {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        this.sessionManager.peer_discard(peerId);
+        await this.persistIfNeeded();
+    }
+    /**
+     * Refresh sessions, returning peer IDs that need keep-alive messages
+     */
+    async refresh() {
+        if (!this.sessionManager) {
+            throw new Error('Session manager is not initialized');
+        }
+        const result = this.sessionManager.refresh();
+        await this.persistIfNeeded();
+        return result;
+    }
+}
+export function sessionStatusToString(status) {
+    switch (status) {
+        case SessionStatus.Active:
+            return 'Active';
+        case SessionStatus.UnknownPeer:
+            return 'UnknownPeer';
+        case SessionStatus.NoSession:
+            return 'NoSession';
+        case SessionStatus.PeerRequested:
+            return 'PeerRequested';
+        case SessionStatus.SelfRequested:
+            return 'SelfRequested';
+        case SessionStatus.Killed:
+            return 'Killed';
+        case SessionStatus.Saturated:
+            return 'Saturated';
+        default:
+            throw new Error(`Unknown session status: ${status}`);
+    }
+}

package/dist/wasm/userKeys.d.ts

@@ -0,0 +1,17 @@
+/**
+ * User Keys Support
+ *
+ * This file provides proxy functions for user key generation,
+ * ensuring proper initialization before calling any WASM functions.
+ */
+import { UserKeys } from '../assets/generated/wasm/gossip_wasm';
+export { UserKeys };
+/**
+ * Generate user keys from a passphrase using password-based key derivation
+ * This ensures WASM is initialized before calling
+ *
+ * @param passphrase - The user's passphrase
+ * @param secondaryKey - A 32-byte secondary public key
+ * @returns UserKeys object containing public and secret keys
+ */
+export declare function generateUserKeys(passphrase: string): Promise<UserKeys>;

package/{src/wasm/userKeys.ts → dist/wasm/userKeys.js}

@@ -4,16 +4,10 @@
  * This file provides proxy functions for user key generation,
  * ensuring proper initialization before calling any WASM functions.
  */
-
 import { ensureWasmInitialized } from './loader';
-import {
-  generate_user_keys as _generate_user_keys,
-  UserKeys,
-} from '../assets/generated/wasm/gossip_wasm';
-
+import { generate_user_keys as _generate_user_keys, UserKeys, } from '../assets/generated/wasm/gossip_wasm';
 // Re-export classes
 export { UserKeys };
-
 /**
  * Generate user keys from a passphrase using password-based key derivation
  * This ensures WASM is initialized before calling
@@ -22,10 +16,9 @@ export { UserKeys };
  * @param secondaryKey - A 32-byte secondary public key
  * @returns UserKeys object containing public and secret keys
  */
-export async function generateUserKeys(passphrase: string): Promise<UserKeys> {
-  await ensureWasmInitialized();
-  // The actual WASM function is synchronous, so we can call it directly
-  const keys = _generate_user_keys(passphrase);
-
-  return keys;
+export async function generateUserKeys(passphrase) {
+    await ensureWasmInitialized();
+    // The actual WASM function is synchronous, so we can call it directly
+    const keys = _generate_user_keys(passphrase);
+    return keys;
 }

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.1",
+  "version": "0.0.2-dev.20260128111120",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",

package/src/api/messageProtocol/index.ts

@@ -1,53 +0,0 @@
-/**
- * Message Protocol Module
- *
- * 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 {
-  defaultMessageProtocol,
-  protocolConfig,
-  type MessageProtocolType,
-} from '../../config/protocol';
-
-import { RestMessageProtocol } from './rest';
-import { MessageProtocol } from './mock';
-
-/**
- * Factory function to create message protocol instances
- */
-export function createMessageProtocol(
-  type: MessageProtocolType = defaultMessageProtocol,
-  config?: Partial<{ baseUrl: string; timeout: number; retryAttempts: number }>
-): IMessageProtocol {
-  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 const restMessageProtocol = createMessageProtocol();

package/src/api/messageProtocol/rest.ts

@@ -1,209 +0,0 @@
-/**
- * REST API implementation of the message protocol
- */
-
-import {
-  BulletinItem,
-  EncryptedMessage,
-  IMessageProtocol,
-  MessageProtocolResponse,
-} from './types';
-import { encodeToBase64, decodeFromBase64 } from '../../utils/base64';
-
-const BULLETIN_ENDPOINT = '/bulletin';
-const MESSAGES_ENDPOINT = '/messages';
-
-export type BulletinsPage = {
-  counter: string;
-  data: string;
-}[];
-
-type FetchMessagesResponse = {
-  key: string;
-  value: string;
-};
-
-export class RestMessageProtocol implements IMessageProtocol {
-  constructor(
-    private baseUrl: string,
-    private timeout: number = 10000,
-    private retryAttempts: number = 3
-  ) {}
-
-  // TODO: Implement a fetch with pagination to avoid fetching all messages at once
-  async fetchMessages(seekers: Uint8Array[]): Promise<EncryptedMessage[]> {
-    const url = `${this.baseUrl}${MESSAGES_ENDPOINT}/fetch`;
-
-    const response = await this.makeRequest<FetchMessagesResponse[]>(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ seekers: seekers.map(encodeToBase64) }),
-    });
-
-    if (!response.success || !response.data) {
-      throw new Error(response.error || 'Failed to fetch messages');
-    }
-
-    return response.data.map((item: FetchMessagesResponse) => {
-      const seeker = decodeFromBase64(item.key);
-      const ciphertext = decodeFromBase64(item.value);
-
-      return {
-        seeker,
-        ciphertext,
-      };
-    });
-  }
-
-  async sendMessage(message: EncryptedMessage): Promise<void> {
-    const url = `${this.baseUrl}${MESSAGES_ENDPOINT}/`;
-
-    const response = await this.makeRequest<void>(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        key: encodeToBase64(message.seeker),
-        value: encodeToBase64(message.ciphertext),
-      }),
-    });
-
-    if (!response.success) {
-      throw new Error(response.error || 'Failed to send message');
-    }
-  }
-
-  async sendAnnouncement(announcement: Uint8Array): Promise<string> {
-    const url = `${this.baseUrl}${BULLETIN_ENDPOINT}`;
-
-    const response = await this.makeRequest<{ counter: string }>(url, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        data: encodeToBase64(announcement),
-      }),
-    });
-
-    if (!response.success || !response.data) {
-      throw new Error(response.error || 'Failed to broadcast outgoing session');
-    }
-
-    return response.data.counter;
-  }
-
-  async fetchAnnouncements(
-    limit: number = 50,
-    cursor?: string
-  ): Promise<BulletinItem[]> {
-    const params = new URLSearchParams();
-
-    params.set('limit', limit.toString());
-    // Always pass 'after' parameter. If cursor is undefined, use '0' to fetch from the beginning.
-    // This ensures pagination works correctly: after=0 gets counters 1-20, after=20 gets 21-40, etc.
-    params.set('after', cursor ?? '0');
-
-    const url = `${this.baseUrl}${BULLETIN_ENDPOINT}?${params.toString()}`;
-
-    const response = await this.makeRequest<BulletinsPage>(url, {
-      method: 'GET',
-    });
-
-    if (!response.success || response.data == null) {
-      throw new Error(response.error || 'Failed to fetch announcements');
-    }
-
-    return response.data.map(item => ({
-      counter: item.counter,
-      data: decodeFromBase64(item.data),
-    }));
-  }
-
-  async fetchPublicKeyByUserId(userId: Uint8Array): Promise<string> {
-    const response = await this.makeRequest<{ value: string }>(
-      `${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: string): Promise<string> {
-    const url = `${this.baseUrl}/auth`;
-
-    const response = await this.makeRequest<{ value: string }>(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;
-  }
-
-  private async makeRequest<T>(
-    url: string,
-    options: RequestInit
-  ): Promise<MessageProtocolResponse<T>> {
-    let lastError: Error | null = 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 as 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?: string): Promise<MessageProtocolResponse> {
-    return {
-      success: true,
-      data:
-        'This message protocol provider use a single node, so changing the node to ' +
-        nodeUrl +
-        ' is not supported',
-    };
-  }
-}

package/src/api/messageProtocol/types.ts

@@ -1,70 +0,0 @@
-/**
- * Message Protocol Types and Interfaces
- *
- * Defines the core types and interfaces for message protocol operations.
- */
-
-export type BulletinItem = {
-  counter: string;
-  data: Uint8Array;
-};
-
-export interface EncryptedMessage {
-  seeker: Uint8Array;
-  ciphertext: Uint8Array;
-}
-
-export interface MessageProtocolResponse<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: string;
-}
-
-/**
- * Abstract interface for message protocol operations
- */
-export interface IMessageProtocol {
-  /**
-   * Fetch encrypted messages for the provided set of seeker read keys
-   */
-  fetchMessages(seekers: Uint8Array[]): Promise<EncryptedMessage[]>;
-
-  /**
-   * Send an encrypted message to the key-value store
-   */
-  sendMessage(message: EncryptedMessage): Promise<void>;
-
-  /**
-   * Broadcast an outgoing session announcement produced by WASM.
-   * Returns the bulletin counter provided by the API.
-   */
-  sendAnnouncement(announcement: Uint8Array): Promise<string>;
-  /**
-   * Fetch incoming discussion announcements from the bulletin storage.
-   * Returns raw announcement bytes as provided by the API.
-   * @param limit - Maximum number of announcements to fetch (default: 20)
-   * @param cursor - Optional cursor (counter) to fetch announcements after this value
-   */
-  fetchAnnouncements(limit?: number, cursor?: string): Promise<BulletinItem[]>;
-
-  /**
-   * 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
-   * @returns MessageProtocolResponse with the new node information
-   */
-  changeNode(nodeUrl?: string): Promise<MessageProtocolResponse>;
-}