@massalabs/gossip-sdk 0.0.2-dev.20260211140005 → 0.0.2-dev.20260211172752

package/README.md

@@ -47,9 +47,8 @@ await gossipSdk.openSession({
   mnemonic: 'word1 word2 word3 ... word12',
   // For existing session:
   encryptedSession: savedBlob,
-  encryptionKey: savedKey,
+  encryptionKey,
   // For persistence:
-  persistEncryptionKey: encryptionKey,
   onPersist: async (blob, key) => {
     await saveToStorage(blob, key);
   },
@@ -113,7 +112,7 @@ await gossipSdk.openSession({
 // With persistence (saves session on changes)
 await gossipSdk.openSession({
   mnemonic: 'word1 word2 word3 ... word12',
-  persistEncryptionKey: encryptionKey,
+  encryptionKey,
   onPersist: async (blob, key) => {
     await db.userProfile.update(userId, { session: blob });
   },
@@ -387,25 +386,16 @@ const decoded = utils.decodeUserId(encodedString);
 
 ## Session Persistence
 
-For restoring sessions across app restarts:
+For restoring sessions across app restarts, pass `encryptionKey` and `onPersist` when opening the session:
 
 ```typescript
-// Option 1: Provide persistence config in openSession
 await gossipSdk.openSession({
   mnemonic,
-  persistEncryptionKey: key,
+  encryptionKey,
   onPersist: async (blob, key) => {
-    // Save blob to your storage
     await db.userProfile.update(userId, { session: blob });
   },
 });
-
-// Option 2: Configure persistence after account creation
-await gossipSdk.openSession({ mnemonic });
-// ... create account, get encryption key ...
-gossipSdk.configurePersistence(encryptionKey, async (blob, key) => {
-  await db.userProfile.update(userId, { session: blob });
-});
 ```
 
 ## Auto-Renewal Behavior

package/dist/gossipSdk.d.ts

@@ -40,7 +40,6 @@
  */
 import { GossipDatabase, type Contact, type Discussion, type Message } from './db';
 import { type SdkConfig, type DeepPartial } from './config/sdk';
-import { SessionStatus, SessionConfig } from './assets/generated/wasm/gossip_wasm';
 import { EncryptionKey } from './wasm/encryption';
 import { type AnnouncementReceptionResult } from './services/announcement';
 import { discussionInitializationResult } from './services/discussion';
@@ -48,7 +47,7 @@ import { type MessageResult, type SendMessageResult } from './services/message';
 import { AuthService } from './services/auth';
 import type { DeleteContactResult, UpdateContactNameResult } from './utils/contacts';
 import { type ValidationResult } from './utils/validation';
-import type { UserPublicKeys } from './wasm/bindings';
+import { type UserPublicKeys, SessionStatus, SessionConfig } from './wasm/bindings';
 import { SdkEventType, type SdkEventHandlers } from './core/SdkEventEmitter';
 import { AnnouncementPayload } from './utils/announcementPayload';
 import { Result } from './utils/type';
@@ -72,12 +71,10 @@ export interface OpenSessionOptions {
     mnemonic: string;
     /** Existing encrypted session blob (for restoring session) */
     encryptedSession?: Uint8Array;
-    /** Encryption key for decrypting session */
+    /** Encryption key for decrypting session and storage. Will be created if not provided. */
     encryptionKey?: EncryptionKey;
     /** Callback when session state changes (for persistence) */
     onPersist?: (encryptedBlob: Uint8Array, encryptionKey: EncryptionKey) => Promise<void>;
-    /** Encryption key for persisting session (required if onPersist is provided) */
-    persistEncryptionKey?: EncryptionKey;
     /** Custom session configuration (optional, uses defaults if not provided) */
     sessionConfig?: SessionConfig;
 }
@@ -127,15 +124,7 @@ declare class GossipSdkImpl {
      * Get encrypted session blob for persistence.
      * Throws if no session is open.
      */
-    getEncryptedSession(encryptionKey: EncryptionKey): Uint8Array;
-    /**
-     * Configure session persistence after session is opened.
-     * Use this when you need to set up persistence after account creation.
-     *
-     * @param encryptionKey - Key to encrypt session blob
-     * @param onPersist - Callback to save encrypted session blob
-     */
-    configurePersistence(encryptionKey: EncryptionKey, onPersist: (encryptedBlob: Uint8Array, encryptionKey: EncryptionKey) => Promise<void>): void;
+    getEncryptedSession(): Uint8Array;
     /** Auth service (available after init, before session) */
     get auth(): AuthService;
     /** Message service */

package/dist/gossipSdk.js

@@ -45,6 +45,7 @@ import { defaultSdkConfig, mergeConfig, } from './config/sdk';
 import { startWasmInitialization, ensureWasmInitialized } from './wasm/loader';
 import { generateUserKeys } from './wasm/userKeys';
 import { SessionModule } from './wasm/session';
+import { generateEncryptionKeyFromSeed, } from './wasm/encryption';
 import { AnnouncementService, } from './services/announcement';
 import { DiscussionService, } from './services/discussion';
 import { MessageService, } from './services/message';
@@ -54,6 +55,7 @@ import { validateUserIdFormat, validateUsernameFormat, } from './utils/validatio
 import { QueueManager } from './utils/queue';
 import { encodeUserId, decodeUserId } from './utils/userId';
 import { getContacts, getContact, addContact, updateContactName, deleteContact, } from './contacts';
+import { SessionManagerWrapper, } from './wasm/bindings';
 import { SdkEventEmitter, SdkEventType, } from './core/SdkEventEmitter';
 import { SdkPolling } from './core/SdkPolling';
 export { SdkEventType };
@@ -197,29 +199,25 @@ class GossipSdkImpl {
         if (this.state.status === SdkStatus.SESSION_OPEN) {
             throw new Error('Session already open. Call closeSession() first.');
         }
-        if (options.encryptedSession && !options.encryptionKey) {
-            throw new Error('encryptionKey is required when encryptedSession is provided.');
-        }
-        if (options.onPersist && !options.persistEncryptionKey) {
-            throw new Error('persistEncryptionKey is required when onPersist is provided.');
+        if (!options.encryptionKey) {
+            console.warn('[GossipSdk] No encryptionKey provided. Creating a new one from mnemonic.');
         }
+        const encryptionKey = options.encryptionKey ??
+            (await generateEncryptionKeyFromSeed(options.mnemonic, new Uint8Array(32).fill(0)));
         const { db, messageProtocol } = this.state;
-        // Validate session restore options - must have both or neither
-        if (options.encryptedSession && !options.encryptionKey) {
-            throw new Error('encryptedSession provided without encryptionKey. Session restore requires both.');
-        }
-        if (options.encryptionKey && !options.encryptedSession) {
-            console.warn('[GossipSdk] encryptionKey provided without encryptedSession - key will be ignored');
-        }
-        // Validate persistence options - warn if incomplete
-        if (options.onPersist && !options.persistEncryptionKey) {
-            console.warn('[GossipSdk] onPersist provided without persistEncryptionKey - session will not be persisted');
-        }
-        if (options.persistEncryptionKey && !options.onPersist) {
-            console.warn('[GossipSdk] persistEncryptionKey provided without onPersist callback - key will be unused');
-        }
-        // Ensure WASM is ready
+        // Ensure WASM is ready before using any WASM-backed helpers
         await ensureWasmInitialized();
+        // Validate that encryptedSession can be decrypted with the provided key
+        if (options.encryptedSession) {
+            try {
+                const sessionManager = SessionManagerWrapper.from_encrypted_blob(options.encryptedSession, encryptionKey);
+                // We only create this wrapper for validation, free it immediately
+                sessionManager.free();
+            }
+            catch {
+                throw new Error('[GossipSdk] Failed to load encrypted session. Please provide a valid encryptedSession and encryptionKey.');
+            }
+        }
         // Generate keys from mnemonic
         const userKeys = await generateUserKeys(options.mnemonic);
         // Create session with persistence callback
@@ -228,12 +226,8 @@ class GossipSdkImpl {
             await this.handleSessionPersist();
         }, options.sessionConfig);
         // Restore existing session state if provided
-        if (options.encryptedSession && options.encryptionKey) {
-            // Create a minimal profile-like object for load()
-            const profileForLoad = {
-                session: options.encryptedSession,
-            };
-            session.load(profileForLoad, options.encryptionKey);
+        if (options.encryptedSession) {
+            session.load(options.encryptedSession, encryptionKey);
         }
         // Get config from initialized state
         const { config } = this.state;
@@ -255,7 +249,7 @@ class GossipSdkImpl {
             config,
             session,
             userKeys,
-            persistEncryptionKey: options.persistEncryptionKey,
+            encryptionKey,
             onPersist: options.onPersist,
         };
         // Create cached service API wrappers
@@ -370,28 +364,12 @@ class GossipSdkImpl {
      * Get encrypted session blob for persistence.
      * Throws if no session is open.
      */
-    getEncryptedSession(encryptionKey) {
+    getEncryptedSession() {
         const state = this.requireSession();
-        return state.session.toEncryptedBlob(encryptionKey);
-    }
-    /**
-     * Configure session persistence after session is opened.
-     * Use this when you need to set up persistence after account creation.
-     *
-     * @param encryptionKey - Key to encrypt session blob
-     * @param onPersist - Callback to save encrypted session blob
-     */
-    configurePersistence(encryptionKey, onPersist) {
-        if (this.state.status !== SdkStatus.SESSION_OPEN) {
-            throw new Error('No session open. Call openSession() first.');
+        if (!state.encryptionKey) {
+            throw new Error('No encryption key found. Call openSession() first.');
         }
-        // Update state with persistence config
-        this.state = {
-            ...this.state,
-            persistEncryptionKey: encryptionKey,
-            onPersist,
-        };
-        console.log('[GossipSdk] Session persistence configured');
+        return state.session.toEncryptedBlob(state.encryptionKey);
     }
     // ─────────────────────────────────────────────────────────────────
     // Services (accessible only when session is open)
@@ -528,13 +506,13 @@ class GossipSdkImpl {
     async handleSessionPersist() {
         if (this.state.status !== SdkStatus.SESSION_OPEN)
             return;
-        const { onPersist, persistEncryptionKey, session } = this.state;
-        if (!onPersist || !persistEncryptionKey)
+        const { onPersist, encryptionKey, session } = this.state;
+        if (!onPersist || !encryptionKey)
             return;
         try {
-            const blob = session.toEncryptedBlob(persistEncryptionKey);
+            const blob = session.toEncryptedBlob(encryptionKey);
             console.log(`[SessionPersist] Saving session blob (${blob.length} bytes)`);
-            await onPersist(blob, persistEncryptionKey);
+            await onPersist(blob, encryptionKey);
         }
         catch (error) {
             this.eventEmitter.emit(SdkEventType.ERROR, error instanceof Error ? error : new Error(String(error)), 'session_persist');

package/dist/wasm/session.d.ts

@@ -5,7 +5,6 @@
  * using SessionManagerWrapper and related WASM classes.
  */
 import { UserPublicKeys, UserSecretKeys, ReceiveMessageOutput, SendMessageOutput, SessionStatus, EncryptionKey, SessionConfig, AnnouncementResult, UserKeys } from './bindings';
-import { UserProfile } from '../db';
 export declare class SessionModule {
     private sessionManager;
     private onPersist?;
@@ -33,7 +32,7 @@ export declare class SessionModule {
     /**
      * Initialize session from an encrypted blob
      */
-    load(profile: UserProfile, encryptionKey: EncryptionKey): void;
+    load(encryptedSession: Uint8Array, encryptionKey: EncryptionKey): void;
     /**
      * Serialize session to an encrypted blob
      */

package/dist/wasm/session.js

@@ -79,10 +79,16 @@ export class SessionModule {
     /**
      * Initialize session from an encrypted blob
      */
-    load(profile, encryptionKey) {
+    load(encryptedSession, encryptionKey) {
         // Clean up existing session if any
         this.cleanup();
-        this.sessionManager = SessionManagerWrapper.from_encrypted_blob(profile.session, encryptionKey);
+        try {
+            this.sessionManager = SessionManagerWrapper.from_encrypted_blob(encryptedSession, encryptionKey);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : JSON.stringify(error);
+            throw new Error(`[SessionModule] Failed to load encrypted session: ${message}`);
+        }
     }
     /**
      * Serialize session to an encrypted blob

package/package.json

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