@unicitylabs/nostr-js-sdk 0.2.3 → 0.2.5

package/README.md

@@ -44,16 +44,28 @@ console.log(keyManager.getPublicKeyHex());
 ### Connecting to Relays
 
 ```typescript
-import { NostrClient, NostrKeyManager } from '@unicitylabs/nostr-sdk';
+import { NostrClient, NostrKeyManager, ConnectionEventListener } from '@unicitylabs/nostr-sdk';
 
 const keyManager = NostrKeyManager.generate();
 
-// Create client with default options
+// Create client with default options (auto-reconnect enabled)
 const client = new NostrClient(keyManager);
 
 // Or configure with custom options
 const client = new NostrClient(keyManager, {
-  queryTimeoutMs: 15000,  // Increase timeout for slow relays (default: 5000ms)
+  queryTimeoutMs: 15000,        // Query timeout (default: 5000ms)
+  autoReconnect: true,          // Auto-reconnect on connection loss (default: true)
+  reconnectIntervalMs: 1000,    // Initial reconnect delay (default: 1000ms)
+  maxReconnectIntervalMs: 30000, // Max backoff interval (default: 30000ms)
+  pingIntervalMs: 30000,        // Health check interval (default: 30000ms, 0 to disable)
+});
+
+// Monitor connection events
+client.addConnectionListener({
+  onConnect: (url) => console.log(`Connected to ${url}`),
+  onDisconnect: (url, reason) => console.log(`Disconnected from ${url}: ${reason}`),
+  onReconnecting: (url, attempt) => console.log(`Reconnecting to ${url} (attempt ${attempt})...`),
+  onReconnected: (url) => console.log(`Reconnected to ${url}`),
 });
 
 // Connect to relays
@@ -66,7 +78,7 @@ await client.connect(
 console.log(client.isConnected());
 console.log(client.getConnectedRelays());
 
-// You can also adjust timeout dynamically
+// Adjust timeout dynamically
 client.setQueryTimeout(30000);  // 30 seconds
 ```
 

package/dist/browser/index.js

@@ -5988,10 +5988,11 @@ var nip17 = /*#__PURE__*/Object.freeze({
  */
 /** 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.
  */
@@ -6003,7 +6004,14 @@ class NostrClient {
     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
@@ -6012,6 +6020,53 @@ class NostrClient {
     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.
@@ -6048,13 +6103,12 @@ class NostrClient {
     }
     /**
      * 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(() => {
@@ -6067,11 +6121,28 @@ class NostrClient {
                     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
@@ -6081,15 +6152,26 @@ class NostrClient {
                 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);
                     }
                 };
@@ -6108,24 +6190,103 @@ class NostrClient {
         });
     }
     /**
-     * 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.
@@ -6272,11 +6433,23 @@ class NostrClient {
             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();