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

package/dist/core/SdkEventEmitter.js

@@ -0,0 +1,59 @@
+/**
+ * SDK Event Emitter
+ *
+ * Type-safe event emitter for SDK events.
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Event Emitter Class
+// ─────────────────────────────────────────────────────────────────────────────
+export class SdkEventEmitter {
+    constructor() {
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                message: new Set(),
+                messageSent: new Set(),
+                messageFailed: new Set(),
+                discussionRequest: new Set(),
+                discussionStatusChanged: new Set(),
+                sessionBroken: new Set(),
+                sessionRenewed: new Set(),
+                error: new Set(),
+            }
+        });
+    }
+    /**
+     * Register an event handler
+     */
+    on(event, handler) {
+        this.handlers[event].add(handler);
+    }
+    /**
+     * Remove an event handler
+     */
+    off(event, handler) {
+        this.handlers[event].delete(handler);
+    }
+    /**
+     * Emit an event to all registered handlers
+     */
+    emit(event, ...args) {
+        const handlers = this.handlers[event];
+        handlers.forEach(handler => {
+            try {
+                handler(...args);
+            }
+            catch (error) {
+                console.error(`[SdkEventEmitter] Error in ${event} handler:`, error);
+            }
+        });
+    }
+    /**
+     * Remove all handlers for all events
+     */
+    clear() {
+        Object.values(this.handlers).forEach(set => set.clear());
+    }
+}

package/dist/core/SdkPolling.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SDK Polling Manager
+ *
+ * Manages polling timers for messages, announcements, and session refresh.
+ */
+import type { SdkConfig } from '../config/sdk';
+import type { Discussion } from '../db';
+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;
+}
+export declare class SdkPolling {
+    private timers;
+    private callbacks;
+    /**
+     * Start polling with the given configuration and callbacks.
+     */
+    start(config: SdkConfig, callbacks: PollingCallbacks): void;
+    /**
+     * Stop all polling timers.
+     */
+    stop(): void;
+    /**
+     * Check if polling is currently running.
+     */
+    isRunning(): boolean;
+}

package/dist/core/SdkPolling.js

@@ -0,0 +1,100 @@
+/**
+ * SDK Polling Manager
+ *
+ * Manages polling timers for messages, announcements, and session refresh.
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Polling Manager Class
+// ─────────────────────────────────────────────────────────────────────────────
+export class SdkPolling {
+    constructor() {
+        Object.defineProperty(this, "timers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                messages: null,
+                announcements: null,
+                sessionRefresh: null,
+            }
+        });
+        Object.defineProperty(this, "callbacks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Start polling with the given configuration and callbacks.
+     */
+    start(config, callbacks) {
+        // 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() {
+        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() {
+        return (this.timers.messages !== null ||
+            this.timers.announcements !== null ||
+            this.timers.sessionRefresh !== null);
+    }
+}

package/{src/core/index.ts → dist/core/index.d.ts}

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

package/dist/core/index.js

@@ -0,0 +1,5 @@
+/**
+ * Core SDK components
+ */
+export { SdkEventEmitter } from './SdkEventEmitter';
+export { SdkPolling } from './SdkPolling';

package/dist/crypto/bip39.d.ts

@@ -0,0 +1,34 @@
+/**
+ * BIP39 utilities for mnemonic generation, validation, and seed derivation
+ * Using @scure/bip39 for browser compatibility
+ */
+import { Account } from '@massalabs/massa-web3';
+export declare 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 declare function generateMnemonic(strength?: number): string;
+/**
+ * Validate a BIP39 mnemonic phrase
+ * @param mnemonic - The mnemonic phrase to validate
+ * @returns True if valid, false otherwise
+ */
+export declare function validateMnemonic(mnemonic: string): boolean;
+/**
+ * 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 declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Uint8Array;
+/**
+ * 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 declare function accountFromMnemonic(mnemonic: string, passphrase?: string): Promise<Account>;

package/dist/crypto/bip39.js

@@ -0,0 +1,62 @@
+/**
+ * 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) {
+    // @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) {
+    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, passphrase = '') {
+    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, passphrase) {
+    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/dist/crypto/encryption.d.ts

@@ -0,0 +1,37 @@
+/**
+ * High-level encryption utilities
+ *
+ * Provides convenient wrappers for encrypting and decrypting strings
+ * using the WASM encryption primitives.
+ */
+import { EncryptionKey } 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 declare function encrypt(plaintext: string, key: EncryptionKey, salt?: Uint8Array): Promise<{
+    encryptedData: Uint8Array;
+    nonce: Uint8Array;
+}>;
+/**
+ * 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 declare function decrypt(encryptedData: Uint8Array, salt: Uint8Array, key: EncryptionKey): Promise<string>;
+/**
+ * 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 declare function deriveKey(seedString: string, nonce: Uint8Array): Promise<EncryptionKey>;

package/dist/crypto/encryption.js

@@ -0,0 +1,46 @@
+/**
+ * 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, key, salt) {
+    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, salt, key) {
+    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, nonce) {
+    return await EncryptionKey.from_seed(seedString, nonce);
+}

package/dist/db.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Gossip Database
+ *
+ * IndexedDB database implementation using Dexie for the Gossip messenger.
+ * Provides tables for contacts, messages, discussions, user profiles, and more.
+ */
+import Dexie, { Table } from 'dexie';
+export type AuthMethod = 'capacitor' | 'webauthn' | 'password';
+export interface Contact {
+    id?: number;
+    ownerUserId: string;
+    userId: string;
+    name: string;
+    avatar?: string;
+    publicKeys: Uint8Array;
+    isOnline: boolean;
+    lastSeen: Date;
+    createdAt: Date;
+}
+export interface Message {
+    id?: number;
+    ownerUserId: string;
+    contactUserId: string;
+    content: string;
+    serializedContent?: Uint8Array;
+    type: MessageType;
+    direction: MessageDirection;
+    status: MessageStatus;
+    timestamp: Date;
+    metadata?: Record<string, unknown>;
+    seeker?: Uint8Array;
+    replyTo?: {
+        originalContent?: string;
+        originalSeeker: Uint8Array;
+    };
+    forwardOf?: {
+        originalContent?: string;
+        originalSeeker: Uint8Array;
+    };
+    encryptedMessage?: Uint8Array;
+}
+export interface UserProfile {
+    userId: string;
+    username: string;
+    avatar?: string;
+    security: {
+        encKeySalt: Uint8Array;
+        authMethod: AuthMethod;
+        webauthn?: {
+            credentialId?: string;
+        };
+        iCloudSync?: boolean;
+        mnemonicBackup: {
+            encryptedMnemonic: Uint8Array;
+            createdAt: Date;
+            backedUp: boolean;
+        };
+    };
+    session: Uint8Array;
+    bio?: string;
+    status: 'online' | 'away' | 'busy' | 'offline';
+    lastSeen: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    lastPublicKeyPush?: Date;
+    lastBulletinCounter?: string;
+}
+export declare enum DiscussionStatus {
+    PENDING = "pending",
+    ACTIVE = "active",
+    CLOSED = "closed",// closed by the user
+    BROKEN = "broken",// The session is killed. Need to be reinitiated
+    SEND_FAILED = "sendFailed",// The discussion was initiated by the session manager but could not be broadcasted on network
+    RECONNECTING = "reconnecting"
+}
+export declare enum MessageDirection {
+    INCOMING = "incoming",
+    OUTGOING = "outgoing"
+}
+export declare enum MessageStatus {
+    WAITING_SESSION = "waiting_session",// Waiting for active session with peer
+    SENDING = "sending",
+    SENT = "sent",
+    DELIVERED = "delivered",
+    READ = "read",
+    FAILED = "failed"
+}
+export declare enum DiscussionDirection {
+    INITIATED = "initiated",
+    RECEIVED = "received"
+}
+export declare enum MessageType {
+    TEXT = "text",
+    KEEP_ALIVE = "keep_alive",
+    IMAGE = "image",
+    FILE = "file",
+    AUDIO = "audio",
+    VIDEO = "video"
+}
+export interface Discussion {
+    id?: number;
+    ownerUserId: string;
+    contactUserId: string;
+    direction: DiscussionDirection;
+    status: DiscussionStatus;
+    nextSeeker?: Uint8Array;
+    initiationAnnouncement?: Uint8Array;
+    announcementMessage?: string;
+    lastSyncTimestamp?: Date;
+    customName?: string;
+    lastMessageId?: number;
+    lastMessageContent?: string;
+    lastMessageTimestamp?: Date;
+    unreadCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface PendingEncryptedMessage {
+    id?: number;
+    seeker: Uint8Array;
+    ciphertext: Uint8Array;
+    fetchedAt: Date;
+}
+export interface PendingAnnouncement {
+    id?: number;
+    announcement: Uint8Array;
+    fetchedAt: Date;
+    counter?: string;
+}
+export interface ActiveSeeker {
+    id?: number;
+    seeker: Uint8Array;
+}
+export declare class GossipDatabase extends Dexie {
+    contacts: Table<Contact>;
+    messages: Table<Message>;
+    userProfile: Table<UserProfile>;
+    discussions: Table<Discussion>;
+    pendingEncryptedMessages: Table<PendingEncryptedMessage>;
+    pendingAnnouncements: Table<PendingAnnouncement>;
+    activeSeekers: Table<ActiveSeeker>;
+    constructor();
+    /** CONTACTS */
+    getContactsByOwner(ownerUserId: string): Promise<Contact[]>;
+    getContactByOwnerAndUserId(ownerUserId: string, userId: string): Promise<Contact | undefined>;
+    /** DISCUSSIONS */
+    getDiscussionsByOwner(ownerUserId: string): Promise<Discussion[]>;
+    getUnreadCountByOwner(ownerUserId: string): Promise<number>;
+    getDiscussionByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<Discussion | undefined>;
+    /**
+     * Get all active discussions with their sync status
+     * @returns Array of active discussions
+     */
+    getActiveDiscussionsByOwner(ownerUserId: string): Promise<Discussion[]>;
+    markMessagesAsRead(ownerUserId: string, contactUserId: string): Promise<void>;
+    getMessagesForContactByOwner(ownerUserId: string, contactUserId: string, limit?: number): Promise<Message[]>;
+    addMessage(message: Omit<Message, 'id'>): Promise<number>;
+    /**
+     * Update the last sync timestamp for a discussion
+     * @param discussionId - The discussion ID
+     * @param timestamp - The sync timestamp
+     */
+    updateLastSyncTimestamp(discussionId: number, timestamp: Date): Promise<void>;
+    deleteDb(): Promise<void>;
+    /**
+     * Set all active seekers, replacing any existing ones
+     * @param seekers - Array of seeker Uint8Arrays to store
+     */
+    setActiveSeekers(seekers: Uint8Array[]): Promise<void>;
+    /**
+     * Get all active seekers from the database
+     * @returns Array of seeker Uint8Arrays
+     */
+    getActiveSeekers(): Promise<Uint8Array[]>;
+}
+/**
+ * Get the database instance.
+ * Creates a default instance if none was set via setDb().
+ */
+export declare function getDb(): GossipDatabase;
+/**
+ * Set the database instance.
+ * Call this before using any SDK functions if you need a custom db instance.
+ */
+export declare function setDb(database: GossipDatabase): void;
+/**
+ * Get the database instance.
+ * Creates a default instance if none was set via setDb().
+ */
+export declare const db: GossipDatabase;