@leofcoin/chain 1.7.104 → 1.7.106

package/exports/browser/chain.js

@@ -5405,27 +5405,12 @@ class ConnectionMonitor {
         const connectedPeers = this.connectedPeers;
         const compatiblePeers = this.compatiblePeers;
         console.log(`🔍 Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible`);
-        if (connectedPeers.length === 0) {
-            console.warn('⚠️ No peer connections detected');
-            await this.#attemptReconnection();
-        }
-        else if (compatiblePeers.length === 0) {
-            console.warn('⚠️ No compatible peers found');
-            await this.#attemptReconnection();
-            // Could attempt to find compatible peers or trigger version negotiation
-        }
-        // Log disconnected peers
-        // const disconnectedPeers = this.disconnectedPeers
-        // if (disconnectedPeers.length > 0) {
-        //   console.warn(`⚠️ Disconnected peers: ${disconnectedPeers.map((peer) => peer.peerId).join(', ')}`)
-        //   // Attempt to reconnect each disconnected peer sequentially to avoid racing signaling/state
-        //   for (const peer of disconnectedPeers) {
-        //     // 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)
-        //   }
+        // if (connectedPeers.length === 0) {
+        console.warn('⚠️ No peer connections detected');
+        // await this.#attemptReconnection()
+        // } else if (compatiblePeers.length === 0) {
+        console.warn('⚠️ No compatible peers found');
+        // await this.#attemptReconnection()
         // }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
@@ -5434,59 +5419,74 @@ class ConnectionMonitor {
             healthy: compatiblePeers.length > 0
         });
     }
-    // helper: try to close/destroy a single peer connection and remove it from peernet's map
-    async #cleanupPeerState(peerId, peernet) {
-        try {
-            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();
-                }
+    // lightweight TCP probe to detect internet connectivity in Node.js
+    async #isOnLine(timeout = 1500) {
+        // If not running in Node, fallback to navigator.onLine if available, otherwise assume online
+        if (typeof process === 'undefined') {
+            if (navigator?.onLine !== undefined) {
+                return navigator.onLine;
             }
-            catch (e) {
-                // ignore
-            }
-            // call any destroy/cleanup API on the connection object
+            return true;
+        }
+        return new Promise(async (resolve) => {
             try {
-                if (typeof conn.destroy === 'function') {
-                    conn.destroy();
-                }
-                else if (typeof conn.close === 'function') {
-                    conn.close();
-                }
+                // lazy require so bundlers / browser builds don't break
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const net = await import('net');
+                const socket = new net.Socket();
+                let finished = false;
+                const finish = (val) => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    try {
+                        socket.destroy();
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                    resolve(val);
+                };
+                socket.setTimeout(timeout);
+                socket.once('connect', () => finish(true));
+                socket.once('error', () => finish(false));
+                socket.once('timeout', () => finish(false));
+                // connect to Cloudflare DNS (1.1.1.1) on TCP/53 — fast and reliable
+                socket.connect(53, '1.1.1.1');
             }
             catch (e) {
-                // ignore
-            }
-            // remove reference so reconnect path will create a fresh one
-            try {
-                delete peernet.connections[peerId];
+                resolve(false);
             }
-            catch (e) {
-                // ignore
+        });
+    }
+    // Called on visibility/online/resume events
+    async #restoreNetwork() {
+        console.log('🔁 Restoring network');
+        try {
+            const online = await this.#isOnLine(1500);
+            if (!online) {
+                console.warn('⚠️ No internet detected, skipping restore');
+                return;
             }
-            // small pause to let underlying sockets/RTCs settle
-            await new Promise((r) => setTimeout(r, 100));
         }
         catch (e) {
-            // ignore cleanup errors
+            // If the probe failed for any reason, continue with restore attempt
+            console.warn('⚠️ Online probe failed, proceeding with restore', e?.message || e);
+        }
+        try {
+            // prefer safe client reinit if available
+            console.log('🔄 Attempting to reinitialize peernet client');
+            await globalThis.peernet.client.reinit();
+        }
+        catch (e) {
+            console.warn('⚠️ peernet.client.reinit failed, falling back to peernet.start if available', e?.message || e);
+            try {
+                await globalThis.peernet.start();
+            }
+            catch (err) {
+                console.error('❌ peernet.start also failed during restore', err?.message || err);
+            }
         }
-    }
-    // Called on visibility/online/resume events
-    async #restoreNetwork() {
-        console.log('🔁 Restoring network after resume/wake');
-        globalThis.peernet.client.reinit();
-        // 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) {
         return new Promise((resolve) => {
@@ -5505,9 +5505,23 @@ class ConnectionMonitor {
             checkPeers();
         });
     }
-    // New: attempt reconnection flow (gentle start + sequential per-peer reconnect)
     async #attemptReconnection() {
-        console.warn('⚠️ Attempting to reconnect to peers...');
+        try {
+            await this.#restoreNetwork();
+        }
+        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`);
+            }
+            setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay);
+        }
     }
 }
 

package/exports/chain.js

@@ -1551,27 +1551,12 @@ class ConnectionMonitor {
         const connectedPeers = this.connectedPeers;
         const compatiblePeers = this.compatiblePeers;
         console.log(`🔍 Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible`);
-        if (connectedPeers.length === 0) {
-            console.warn('⚠️ No peer connections detected');
-            await this.#attemptReconnection();
-        }
-        else if (compatiblePeers.length === 0) {
-            console.warn('⚠️ No compatible peers found');
-            await this.#attemptReconnection();
-            // Could attempt to find compatible peers or trigger version negotiation
-        }
-        // Log disconnected peers
-        // const disconnectedPeers = this.disconnectedPeers
-        // if (disconnectedPeers.length > 0) {
-        //   console.warn(`⚠️ Disconnected peers: ${disconnectedPeers.map((peer) => peer.peerId).join(', ')}`)
-        //   // Attempt to reconnect each disconnected peer sequentially to avoid racing signaling/state
-        //   for (const peer of disconnectedPeers) {
-        //     // 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)
-        //   }
+        // if (connectedPeers.length === 0) {
+        console.warn('⚠️ No peer connections detected');
+        // await this.#attemptReconnection()
+        // } else if (compatiblePeers.length === 0) {
+        console.warn('⚠️ No compatible peers found');
+        // await this.#attemptReconnection()
         // }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
@@ -1580,59 +1565,74 @@ class ConnectionMonitor {
             healthy: compatiblePeers.length > 0
         });
     }
-    // helper: try to close/destroy a single peer connection and remove it from peernet's map
-    async #cleanupPeerState(peerId, peernet) {
-        try {
-            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
+    // lightweight TCP probe to detect internet connectivity in Node.js
+    async #isOnLine(timeout = 1500) {
+        // If not running in Node, fallback to navigator.onLine if available, otherwise assume online
+        if (typeof process === 'undefined') {
+            if (navigator?.onLine !== undefined) {
+                return navigator.onLine;
             }
-            // call any destroy/cleanup API on the connection object
+            return true;
+        }
+        return new Promise(async (resolve) => {
             try {
-                if (typeof conn.destroy === 'function') {
-                    conn.destroy();
-                }
-                else if (typeof conn.close === 'function') {
-                    conn.close();
-                }
+                // lazy require so bundlers / browser builds don't break
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const net = await import('net');
+                const socket = new net.Socket();
+                let finished = false;
+                const finish = (val) => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    try {
+                        socket.destroy();
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                    resolve(val);
+                };
+                socket.setTimeout(timeout);
+                socket.once('connect', () => finish(true));
+                socket.once('error', () => finish(false));
+                socket.once('timeout', () => finish(false));
+                // connect to Cloudflare DNS (1.1.1.1) on TCP/53 — fast and reliable
+                socket.connect(53, '1.1.1.1');
             }
             catch (e) {
-                // ignore
-            }
-            // remove reference so reconnect path will create a fresh one
-            try {
-                delete peernet.connections[peerId];
+                resolve(false);
             }
-            catch (e) {
-                // ignore
+        });
+    }
+    // Called on visibility/online/resume events
+    async #restoreNetwork() {
+        console.log('🔁 Restoring network');
+        try {
+            const online = await this.#isOnLine(1500);
+            if (!online) {
+                console.warn('⚠️ No internet detected, skipping restore');
+                return;
             }
-            // small pause to let underlying sockets/RTCs settle
-            await new Promise((r) => setTimeout(r, 100));
         }
         catch (e) {
-            // ignore cleanup errors
+            // If the probe failed for any reason, continue with restore attempt
+            console.warn('⚠️ Online probe failed, proceeding with restore', e?.message || e);
+        }
+        try {
+            // prefer safe client reinit if available
+            console.log('🔄 Attempting to reinitialize peernet client');
+            await globalThis.peernet.client.reinit();
+        }
+        catch (e) {
+            console.warn('⚠️ peernet.client.reinit failed, falling back to peernet.start if available', e?.message || e);
+            try {
+                await globalThis.peernet.start();
+            }
+            catch (err) {
+                console.error('❌ peernet.start also failed during restore', err?.message || err);
+            }
         }
-    }
-    // Called on visibility/online/resume events
-    async #restoreNetwork() {
-        console.log('🔁 Restoring network after resume/wake');
-        globalThis.peernet.client.reinit();
-        // 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) {
         return new Promise((resolve) => {
@@ -1651,9 +1651,23 @@ class ConnectionMonitor {
             checkPeers();
         });
     }
-    // New: attempt reconnection flow (gentle start + sequential per-peer reconnect)
     async #attemptReconnection() {
-        console.warn('⚠️ Attempting to reconnect to peers...');
+        try {
+            await this.#restoreNetwork();
+        }
+        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`);
+            }
+            setTimeout(() => this.#attemptReconnection(), this.#reconnectDelay);
+        }
     }
 }
 

package/package.json

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