@leofcoin/chain 1.7.103 → 1.7.104

package/exports/browser/chain.js

@@ -5347,13 +5347,13 @@ class ConnectionMonitor {
                 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);
+            // 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 = () => {
@@ -5415,18 +5415,18 @@ class ConnectionMonitor {
             // 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);
-            }
-        }
+        // 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)
+        //   }
+        // }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
             connected: connectedPeers.length,
@@ -5434,71 +5434,6 @@ class ConnectionMonitor {
             healthy: compatiblePeers.length > 0
         });
     }
-    async #attemptPeerReconnection(peer) {
-        if (!peer)
-            return;
-        const peerId = peer.peerId || peer.id;
-        if (!peerId)
-            return;
-        if (!this.#peerReconnectAttempts[peerId]) {
-            this.#peerReconnectAttempts[peerId] = 0;
-        }
-        if (this.#peerReconnectAttempts[peerId] >= this.#maxReconnectAttempts) {
-            console.error('❌ Max reconnection attempts reached for', peerId);
-            this.#peerReconnectAttempts[peerId] = 0;
-            return;
-        }
-        this.#peerReconnectAttempts[peerId]++;
-        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peerId]}/${this.#maxReconnectAttempts} for ${peerId}`);
-        try {
-            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 || error);
-            // As fallback, try full restart only if even the cleanup+retry failed
-            if (globalThis.peernet) {
-                await this.#performFullRestart(globalThis.peernet);
-            }
-        }
-    }
     // helper: try to close/destroy a single peer connection and remove it from peernet's map
     async #cleanupPeerState(peerId, peernet) {
         try {
@@ -5541,64 +5476,17 @@ class ConnectionMonitor {
             // 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 {
-                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');
+        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();
-        }
+        // 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) => {
@@ -5620,31 +5508,6 @@ class ConnectionMonitor {
     // New: attempt reconnection flow (gentle start + sequential per-peer reconnect)
     async #attemptReconnection() {
         console.warn('⚠️ Attempting to reconnect to peers...');
-        try {
-            // 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`);
-            }
-        }
     }
 }
 

package/exports/chain.js

@@ -1493,13 +1493,13 @@ class ConnectionMonitor {
                 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);
+            // 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 = () => {
@@ -1561,18 +1561,18 @@ class ConnectionMonitor {
             // 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);
-            }
-        }
+        // 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)
+        //   }
+        // }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
             connected: connectedPeers.length,
@@ -1580,71 +1580,6 @@ class ConnectionMonitor {
             healthy: compatiblePeers.length > 0
         });
     }
-    async #attemptPeerReconnection(peer) {
-        if (!peer)
-            return;
-        const peerId = peer.peerId || peer.id;
-        if (!peerId)
-            return;
-        if (!this.#peerReconnectAttempts[peerId]) {
-            this.#peerReconnectAttempts[peerId] = 0;
-        }
-        if (this.#peerReconnectAttempts[peerId] >= this.#maxReconnectAttempts) {
-            console.error('❌ Max reconnection attempts reached for', peerId);
-            this.#peerReconnectAttempts[peerId] = 0;
-            return;
-        }
-        this.#peerReconnectAttempts[peerId]++;
-        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peerId]}/${this.#maxReconnectAttempts} for ${peerId}`);
-        try {
-            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 || error);
-            // As fallback, try full restart only if even the cleanup+retry failed
-            if (globalThis.peernet) {
-                await this.#performFullRestart(globalThis.peernet);
-            }
-        }
-    }
     // helper: try to close/destroy a single peer connection and remove it from peernet's map
     async #cleanupPeerState(peerId, peernet) {
         try {
@@ -1687,64 +1622,17 @@ class ConnectionMonitor {
             // 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 {
-                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');
+        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();
-        }
+        // 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) => {
@@ -1766,31 +1654,6 @@ class ConnectionMonitor {
     // New: attempt reconnection flow (gentle start + sequential per-peer reconnect)
     async #attemptReconnection() {
         console.warn('⚠️ Attempting to reconnect to peers...');
-        try {
-            // 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`);
-            }
-        }
     }
 }
 

package/package.json

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