@massalabs/gossip-sdk 0.0.2-dev.20260128094509 → 0.0.2-dev.20260128160824

package/src/wasm/loader.ts

@@ -1,123 +0,0 @@
-/**
- * WASM Module Loader and Initialization Service
- *
- * This file handles both WASM core initialization and module loading.
- * It ensures WASM modules are initialized once and properly throughout
- * the application lifecycle.
- */
-
-import init from '../assets/generated/wasm/gossip_wasm';
-
-/**
- * Check if we're running in Node.js environment
- */
-function isNodeEnvironment(): boolean {
-  return (
-    typeof process !== 'undefined' &&
-    process.versions != null &&
-    process.versions.node != null
-  );
-}
-
-/**
- * Load WASM module for Node.js environment using fs.readFileSync
- */
-async function loadWasmForNode(): Promise<WebAssembly.Module> {
-  // Dynamic import to avoid bundling Node.js modules in browser builds
-  const fs = await import('node:fs');
-  const path = await import('node:path');
-  const { fileURLToPath } = await import('node:url');
-
-  // Get the directory of the current module
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path.dirname(__filename);
-
-  // Resolve path to WASM file - WASM is in the SDK's generated folder
-  const wasmPath = path.resolve(
-    __dirname,
-    '../assets/generated/wasm/gossip_wasm_bg.wasm'
-  );
-
-  // Read WASM file as binary
-  const wasmBuffer = fs.readFileSync(wasmPath);
-
-  // Instantiate WASM module
-  const wasmModule = await WebAssembly.compile(wasmBuffer);
-  return wasmModule;
-}
-
-/**
- * WASM Initialization State
- */
-let isInitializing = false;
-let isInitialized = false;
-let initializationPromise: Promise<void> | null = null;
-let initError: Error | null = null;
-
-/**
- * Initialize WASM modules if not already initialized
- * This function is idempotent - safe to call multiple times
- */
-export async function initializeWasm(): Promise<void> {
-  // If already initialized, return immediately
-  if (isInitialized) {
-    return;
-  }
-
-  // If initialization is in progress, wait for it to complete
-  if (isInitializing && initializationPromise) {
-    return initializationPromise;
-  }
-
-  // Start initialization
-  isInitializing = true;
-  initError = null;
-
-  initializationPromise = (async () => {
-    try {
-      // In Node.js environment, load WASM using fs.readFileSync
-      if (isNodeEnvironment()) {
-        const wasmModule = await loadWasmForNode();
-        await init(wasmModule);
-      } else {
-        // In browser/jsdom, use default init (which uses fetch)
-        await init();
-      }
-      isInitialized = true;
-      isInitializing = false;
-    } catch (error) {
-      initError = error as Error;
-      isInitializing = false;
-      console.error('[WASM] Failed to initialize WASM modules:', error);
-      throw error;
-    }
-  })();
-
-  return initializationPromise;
-}
-
-/**
- * Ensure WASM is initialized, throwing an error if initialization failed
- */
-export async function ensureWasmInitialized(): Promise<void> {
-  await initializeWasm();
-
-  if (initError) {
-    throw new Error(`WASM initialization failed: ${initError.message}`);
-  }
-
-  if (!isInitialized) {
-    throw new Error('WASM not initialized');
-  }
-}
-
-/**
- * Start WASM initialization in the background.
- * Call this early in the app lifecycle (for example in main.tsx).
- */
-export function startWasmInitialization(): void {
-  // Fire and forget - start initialization in background
-  initializeWasm().catch(error => {
-    console.error('[WASM] Background initialization error:', error);
-  });
-}

package/src/wasm/session.ts

@@ -1,276 +0,0 @@
-/**
- * Session Module Implementation
- *
- * This file contains the real WASM implementation of the SessionModule
- * using SessionManagerWrapper and related WASM classes.
- */
-
-import {
-  SessionManagerWrapper,
-  UserPublicKeys,
-  UserSecretKeys,
-  ReceiveMessageOutput,
-  SendMessageOutput,
-  SessionStatus,
-  EncryptionKey,
-  SessionConfig,
-  AnnouncementResult,
-  UserKeys,
-} from '../assets/generated/wasm/gossip_wasm';
-import { UserProfile } from '../db';
-import { encodeUserId } from '../utils/userId';
-
-export class SessionModule {
-  private sessionManager: SessionManagerWrapper | null = null;
-  private onPersist?: () => Promise<void>; // Async callback for persistence
-  public ourPk: UserPublicKeys;
-  public ourSk: UserSecretKeys;
-  public userId: Uint8Array;
-  public userIdEncoded: string;
-
-  constructor(
-    userKeys: UserKeys,
-    onPersist?: () => Promise<void>,
-    config?: SessionConfig
-  ) {
-    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: () => Promise<void>): void {
-    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.
-   */
-  private async persistIfNeeded(): Promise<void> {
-    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(): Promise<void> {
-    await this.persistIfNeeded();
-  }
-
-  /**
-   * Initialize session from an encrypted blob
-   */
-  load(profile: UserProfile, encryptionKey: EncryptionKey): void {
-    // 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: EncryptionKey): Uint8Array {
-    if (!this.sessionManager) {
-      throw new Error('Session manager is not initialized');
-    }
-
-    return this.sessionManager.to_encrypted_blob(key);
-  }
-
-  cleanup(): void {
-    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: UserPublicKeys,
-    userData?: Uint8Array
-  ): Promise<Uint8Array> {
-    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: Uint8Array
-  ): Promise<AnnouncementResult | undefined> {
-    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(): Array<Uint8Array> {
-    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: Uint8Array,
-    ciphertext: Uint8Array
-  ): Promise<ReceiveMessageOutput | undefined> {
-    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: Uint8Array,
-    message: Uint8Array
-  ): Promise<SendMessageOutput | undefined> {
-    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(): Array<Uint8Array> {
-    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: Uint8Array): SessionStatus {
-    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: Uint8Array): Promise<void> {
-    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(): Promise<Array<Uint8Array>> {
-    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: SessionStatus): string {
-  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/test/config/protocol.spec.ts

@@ -1,31 +0,0 @@
-/**
- * Protocol config tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  protocolConfig,
-  setProtocolBaseUrl,
-  resetProtocolBaseUrl,
-} from '../../src/config/protocol';
-
-describe('protocol config', () => {
-  beforeEach(() => {
-    resetProtocolBaseUrl();
-  });
-
-  afterEach(() => {
-    resetProtocolBaseUrl();
-  });
-
-  it('uses runtime override when provided', () => {
-    setProtocolBaseUrl('https://custom.example.com/api');
-    expect(protocolConfig.baseUrl).toBe('https://custom.example.com/api');
-  });
-
-  it('resets to default after override', () => {
-    setProtocolBaseUrl('https://custom.example.com/api');
-    resetProtocolBaseUrl();
-    expect(protocolConfig.baseUrl).toBe('https://api.usegossip.com/api');
-  });
-});

package/test/config/sdk.spec.ts

@@ -1,163 +0,0 @@
-/**
- * SDK Config tests
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  defaultSdkConfig,
-  mergeConfig,
-  type SdkConfig,
-  type DeepPartial,
-} from '../../src/config/sdk';
-
-describe('SDK Config', () => {
-  describe('defaultSdkConfig', () => {
-    it('should have correct default protocol values', () => {
-      expect(defaultSdkConfig.protocol.timeout).toBe(10000);
-      expect(defaultSdkConfig.protocol.retryAttempts).toBe(3);
-      expect(defaultSdkConfig.protocol.baseUrl).toBeUndefined();
-    });
-
-    it('should have correct default polling values', () => {
-      expect(defaultSdkConfig.polling.enabled).toBe(false);
-      expect(defaultSdkConfig.polling.messagesIntervalMs).toBe(5000);
-      expect(defaultSdkConfig.polling.announcementsIntervalMs).toBe(10000);
-      expect(defaultSdkConfig.polling.sessionRefreshIntervalMs).toBe(30000);
-    });
-
-    it('should have correct default messages values', () => {
-      expect(defaultSdkConfig.messages.fetchDelayMs).toBe(100);
-      expect(defaultSdkConfig.messages.maxFetchIterations).toBe(30);
-    });
-
-    it('should have correct default announcements values', () => {
-      expect(defaultSdkConfig.announcements.fetchLimit).toBe(500);
-      expect(defaultSdkConfig.announcements.brokenThresholdMs).toBe(
-        60 * 60 * 1000
-      );
-    });
-  });
-
-  describe('mergeConfig', () => {
-    it('should return defaults when no partial provided', () => {
-      const config = mergeConfig();
-      expect(config).toEqual(defaultSdkConfig);
-    });
-
-    it('should return defaults when undefined provided', () => {
-      const config = mergeConfig(undefined);
-      expect(config).toEqual(defaultSdkConfig);
-    });
-
-    it('should merge partial protocol config', () => {
-      const partial: DeepPartial<SdkConfig> = {
-        protocol: {
-          timeout: 5000,
-        },
-      };
-
-      const config = mergeConfig(partial);
-
-      expect(config.protocol.timeout).toBe(5000);
-      expect(config.protocol.retryAttempts).toBe(3);
-      expect(config.polling.enabled).toBe(false);
-    });
-
-    it('should merge partial polling config', () => {
-      const partial: DeepPartial<SdkConfig> = {
-        polling: {
-          enabled: true,
-          messagesIntervalMs: 2000,
-        },
-      };
-
-      const config = mergeConfig(partial);
-
-      expect(config.polling.enabled).toBe(true);
-      expect(config.polling.messagesIntervalMs).toBe(2000);
-      expect(config.polling.announcementsIntervalMs).toBe(10000);
-      expect(config.polling.sessionRefreshIntervalMs).toBe(30000);
-    });
-
-    it('should merge partial messages config', () => {
-      const partial: DeepPartial<SdkConfig> = {
-        messages: {
-          maxFetchIterations: 50,
-        },
-      };
-
-      const config = mergeConfig(partial);
-
-      expect(config.messages.maxFetchIterations).toBe(50);
-      expect(config.messages.fetchDelayMs).toBe(100);
-    });
-
-    it('should merge partial announcements config', () => {
-      const partial: DeepPartial<SdkConfig> = {
-        announcements: {
-          brokenThresholdMs: 30 * 60 * 1000,
-        },
-      };
-
-      const config = mergeConfig(partial);
-
-      expect(config.announcements.brokenThresholdMs).toBe(30 * 60 * 1000);
-      expect(config.announcements.fetchLimit).toBe(500);
-    });
-
-    it('should merge multiple sections at once', () => {
-      const partial: DeepPartial<SdkConfig> = {
-        protocol: {
-          baseUrl: 'https://custom.api.com',
-        },
-        polling: {
-          enabled: true,
-        },
-        messages: {
-          fetchDelayMs: 50,
-        },
-        announcements: {
-          fetchLimit: 1000,
-        },
-      };
-
-      const config = mergeConfig(partial);
-
-      expect(config.protocol.baseUrl).toBe('https://custom.api.com');
-      expect(config.polling.enabled).toBe(true);
-      expect(config.messages.fetchDelayMs).toBe(50);
-      expect(config.announcements.fetchLimit).toBe(1000);
-      expect(config.protocol.timeout).toBe(10000);
-      expect(config.polling.messagesIntervalMs).toBe(5000);
-    });
-
-    it('should not mutate the original defaults', () => {
-      const originalTimeout = defaultSdkConfig.protocol.timeout;
-
-      mergeConfig({
-        protocol: { timeout: 1234 },
-      });
-
-      expect(defaultSdkConfig.protocol.timeout).toBe(originalTimeout);
-    });
-  });
-});
-
-describe('Max Fetch Iterations Limit', () => {
-  it('should respect maxFetchIterations config', async () => {
-    const config: SdkConfig = {
-      ...defaultSdkConfig,
-      messages: {
-        ...defaultSdkConfig.messages,
-        maxFetchIterations: 5,
-        fetchDelayMs: 0,
-      },
-    };
-
-    expect(config.messages.maxFetchIterations).toBe(5);
-  });
-
-  it('should have default maxFetchIterations of 30', () => {
-    expect(defaultSdkConfig.messages.maxFetchIterations).toBe(30);
-  });
-});