@massalabs/gossip-sdk 0.0.1

package/src/core/SdkEventEmitter.ts

@@ -0,0 +1,91 @@
+/**
+ * SDK Event Emitter
+ *
+ * Type-safe event emitter for SDK events.
+ */
+
+import type { Message, Discussion, Contact } from '../db';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Event Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type SdkEventType =
+  | 'message'
+  | 'messageSent'
+  | 'messageFailed'
+  | 'discussionRequest'
+  | 'discussionStatusChanged'
+  | 'sessionBroken'
+  | 'sessionRenewed'
+  | 'error';
+
+export interface SdkEventHandlers {
+  message: (message: Message) => void;
+  messageSent: (message: Message) => void;
+  messageFailed: (message: Message, error: Error) => void;
+  discussionRequest: (discussion: Discussion, contact: Contact) => void;
+  discussionStatusChanged: (discussion: Discussion) => void;
+  sessionBroken: (discussion: Discussion) => void;
+  sessionRenewed: (discussion: Discussion) => void;
+  error: (error: Error, context: string) => void;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Event Emitter Class
+// ─────────────────────────────────────────────────────────────────────────────
+
+export class SdkEventEmitter {
+  private handlers = {
+    message: new Set<SdkEventHandlers['message']>(),
+    messageSent: new Set<SdkEventHandlers['messageSent']>(),
+    messageFailed: new Set<SdkEventHandlers['messageFailed']>(),
+    discussionRequest: new Set<SdkEventHandlers['discussionRequest']>(),
+    discussionStatusChanged: new Set<
+      SdkEventHandlers['discussionStatusChanged']
+    >(),
+    sessionBroken: new Set<SdkEventHandlers['sessionBroken']>(),
+    sessionRenewed: new Set<SdkEventHandlers['sessionRenewed']>(),
+    error: new Set<SdkEventHandlers['error']>(),
+  };
+
+  /**
+   * Register an event handler
+   */
+  on<K extends SdkEventType>(event: K, handler: SdkEventHandlers[K]): void {
+    (this.handlers[event] as Set<SdkEventHandlers[K]>).add(handler);
+  }
+
+  /**
+   * Remove an event handler
+   */
+  off<K extends SdkEventType>(event: K, handler: SdkEventHandlers[K]): void {
+    (this.handlers[event] as Set<SdkEventHandlers[K]>).delete(handler);
+  }
+
+  /**
+   * Emit an event to all registered handlers
+   */
+  emit<K extends SdkEventType>(
+    event: K,
+    ...args: Parameters<SdkEventHandlers[K]>
+  ): void {
+    const handlers = this.handlers[event] as Set<SdkEventHandlers[K]>;
+    handlers.forEach(handler => {
+      try {
+        (handler as (...args: Parameters<SdkEventHandlers[K]>) => void)(
+          ...args
+        );
+      } catch (error) {
+        console.error(`[SdkEventEmitter] Error in ${event} handler:`, error);
+      }
+    });
+  }
+
+  /**
+   * Remove all handlers for all events
+   */
+  clear(): void {
+    Object.values(this.handlers).forEach(set => set.clear());
+  }
+}

package/src/core/SdkPolling.ts

@@ -0,0 +1,134 @@
+/**
+ * SDK Polling Manager
+ *
+ * Manages polling timers for messages, announcements, and session refresh.
+ */
+
+import type { SdkConfig } from '../config/sdk';
+import type { Discussion } from '../db';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface PollingCallbacks {
+  /** Fetch messages from protocol */
+  fetchMessages: () => Promise<void>;
+  /** Fetch and process announcements */
+  fetchAnnouncements: () => Promise<void>;
+  /** Handle session refresh for active discussions */
+  handleSessionRefresh: (discussions: Discussion[]) => Promise<void>;
+  /** Get active discussions for session refresh */
+  getActiveDiscussions: () => Promise<Discussion[]>;
+  /** Called when a polling error occurs */
+  onError: (error: Error, context: string) => void;
+}
+
+interface PollingTimers {
+  messages: ReturnType<typeof setInterval> | null;
+  announcements: ReturnType<typeof setInterval> | null;
+  sessionRefresh: ReturnType<typeof setInterval> | null;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Polling Manager Class
+// ─────────────────────────────────────────────────────────────────────────────
+
+export class SdkPolling {
+  private timers: PollingTimers = {
+    messages: null,
+    announcements: null,
+    sessionRefresh: null,
+  };
+
+  private callbacks: PollingCallbacks | null = null;
+
+  /**
+   * Start polling with the given configuration and callbacks.
+   */
+  start(config: SdkConfig, callbacks: PollingCallbacks): void {
+    // Stop any existing timers first
+    this.stop();
+
+    this.callbacks = callbacks;
+
+    console.log('[SdkPolling] Starting polling', {
+      messagesIntervalMs: config.polling.messagesIntervalMs,
+      announcementsIntervalMs: config.polling.announcementsIntervalMs,
+      sessionRefreshIntervalMs: config.polling.sessionRefreshIntervalMs,
+    });
+
+    // Start message polling
+    this.timers.messages = setInterval(async () => {
+      try {
+        await this.callbacks?.fetchMessages();
+      } catch (error) {
+        console.error('[SdkPolling] Message polling error:', error);
+        this.callbacks?.onError(
+          error instanceof Error ? error : new Error(String(error)),
+          'message_polling'
+        );
+      }
+    }, config.polling.messagesIntervalMs);
+
+    // Start announcement polling
+    this.timers.announcements = setInterval(async () => {
+      try {
+        await this.callbacks?.fetchAnnouncements();
+      } catch (error) {
+        console.error('[SdkPolling] Announcement polling error:', error);
+        this.callbacks?.onError(
+          error instanceof Error ? error : new Error(String(error)),
+          'announcement_polling'
+        );
+      }
+    }, config.polling.announcementsIntervalMs);
+
+    // Start session refresh polling
+    this.timers.sessionRefresh = setInterval(async () => {
+      try {
+        const discussions = await this.callbacks?.getActiveDiscussions();
+        if (discussions && discussions.length > 0) {
+          await this.callbacks?.handleSessionRefresh(discussions);
+        }
+      } catch (error) {
+        console.error('[SdkPolling] Session refresh polling error:', error);
+        this.callbacks?.onError(
+          error instanceof Error ? error : new Error(String(error)),
+          'session_refresh_polling'
+        );
+      }
+    }, config.polling.sessionRefreshIntervalMs);
+  }
+
+  /**
+   * Stop all polling timers.
+   */
+  stop(): void {
+    if (this.timers.messages) {
+      clearInterval(this.timers.messages);
+      this.timers.messages = null;
+    }
+    if (this.timers.announcements) {
+      clearInterval(this.timers.announcements);
+      this.timers.announcements = null;
+    }
+    if (this.timers.sessionRefresh) {
+      clearInterval(this.timers.sessionRefresh);
+      this.timers.sessionRefresh = null;
+    }
+
+    this.callbacks = null;
+  }
+
+  /**
+   * Check if polling is currently running.
+   */
+  isRunning(): boolean {
+    return (
+      this.timers.messages !== null ||
+      this.timers.announcements !== null ||
+      this.timers.sessionRefresh !== null
+    );
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Core SDK components
+ */
+
+export { SdkEventEmitter } from './SdkEventEmitter';
+export type { SdkEventType, SdkEventHandlers } from './SdkEventEmitter';
+
+export { SdkPolling } from './SdkPolling';
+export type { PollingCallbacks } from './SdkPolling';

package/src/crypto/bip39.ts

@@ -0,0 +1,84 @@
+/**
+ * BIP39 utilities for mnemonic generation, validation, and seed derivation
+ * Using @scure/bip39 for browser compatibility
+ */
+
+import {
+  generateMnemonic as generateMnemonicScure,
+  mnemonicToSeedSync,
+  validateMnemonic as validateMnemonicScure,
+} from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english.js';
+import { Account, PrivateKey } from '@massalabs/massa-web3';
+import varint from 'varint';
+
+export const PRIVATE_KEY_VERSION = 0;
+
+/**
+ * Generate a new BIP39 mnemonic phrase
+ * @param strength - Entropy strength in bits (128, 160, 192, 224, 256)
+ * @returns Generated mnemonic phrase
+ */
+export function generateMnemonic(strength = 256): string {
+  // @scure/bip39 generateMnemonic expects strength in bits (128, 160, 192, 224, 256)
+  return generateMnemonicScure(wordlist, strength);
+}
+
+/**
+ * Validate a BIP39 mnemonic phrase
+ * @param mnemonic - The mnemonic phrase to validate
+ * @returns True if valid, false otherwise
+ */
+export function validateMnemonic(mnemonic: string): boolean {
+  return validateMnemonicScure(mnemonic, wordlist);
+}
+
+/**
+ * Generate a seed from mnemonic and optional passphrase
+ * @param mnemonic - The BIP39 mnemonic phrase
+ * @param passphrase - Optional passphrase (empty string if not provided)
+ * @returns Uint8Array seed
+ */
+export function mnemonicToSeed(
+  mnemonic: string,
+  passphrase: string = ''
+): Uint8Array {
+  return mnemonicToSeedSync(mnemonic, passphrase);
+}
+
+/**
+ * Create a Massa blockchain account from a mnemonic phrase
+ *
+ * @param mnemonic - The BIP39 mnemonic phrase
+ * @param passphrase - Optional passphrase for additional security
+ * @returns Massa Account object
+ * @throws Error if mnemonic is invalid
+ */
+export async function accountFromMnemonic(
+  mnemonic: string,
+  passphrase?: string
+): Promise<Account> {
+  try {
+    if (!validateMnemonic(mnemonic)) {
+      throw new Error('Invalid mnemonic phrase');
+    }
+
+    const seed = mnemonicToSeed(mnemonic, passphrase);
+
+    const versionArray = varint.encode(PRIVATE_KEY_VERSION);
+
+    const privateKeyBytes = seed.slice(0, 32);
+    const privateKey = new Uint8Array([...versionArray, ...privateKeyBytes]);
+
+    const pkey = PrivateKey.fromBytes(privateKey);
+    const account = await Account.fromPrivateKey(pkey);
+    return account;
+  } catch (error) {
+    console.error('Error in accountFromMnemonic:', error);
+    console.error(
+      'Error stack:',
+      error instanceof Error ? error.stack : 'No stack'
+    );
+    throw error;
+  }
+}

package/src/crypto/encryption.ts

@@ -0,0 +1,77 @@
+/**
+ * High-level encryption utilities
+ *
+ * Provides convenient wrappers for encrypting and decrypting strings
+ * using the WASM encryption primitives.
+ */
+
+import {
+  decryptAead,
+  encryptAead,
+  EncryptionKey,
+  generateNonce,
+  Nonce,
+} from '../wasm/encryption';
+
+/**
+ * Encrypt a plaintext string using AES-256-SIV
+ *
+ * @param plaintext - The string to encrypt
+ * @param key - The encryption key (64 bytes)
+ * @param salt - Optional salt/nonce bytes (will generate random if not provided)
+ * @returns Object containing encrypted data and nonce bytes
+ */
+export async function encrypt(
+  plaintext: string,
+  key: EncryptionKey,
+  salt?: Uint8Array
+): Promise<{ encryptedData: Uint8Array; nonce: Uint8Array }> {
+  const nonce = salt ? Nonce.from_bytes(salt) : await generateNonce();
+  const encryptedData = await encryptAead(
+    key,
+    nonce,
+    new TextEncoder().encode(plaintext),
+    new Uint8Array()
+  );
+  return { encryptedData, nonce: nonce.to_bytes() };
+}
+
+/**
+ * Decrypt encrypted data back to a string
+ *
+ * @param encryptedData - The encrypted data bytes
+ * @param salt - The nonce/salt used during encryption
+ * @param key - The encryption key (must match encryption key)
+ * @returns The decrypted plaintext string
+ * @throws Error if decryption fails (wrong key, corrupted data, etc.)
+ */
+export async function decrypt(
+  encryptedData: Uint8Array,
+  salt: Uint8Array,
+  key: EncryptionKey
+): Promise<string> {
+  const plain = await decryptAead(
+    key,
+    Nonce.from_bytes(salt),
+    encryptedData,
+    new Uint8Array()
+  );
+  if (!plain) {
+    throw new Error('Failed to decrypt data');
+  }
+  return new TextDecoder().decode(plain);
+}
+
+/**
+ * Derive an encryption key from a seed string and nonce
+ *
+ * @param seedString - The seed string (e.g., password)
+ * @param nonce - The nonce/salt for key derivation
+ * @returns The derived encryption key
+ */
+export async function deriveKey(
+  seedString: string,
+  nonce: Uint8Array
+): Promise<EncryptionKey> {
+  return await EncryptionKey.from_seed(seedString, nonce);
+}