@unicitylabs/nostr-js-sdk 0.2.3 → 0.2.5

package/dist/browser/index.umd.js

@@ -5994,10 +5994,11 @@
      */
     /** Connection timeout in milliseconds */
     const CONNECTION_TIMEOUT_MS = 30000;
-    /** Reconnection delay in milliseconds */
-    const RECONNECT_DELAY_MS = 5000;
-    /** Default query timeout in milliseconds */
+    /** Default options */
     const DEFAULT_QUERY_TIMEOUT_MS = 5000;
+    const DEFAULT_RECONNECT_INTERVAL_MS = 1000;
+    const DEFAULT_MAX_RECONNECT_INTERVAL_MS = 30000;
+    const DEFAULT_PING_INTERVAL_MS = 30000;
     /**
      * NostrClient provides the main interface for Nostr protocol operations.
      */
@@ -6009,7 +6010,14 @@
         pendingOks = new Map();
         subscriptionCounter = 0;
         closed = false;
+        // Configuration options
         queryTimeoutMs;
+        autoReconnect;
+        reconnectIntervalMs;
+        maxReconnectIntervalMs;
+        pingIntervalMs;
+        // Connection event listeners
+        connectionListeners = [];
         /**
          * Create a NostrClient instance.
          * @param keyManager Key manager with signing keys
@@ -6018,6 +6026,53 @@
         constructor(keyManager, options) {
             this.keyManager = keyManager;
             this.queryTimeoutMs = options?.queryTimeoutMs ?? DEFAULT_QUERY_TIMEOUT_MS;
+            this.autoReconnect = options?.autoReconnect ?? true;
+            this.reconnectIntervalMs = options?.reconnectIntervalMs ?? DEFAULT_RECONNECT_INTERVAL_MS;
+            this.maxReconnectIntervalMs = options?.maxReconnectIntervalMs ?? DEFAULT_MAX_RECONNECT_INTERVAL_MS;
+            this.pingIntervalMs = options?.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS;
+        }
+        /**
+         * Add a connection event listener.
+         * @param listener Listener for connection events
+         */
+        addConnectionListener(listener) {
+            this.connectionListeners.push(listener);
+        }
+        /**
+         * Remove a connection event listener.
+         * @param listener Listener to remove
+         */
+        removeConnectionListener(listener) {
+            const index = this.connectionListeners.indexOf(listener);
+            if (index !== -1) {
+                this.connectionListeners.splice(index, 1);
+            }
+        }
+        /**
+         * Emit a connection event to all listeners.
+         */
+        emitConnectionEvent(eventType, relayUrl, extra) {
+            for (const listener of this.connectionListeners) {
+                try {
+                    switch (eventType) {
+                        case 'connect':
+                            listener.onConnect?.(relayUrl);
+                            break;
+                        case 'disconnect':
+                            listener.onDisconnect?.(relayUrl, extra);
+                            break;
+                        case 'reconnecting':
+                            listener.onReconnecting?.(relayUrl, extra);
+                            break;
+                        case 'reconnected':
+                            listener.onReconnected?.(relayUrl);
+                            break;
+                    }
+                }
+                catch {
+                    // Ignore listener errors
+                }
+            }
         }
         /**
          * Get the key manager.
@@ -6054,13 +6109,12 @@
         }
         /**
          * Connect to a single relay.
+         * @param isReconnect Whether this is a reconnection attempt
          */
-        async connectToRelay(url) {
-            if (this.relays.has(url)) {
-                const relay = this.relays.get(url);
-                if (relay.connected) {
-                    return;
-                }
+        async connectToRelay(url, isReconnect = false) {
+            const existingRelay = this.relays.get(url);
+            if (existingRelay?.connected) {
+                return;
             }
             return new Promise((resolve, reject) => {
                 const timeoutId = setTimeout(() => {
@@ -6073,11 +6127,28 @@
                         socket,
                         connected: false,
                         reconnecting: false,
+                        reconnectAttempts: 0,
+                        reconnectTimer: null,
+                        pingTimer: null,
+                        lastPongTime: Date.now(),
+                        wasConnected: existingRelay?.wasConnected ?? false,
                     };
                     socket.onopen = () => {
                         clearTimeout(timeoutId);
                         relay.connected = true;
+                        relay.reconnectAttempts = 0; // Reset on successful connection
+                        relay.lastPongTime = Date.now();
                         this.relays.set(url, relay);
+                        // Emit appropriate connection event
+                        if (isReconnect && relay.wasConnected) {
+                            this.emitConnectionEvent('reconnected', url);
+                        }
+                        else {
+                            this.emitConnectionEvent('connect', url);
+                        }
+                        relay.wasConnected = true;
+                        // Start ping health check
+                        this.startPingTimer(url);
                         // Re-establish subscriptions
                         this.resubscribeAll(url);
                         // Flush queued events
@@ -6087,15 +6158,26 @@
                     socket.onmessage = (event) => {
                         try {
                             const data = extractMessageData(event);
+                            // Update last pong time on any message (relay is alive)
+                            const r = this.relays.get(url);
+                            if (r) {
+                                r.lastPongTime = Date.now();
+                            }
                             this.handleRelayMessage(url, data);
                         }
                         catch (error) {
                             console.error(`Error handling message from ${url}:`, error);
                         }
                     };
-                    socket.onclose = () => {
+                    socket.onclose = (event) => {
+                        const wasConnected = relay.connected;
                         relay.connected = false;
-                        if (!this.closed && !relay.reconnecting) {
+                        this.stopPingTimer(url);
+                        if (wasConnected) {
+                            const reason = event?.reason || 'Connection closed';
+                            this.emitConnectionEvent('disconnect', url, reason);
+                        }
+                        if (!this.closed && this.autoReconnect && !relay.reconnecting) {
                             this.scheduleReconnect(url);
                         }
                     };
@@ -6114,24 +6196,103 @@
             });
         }
         /**
-         * Schedule a reconnection attempt for a relay.
+         * Schedule a reconnection attempt for a relay with exponential backoff.
          */
         scheduleReconnect(url) {
             const relay = this.relays.get(url);
-            if (!relay || this.closed)
+            if (!relay || this.closed || !this.autoReconnect)
                 return;
+            // Clear any existing reconnect timer
+            if (relay.reconnectTimer) {
+                clearTimeout(relay.reconnectTimer);
+            }
             relay.reconnecting = true;
-            setTimeout(async () => {
+            relay.reconnectAttempts++;
+            // Calculate delay with exponential backoff
+            const baseDelay = this.reconnectIntervalMs;
+            const exponentialDelay = baseDelay * Math.pow(2, relay.reconnectAttempts - 1);
+            const delay = Math.min(exponentialDelay, this.maxReconnectIntervalMs);
+            this.emitConnectionEvent('reconnecting', url, relay.reconnectAttempts);
+            relay.reconnectTimer = setTimeout(async () => {
                 if (this.closed)
                     return;
+                relay.reconnectTimer = null;
                 try {
                     relay.reconnecting = false;
-                    await this.connectToRelay(url);
+                    await this.connectToRelay(url, true);
+                }
+                catch {
+                    // Connection failed, schedule another attempt
+                    if (!this.closed && this.autoReconnect) {
+                        this.scheduleReconnect(url);
+                    }
+                }
+            }, delay);
+        }
+        /**
+         * Start the ping timer for a relay to detect stale connections.
+         */
+        startPingTimer(url) {
+            if (this.pingIntervalMs <= 0)
+                return;
+            const relay = this.relays.get(url);
+            if (!relay)
+                return;
+            // Stop existing timer if any
+            this.stopPingTimer(url);
+            relay.pingTimer = setInterval(() => {
+                if (!relay.connected || !relay.socket) {
+                    this.stopPingTimer(url);
+                    return;
+                }
+                // Check if we've received any message recently
+                const timeSinceLastPong = Date.now() - relay.lastPongTime;
+                if (timeSinceLastPong > this.pingIntervalMs * 2) {
+                    // Connection is stale - force close and reconnect
+                    console.warn(`Relay ${url} appears stale (no response for ${timeSinceLastPong}ms), reconnecting...`);
+                    this.stopPingTimer(url);
+                    try {
+                        relay.socket.close();
+                    }
+                    catch {
+                        // Ignore close errors
+                    }
+                    return;
+                }
+                // Send a subscription request as a ping (relays respond with EOSE)
+                // Use a single fixed subscription ID per relay to avoid accumulating subscriptions
+                // Note: limit:1 is used because some relays don't respond to limit:0
+                try {
+                    const pingSubId = `ping`;
+                    // First close any existing ping subscription to ensure we don't accumulate
+                    const closeMessage = JSON.stringify(['CLOSE', pingSubId]);
+                    relay.socket.send(closeMessage);
+                    // Then send the new ping request (limit:1 ensures relay sends EOSE)
+                    const pingMessage = JSON.stringify(['REQ', pingSubId, { limit: 1 }]);
+                    relay.socket.send(pingMessage);
                 }
                 catch {
-                    // Will trigger another reconnect via onclose
+                    // Send failed, connection likely dead
+                    console.warn(`Ping to ${url} failed, reconnecting...`);
+                    this.stopPingTimer(url);
+                    try {
+                        relay.socket.close();
+                    }
+                    catch {
+                        // Ignore close errors
+                    }
                 }
-            }, RECONNECT_DELAY_MS);
+            }, this.pingIntervalMs);
+        }
+        /**
+         * Stop the ping timer for a relay.
+         */
+        stopPingTimer(url) {
+            const relay = this.relays.get(url);
+            if (relay?.pingTimer) {
+                clearInterval(relay.pingTimer);
+                relay.pingTimer = null;
+            }
         }
         /**
          * Re-establish all subscriptions for a relay.
@@ -6278,11 +6439,23 @@
                 item.reject(new Error('Client disconnected'));
             }
             this.eventQueue = [];
-            // Close all relay connections
-            for (const [, relay] of this.relays) {
+            // Close all relay connections and clean up timers
+            for (const [url, relay] of this.relays) {
+                // Stop ping timer
+                if (relay.pingTimer) {
+                    clearInterval(relay.pingTimer);
+                    relay.pingTimer = null;
+                }
+                // Stop reconnect timer
+                if (relay.reconnectTimer) {
+                    clearTimeout(relay.reconnectTimer);
+                    relay.reconnectTimer = null;
+                }
+                // Close socket
                 if (relay.socket && relay.socket.readyState !== CLOSED) {
                     relay.socket.close(1000, 'Client disconnected');
                 }
+                this.emitConnectionEvent('disconnect', url, 'Client disconnected');
             }
             this.relays.clear();
             this.subscriptions.clear();