@leofcoin/chain 1.7.99 → 1.7.100

package/exports/browser/chain.js

@@ -5317,6 +5317,10 @@ class ConnectionMonitor {
     #reconnectDelay = 5000;
     #healthCheckInterval = 10000;
     #version;
+    // event handlers to remove later
+    #onOnline = null;
+    #onVisibilityChange = null;
+    #onSigcont = null;
     get isMonitoring() {
         return this.#isMonitoring;
     }
@@ -5336,6 +5340,33 @@ class ConnectionMonitor {
             return;
         this.#isMonitoring = true;
         console.log('🔄 Starting connection monitor...');
+        // Listen for resume/network events (browser + node/electron)
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            this.#onOnline = () => {
+                console.log('🌐 Network online — attempting restore');
+                void this.#restoreNetwork();
+            };
+            window.addEventListener('online', this.#onOnline);
+            this.#onVisibilityChange = () => {
+                if (document.visibilityState === 'visible') {
+                    console.log('💡 Visibility regained — attempting restore');
+                    void this.#restoreNetwork();
+                }
+            };
+            document.addEventListener('visibilitychange', this.#onVisibilityChange);
+        }
+        if (typeof process !== 'undefined' && typeof process.on === 'function') {
+            this.#onSigcont = () => {
+                console.log('🔔 Process resumed (SIGCONT) — attempting restore');
+                void this.#restoreNetwork();
+            };
+            try {
+                process.on('SIGCONT', this.#onSigcont);
+            }
+            catch (e) {
+                // ignore if not supported
+            }
+        }
         this.#checkInterval = setInterval(() => {
             this.#healthCheck();
         }, this.#healthCheckInterval);
@@ -5350,6 +5381,26 @@ class ConnectionMonitor {
             clearInterval(this.#checkInterval);
             this.#checkInterval = null;
         }
+        // remove listeners
+        if (typeof window !== 'undefined') {
+            if (this.#onOnline) {
+                window.removeEventListener('online', this.#onOnline);
+                this.#onOnline = null;
+            }
+            if (this.#onVisibilityChange) {
+                document.removeEventListener('visibilitychange', this.#onVisibilityChange);
+                this.#onVisibilityChange = null;
+            }
+        }
+        if (typeof process !== 'undefined' && typeof process.removeListener === 'function' && this.#onSigcont) {
+            try {
+                process.removeListener('SIGCONT', this.#onSigcont);
+            }
+            catch (e) {
+                // ignore
+            }
+            this.#onSigcont = null;
+        }
         console.log('⏹️ Connection monitor stopped');
     }
     async #healthCheck() {
@@ -5369,12 +5420,14 @@ class ConnectionMonitor {
         const disconnectedPeers = this.disconnectedPeers;
         if (disconnectedPeers.length > 0) {
             console.warn(`⚠️ Disconnected peers: ${disconnectedPeers.map((peer) => peer.peerId).join(', ')}`);
-            // Attempt to reconnect each disconnected peer
-            const promises = [];
+            // Attempt to reconnect each disconnected peer sequentially to avoid racing signaling/state
             for (const peer of disconnectedPeers) {
-                promises.push(this.#attemptPeerReconnection(peer));
+                // small spacing between attempts to reduce signaling races
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((r) => setTimeout(r, 150));
+                // eslint-disable-next-line no-await-in-loop
+                await this.#attemptPeerReconnection(peer);
             }
-            await Promise.all(promises);
         }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
@@ -5384,54 +5437,169 @@ class ConnectionMonitor {
         });
     }
     async #attemptPeerReconnection(peer) {
-        if (this.#peerReconnectAttempts[peer.peerId] >= this.#maxReconnectAttempts) {
-            console.error('❌ Max reconnection attempts reached');
-            this.#peerReconnectAttempts[peer.peerId] = 0;
+        if (!peer)
+            return;
+        const peerId = peer.peerId || peer.id;
+        if (!peerId)
+            return;
+        if (!this.#peerReconnectAttempts[peerId]) {
+            this.#peerReconnectAttempts[peerId] = 0;
         }
-        if (!this.#peerReconnectAttempts[peer.peerId]) {
-            this.#peerReconnectAttempts[peer.peerId] = 0;
+        if (this.#peerReconnectAttempts[peerId] >= this.#maxReconnectAttempts) {
+            console.error('❌ Max reconnection attempts reached for', peerId);
+            this.#peerReconnectAttempts[peerId] = 0;
+            return;
         }
-        this.#peerReconnectAttempts[peer.peerId]++;
-        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peer.peerId]}/${this.#maxReconnectAttempts}`);
+        this.#peerReconnectAttempts[peerId]++;
+        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peerId]}/${this.#maxReconnectAttempts} for ${peerId}`);
         try {
-            const peerId = peer.peerId || peer.id;
-            // Attempt to reconnect the specific peer
-            await peernet.client.reconnect(peerId, globalThis.peernet?.stars[0]);
+            const peernet = globalThis.peernet;
+            if (!peernet) {
+                console.warn('⚠️ globalThis.peernet not available');
+                return;
+            }
+            // Try targeted reconnect if available
+            if (peernet.client?.reconnect) {
+                try {
+                    await peernet.client.reconnect(peerId, peernet.stars?.[0]);
+                    return;
+                }
+                catch (err) {
+                    const msg = String(err?.message || err);
+                    console.warn('⚠️ Targeted reconnect failed:', msg);
+                    // handle signaling/state mismatches by cleaning up only that peer and retrying targeted reconnect
+                    if (msg.includes('Called in wrong state') ||
+                        msg.includes('setRemoteDescription') ||
+                        msg.includes('channelNames') ||
+                        msg.includes("channelNames don't match")) {
+                        console.warn('⚠️ Detected signaling/channel mismatch — cleaning up peer state and retrying targeted reconnect');
+                        try {
+                            await this.#cleanupPeerState(peerId, peernet);
+                            // small backoff before retry
+                            await new Promise((r) => setTimeout(r, 150));
+                            await peernet.client.reconnect(peerId, peernet.stars?.[0]);
+                            return;
+                        }
+                        catch (retryErr) {
+                            console.warn('⚠️ Retry targeted reconnect failed:', String(retryErr?.message || retryErr));
+                            // fall through to non-targeted fallback below
+                        }
+                    }
+                    throw err;
+                }
+            }
+            // If no targeted reconnect, try start/restore
+            if (peernet.start) {
+                await peernet.start();
+            }
         }
         catch (error) {
-            console.error('❌ Reconnection failed:', error.message);
+            console.error('❌ Reconnection failed:', error?.message || error);
+            // As fallback, try full restart only if even the cleanup+retry failed
+            if (globalThis.peernet) {
+                await this.#performFullRestart(globalThis.peernet);
+            }
         }
-        //   // Try to restart the network
-        //   if (globalThis.peernet?.start) {
-        //     await globalThis.peernet.start()
-        //   } else {
-        //     console.warn('⚠️ Peernet start method not available, skipping reconnection')
-        //   }
-        // } catch (error) {
-        //   console.error('❌ Reconnection failed:', error.message)
-        // }
     }
-    async #attemptReconnection() {
-        console.warn('⚠️ Attempting to reconnect to peers...');
+    // helper: try to close/destroy a single peer connection and remove it from peernet's map
+    async #cleanupPeerState(peerId, peernet) {
         try {
-            // Try to restart the network
-            // if (globalThis.peernet?.start) {
-            //   await globalThis.peernet.start()
-            // }
-            // Wait a bit before next check
-            await new Promise((resolve) => setTimeout(resolve, this.#reconnectDelay));
+            const conns = peernet.connections || {};
+            const conn = conns[peerId] || conns[Object.keys(conns).find((k) => k.includes(peerId) || peerId.includes(k))];
+            if (!conn)
+                return;
+            // close underlying RTCPeerConnection if exposed
+            try {
+                if (conn.pc && typeof conn.pc.close === 'function') {
+                    conn.pc.close();
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // call any destroy/cleanup API on the connection object
+            try {
+                if (typeof conn.destroy === 'function') {
+                    conn.destroy();
+                }
+                else if (typeof conn.close === 'function') {
+                    conn.close();
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // remove reference so reconnect path will create a fresh one
+            try {
+                delete peernet.connections[peerId];
+            }
+            catch (e) {
+                // ignore
+            }
+            // small pause to let underlying sockets/RTCs settle
+            await new Promise((r) => setTimeout(r, 100));
         }
-        catch (error) {
-            console.error('❌ Reconnection failed:', error.message);
-            if (this.#reconnectDelay >= 30000) {
-                console.warn('⚠️ Reconnection delay reached maximum, resetting to 5 seconds');
-                this.#reconnectDelay = 5000;
+        catch (e) {
+            // ignore cleanup errors
+        }
+    }
+    // New helper: close stale RTCPeerConnections if present and then restart peernet
+    async #performFullRestart(peernet) {
+        try {
+            // Close underlying peer RTCPeerConnections if the library exposes them
+            try {
+                const conns = peernet.connections || {};
+                for (const id of Object.keys(conns)) {
+                    const p = conns[id];
+                    // try to close underlying RTCPeerConnection if exposed
+                    if (p && p.pc && typeof p.pc.close === 'function') {
+                        try {
+                            p.pc.close();
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // If the library supports stop -> start, do that to fully reset signaling state
+            if (typeof peernet.stop === 'function') {
+                try {
+                    await peernet.stop();
+                }
+                catch (e) {
+                    // ignore stop errors
+                }
+            }
+            // small delay to ensure sockets/RTCs are closed
+            await new Promise((r) => setTimeout(r, 250));
+            if (typeof peernet.start === 'function') {
+                await peernet.start();
             }
             else {
-                // Exponential backoff
-                this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 30000);
-                console.warn(`⚠️ Increasing reconnection delay to ${this.#reconnectDelay} ms`);
+                console.warn('⚠️ peernet.start not available for full restart');
             }
+            // reset reconnect attempts so we can try fresh
+            this.#peerReconnectAttempts = {};
+            console.log('✅ Full peernet restart completed');
+        }
+        catch (e) {
+            console.error('❌ Full restart failed:', e?.message || e);
+        }
+    }
+    // Called on visibility/online/resume events
+    async #restoreNetwork() {
+        console.log('🔁 Restoring network after resume/wake');
+        // If there is a peernet instance, try a safe restore
+        if (globalThis.peernet) {
+            await this.#performFullRestart(globalThis.peernet);
+        }
+        else {
+            // If no global peernet, attempt a normal reconnection flow
+            await this.#attemptReconnection();
         }
     }
     async waitForPeers(timeoutMs = 30000) {
@@ -5451,6 +5619,39 @@ class ConnectionMonitor {
             checkPeers();
         });
     }
+    // New: attempt reconnection flow (gentle start + sequential per-peer reconnect)
+    async #attemptReconnection() {
+        console.warn('⚠️ Attempting to reconnect to peers...');
+        try {
+            // gentle restore: if peernet supports start(), try that first
+            if (globalThis.peernet?.start) {
+                await globalThis.peernet.start();
+            }
+            // attempt targeted reconnection for disconnected peers sequentially (avoid racing WebRTC state)
+            const disconnected = this.disconnectedPeers;
+            for (const p of disconnected) {
+                // small spacing between attempts to reduce signaling races
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((r) => setTimeout(r, 200));
+                // eslint-disable-next-line no-await-in-loop
+                await this.#attemptPeerReconnection(p);
+            }
+            // pause before next health check cycle
+            await new Promise((resolve) => setTimeout(resolve, this.#reconnectDelay));
+        }
+        catch (error) {
+            console.error('❌ Reconnection failed:', error?.message || error);
+            if (this.#reconnectDelay >= 30000) {
+                console.warn('⚠️ Reconnection delay reached maximum, resetting to 5 seconds');
+                this.#reconnectDelay = 5000;
+            }
+            else {
+                // exponential-ish backoff
+                this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 30000);
+                console.warn(`⚠️ Increasing reconnection delay to ${this.#reconnectDelay} ms`);
+            }
+        }
+    }
 }
 
 const debug = globalThis.createDebugger('leofcoin/chain');

package/exports/chain.js

@@ -1463,6 +1463,10 @@ class ConnectionMonitor {
     #reconnectDelay = 5000;
     #healthCheckInterval = 10000;
     #version;
+    // event handlers to remove later
+    #onOnline = null;
+    #onVisibilityChange = null;
+    #onSigcont = null;
     get isMonitoring() {
         return this.#isMonitoring;
     }
@@ -1482,6 +1486,33 @@ class ConnectionMonitor {
             return;
         this.#isMonitoring = true;
         console.log('🔄 Starting connection monitor...');
+        // Listen for resume/network events (browser + node/electron)
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            this.#onOnline = () => {
+                console.log('🌐 Network online — attempting restore');
+                void this.#restoreNetwork();
+            };
+            window.addEventListener('online', this.#onOnline);
+            this.#onVisibilityChange = () => {
+                if (document.visibilityState === 'visible') {
+                    console.log('💡 Visibility regained — attempting restore');
+                    void this.#restoreNetwork();
+                }
+            };
+            document.addEventListener('visibilitychange', this.#onVisibilityChange);
+        }
+        if (typeof process !== 'undefined' && typeof process.on === 'function') {
+            this.#onSigcont = () => {
+                console.log('🔔 Process resumed (SIGCONT) — attempting restore');
+                void this.#restoreNetwork();
+            };
+            try {
+                process.on('SIGCONT', this.#onSigcont);
+            }
+            catch (e) {
+                // ignore if not supported
+            }
+        }
         this.#checkInterval = setInterval(() => {
             this.#healthCheck();
         }, this.#healthCheckInterval);
@@ -1496,6 +1527,26 @@ class ConnectionMonitor {
             clearInterval(this.#checkInterval);
             this.#checkInterval = null;
         }
+        // remove listeners
+        if (typeof window !== 'undefined') {
+            if (this.#onOnline) {
+                window.removeEventListener('online', this.#onOnline);
+                this.#onOnline = null;
+            }
+            if (this.#onVisibilityChange) {
+                document.removeEventListener('visibilitychange', this.#onVisibilityChange);
+                this.#onVisibilityChange = null;
+            }
+        }
+        if (typeof process !== 'undefined' && typeof process.removeListener === 'function' && this.#onSigcont) {
+            try {
+                process.removeListener('SIGCONT', this.#onSigcont);
+            }
+            catch (e) {
+                // ignore
+            }
+            this.#onSigcont = null;
+        }
         console.log('⏹️ Connection monitor stopped');
     }
     async #healthCheck() {
@@ -1515,12 +1566,14 @@ class ConnectionMonitor {
         const disconnectedPeers = this.disconnectedPeers;
         if (disconnectedPeers.length > 0) {
             console.warn(`⚠️ Disconnected peers: ${disconnectedPeers.map((peer) => peer.peerId).join(', ')}`);
-            // Attempt to reconnect each disconnected peer
-            const promises = [];
+            // Attempt to reconnect each disconnected peer sequentially to avoid racing signaling/state
             for (const peer of disconnectedPeers) {
-                promises.push(this.#attemptPeerReconnection(peer));
+                // small spacing between attempts to reduce signaling races
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((r) => setTimeout(r, 150));
+                // eslint-disable-next-line no-await-in-loop
+                await this.#attemptPeerReconnection(peer);
             }
-            await Promise.all(promises);
         }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
@@ -1530,54 +1583,169 @@ class ConnectionMonitor {
         });
     }
     async #attemptPeerReconnection(peer) {
-        if (this.#peerReconnectAttempts[peer.peerId] >= this.#maxReconnectAttempts) {
-            console.error('❌ Max reconnection attempts reached');
-            this.#peerReconnectAttempts[peer.peerId] = 0;
+        if (!peer)
+            return;
+        const peerId = peer.peerId || peer.id;
+        if (!peerId)
+            return;
+        if (!this.#peerReconnectAttempts[peerId]) {
+            this.#peerReconnectAttempts[peerId] = 0;
         }
-        if (!this.#peerReconnectAttempts[peer.peerId]) {
-            this.#peerReconnectAttempts[peer.peerId] = 0;
+        if (this.#peerReconnectAttempts[peerId] >= this.#maxReconnectAttempts) {
+            console.error('❌ Max reconnection attempts reached for', peerId);
+            this.#peerReconnectAttempts[peerId] = 0;
+            return;
         }
-        this.#peerReconnectAttempts[peer.peerId]++;
-        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peer.peerId]}/${this.#maxReconnectAttempts}`);
+        this.#peerReconnectAttempts[peerId]++;
+        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peerId]}/${this.#maxReconnectAttempts} for ${peerId}`);
         try {
-            const peerId = peer.peerId || peer.id;
-            // Attempt to reconnect the specific peer
-            await peernet.client.reconnect(peerId, globalThis.peernet?.stars[0]);
+            const peernet = globalThis.peernet;
+            if (!peernet) {
+                console.warn('⚠️ globalThis.peernet not available');
+                return;
+            }
+            // Try targeted reconnect if available
+            if (peernet.client?.reconnect) {
+                try {
+                    await peernet.client.reconnect(peerId, peernet.stars?.[0]);
+                    return;
+                }
+                catch (err) {
+                    const msg = String(err?.message || err);
+                    console.warn('⚠️ Targeted reconnect failed:', msg);
+                    // handle signaling/state mismatches by cleaning up only that peer and retrying targeted reconnect
+                    if (msg.includes('Called in wrong state') ||
+                        msg.includes('setRemoteDescription') ||
+                        msg.includes('channelNames') ||
+                        msg.includes("channelNames don't match")) {
+                        console.warn('⚠️ Detected signaling/channel mismatch — cleaning up peer state and retrying targeted reconnect');
+                        try {
+                            await this.#cleanupPeerState(peerId, peernet);
+                            // small backoff before retry
+                            await new Promise((r) => setTimeout(r, 150));
+                            await peernet.client.reconnect(peerId, peernet.stars?.[0]);
+                            return;
+                        }
+                        catch (retryErr) {
+                            console.warn('⚠️ Retry targeted reconnect failed:', String(retryErr?.message || retryErr));
+                            // fall through to non-targeted fallback below
+                        }
+                    }
+                    throw err;
+                }
+            }
+            // If no targeted reconnect, try start/restore
+            if (peernet.start) {
+                await peernet.start();
+            }
         }
         catch (error) {
-            console.error('❌ Reconnection failed:', error.message);
+            console.error('❌ Reconnection failed:', error?.message || error);
+            // As fallback, try full restart only if even the cleanup+retry failed
+            if (globalThis.peernet) {
+                await this.#performFullRestart(globalThis.peernet);
+            }
         }
-        //   // Try to restart the network
-        //   if (globalThis.peernet?.start) {
-        //     await globalThis.peernet.start()
-        //   } else {
-        //     console.warn('⚠️ Peernet start method not available, skipping reconnection')
-        //   }
-        // } catch (error) {
-        //   console.error('❌ Reconnection failed:', error.message)
-        // }
     }
-    async #attemptReconnection() {
-        console.warn('⚠️ Attempting to reconnect to peers...');
+    // helper: try to close/destroy a single peer connection and remove it from peernet's map
+    async #cleanupPeerState(peerId, peernet) {
         try {
-            // Try to restart the network
-            // if (globalThis.peernet?.start) {
-            //   await globalThis.peernet.start()
-            // }
-            // Wait a bit before next check
-            await new Promise((resolve) => setTimeout(resolve, this.#reconnectDelay));
+            const conns = peernet.connections || {};
+            const conn = conns[peerId] || conns[Object.keys(conns).find((k) => k.includes(peerId) || peerId.includes(k))];
+            if (!conn)
+                return;
+            // close underlying RTCPeerConnection if exposed
+            try {
+                if (conn.pc && typeof conn.pc.close === 'function') {
+                    conn.pc.close();
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // call any destroy/cleanup API on the connection object
+            try {
+                if (typeof conn.destroy === 'function') {
+                    conn.destroy();
+                }
+                else if (typeof conn.close === 'function') {
+                    conn.close();
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // remove reference so reconnect path will create a fresh one
+            try {
+                delete peernet.connections[peerId];
+            }
+            catch (e) {
+                // ignore
+            }
+            // small pause to let underlying sockets/RTCs settle
+            await new Promise((r) => setTimeout(r, 100));
         }
-        catch (error) {
-            console.error('❌ Reconnection failed:', error.message);
-            if (this.#reconnectDelay >= 30000) {
-                console.warn('⚠️ Reconnection delay reached maximum, resetting to 5 seconds');
-                this.#reconnectDelay = 5000;
+        catch (e) {
+            // ignore cleanup errors
+        }
+    }
+    // New helper: close stale RTCPeerConnections if present and then restart peernet
+    async #performFullRestart(peernet) {
+        try {
+            // Close underlying peer RTCPeerConnections if the library exposes them
+            try {
+                const conns = peernet.connections || {};
+                for (const id of Object.keys(conns)) {
+                    const p = conns[id];
+                    // try to close underlying RTCPeerConnection if exposed
+                    if (p && p.pc && typeof p.pc.close === 'function') {
+                        try {
+                            p.pc.close();
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            // If the library supports stop -> start, do that to fully reset signaling state
+            if (typeof peernet.stop === 'function') {
+                try {
+                    await peernet.stop();
+                }
+                catch (e) {
+                    // ignore stop errors
+                }
+            }
+            // small delay to ensure sockets/RTCs are closed
+            await new Promise((r) => setTimeout(r, 250));
+            if (typeof peernet.start === 'function') {
+                await peernet.start();
             }
             else {
-                // Exponential backoff
-                this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 30000);
-                console.warn(`⚠️ Increasing reconnection delay to ${this.#reconnectDelay} ms`);
+                console.warn('⚠️ peernet.start not available for full restart');
             }
+            // reset reconnect attempts so we can try fresh
+            this.#peerReconnectAttempts = {};
+            console.log('✅ Full peernet restart completed');
+        }
+        catch (e) {
+            console.error('❌ Full restart failed:', e?.message || e);
+        }
+    }
+    // Called on visibility/online/resume events
+    async #restoreNetwork() {
+        console.log('🔁 Restoring network after resume/wake');
+        // If there is a peernet instance, try a safe restore
+        if (globalThis.peernet) {
+            await this.#performFullRestart(globalThis.peernet);
+        }
+        else {
+            // If no global peernet, attempt a normal reconnection flow
+            await this.#attemptReconnection();
         }
     }
     async waitForPeers(timeoutMs = 30000) {
@@ -1597,6 +1765,39 @@ class ConnectionMonitor {
             checkPeers();
         });
     }
+    // New: attempt reconnection flow (gentle start + sequential per-peer reconnect)
+    async #attemptReconnection() {
+        console.warn('⚠️ Attempting to reconnect to peers...');
+        try {
+            // gentle restore: if peernet supports start(), try that first
+            if (globalThis.peernet?.start) {
+                await globalThis.peernet.start();
+            }
+            // attempt targeted reconnection for disconnected peers sequentially (avoid racing WebRTC state)
+            const disconnected = this.disconnectedPeers;
+            for (const p of disconnected) {
+                // small spacing between attempts to reduce signaling races
+                // eslint-disable-next-line no-await-in-loop
+                await new Promise((r) => setTimeout(r, 200));
+                // eslint-disable-next-line no-await-in-loop
+                await this.#attemptPeerReconnection(p);
+            }
+            // pause before next health check cycle
+            await new Promise((resolve) => setTimeout(resolve, this.#reconnectDelay));
+        }
+        catch (error) {
+            console.error('❌ Reconnection failed:', error?.message || error);
+            if (this.#reconnectDelay >= 30000) {
+                console.warn('⚠️ Reconnection delay reached maximum, resetting to 5 seconds');
+                this.#reconnectDelay = 5000;
+            }
+            else {
+                // exponential-ish backoff
+                this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 30000);
+                console.warn(`⚠️ Increasing reconnection delay to ${this.#reconnectDelay} ms`);
+            }
+        }
+    }
 }
 
 const debug = globalThis.createDebugger('leofcoin/chain');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.7.99",
+  "version": "1.7.100",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {