@leofcoin/chain 1.7.98 → 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/browser/{client-BDXkFVRR-BZjYAtds.js → client-UwSHOtRi-BsddY8I0.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './node-browser-D0JliYju.js';
+import { L as LittlePubSub } from './node-browser-DPfaEz6Y.js';
 import './identity-Cn0iQbY3-CeW0giQS.js';
 import './index-DUfUgiQY.js';
 
@@ -428,7 +428,11 @@ class Client {
     #peerId;
     #connections = {};
     #stars = {};
+    #starListeners = {};
+    #handlersSetup = false;
+    #reinitLock = null;
     #connectEvent = 'peer:connected';
+    #retryOptions = { retries: 5, factor: 2, minTimeout: 1000, maxTimeout: 30000 };
     id;
     networkVersion;
     starsConfig;
@@ -467,21 +471,80 @@ class Client {
         this.version = version;
         this.#connectEvent = connectEvent;
         this.starsConfig = stars;
+        if (options?.retry)
+            this.#retryOptions = { ...this.#retryOptions, ...options.retry };
         this._init();
     }
-    async _init() {
-        // reconnectJob()
-        if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-Cjcx-T47-D0KbGYCz.js').then(function (n) { return n.b; })).default;
-        for (const star of this.starsConfig) {
+    /**
+     * Safely reinitialize the client (used after system resume/sleep).
+     * It closes existing connections and reconnects to configured stars.
+     */
+    async reinit() {
+        // avoid concurrent reinit runs
+        if (this.#reinitLock)
+            return this.#reinitLock;
+        this.#reinitLock = (async () => {
+            debug('reinit: start');
+            try {
+                await this.close();
+                // clear internal maps so setupStar starts fresh
+                this.#stars = {};
+                this.#connections = {};
+                for (const star of this.starsConfig) {
+                    try {
+                        await this.setupStar(star);
+                    }
+                    catch (e) {
+                        // If last star fails and none connected, surface error
+                        if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
+                            Object.keys(this.#stars).length === 0)
+                            throw new Error(`No star available to connect`);
+                    }
+                }
+            }
+            finally {
+                debug('reinit: done');
+                this.#reinitLock = null;
+            }
+        })();
+        return this.#reinitLock;
+    }
+    async setupStar(star) {
+        const { retries, factor, minTimeout, maxTimeout } = this.#retryOptions;
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        let attempt = 0;
+        let lastErr;
+        while (attempt <= retries) {
             try {
                 const client = new SocketRequestClient(star, this.networkVersion);
                 this.#stars[star] = await client.init();
-                this.setupStarListeners(this.#stars[star]);
+                this.setupStarListeners(this.#stars[star], star);
                 this.#stars[star].send({
                     url: 'join',
                     params: { version: this.version, peerId: this.peerId }
                 });
+                return this.#stars[star];
+            }
+            catch (e) {
+                lastErr = e;
+                attempt += 1;
+                if (attempt > retries)
+                    break;
+                const delay = Math.min(maxTimeout, Math.round(minTimeout * Math.pow(factor, attempt - 1)));
+                debug(`setupStar ${star} failed, retrying in ${delay}ms (attempt ${attempt})`);
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(delay);
+            }
+        }
+        throw lastErr;
+    }
+    async _init() {
+        // reconnectJob()
+        if (!globalThis.RTCPeerConnection)
+            globalThis.wrtc = (await import('./browser-Cjcx-T47-D0KbGYCz.js').then(function (n) { return n.b; })).default;
+        for (const star of this.starsConfig) {
+            try {
+                await this.setupStar(star);
             }
             catch (e) {
                 if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1 &&
@@ -499,13 +562,68 @@ class Client {
         else {
             globalThis.addEventListener('beforeunload', this.close.bind(this));
         }
+        // Setup resume/sleep detection so we can reinit connections after wake
+        this._setupResumeHandler();
+    }
+    setupStarListeners(starConnection, starId) {
+        // create stable references to handlers so we can unsubscribe later
+        const onPeerJoined = (id) => this.#peerJoined(id, starConnection);
+        const onPeerLeft = (id) => this.#peerLeft(id, starConnection);
+        const onStarJoined = this.#starJoined;
+        const onStarLeft = this.#starLeft;
+        const onSignal = (message) => this.#inComingSignal(message, starConnection);
+        starConnection.pubsub.subscribe('peer:joined', onPeerJoined);
+        starConnection.pubsub.subscribe('peer:left', onPeerLeft);
+        starConnection.pubsub.subscribe('star:joined', onStarJoined);
+        starConnection.pubsub.subscribe('star:left', onStarLeft);
+        starConnection.pubsub.subscribe('signal', onSignal);
+        this.#starListeners[starId] = [
+            { topic: 'peer:joined', handler: onPeerJoined },
+            { topic: 'peer:left', handler: onPeerLeft },
+            { topic: 'star:joined', handler: onStarJoined },
+            { topic: 'star:left', handler: onStarLeft },
+            { topic: 'signal', handler: onSignal }
+        ];
     }
-    setupStarListeners(star) {
-        star.pubsub.subscribe('peer:joined', (id) => this.#peerJoined(id, star));
-        star.pubsub.subscribe('peer:left', (id) => this.#peerLeft(id, star));
-        star.pubsub.subscribe('star:joined', this.#starJoined);
-        star.pubsub.subscribe('star:left', this.#starLeft);
-        star.pubsub.subscribe('signal', (message) => this.#inComingSignal(message, star));
+    _setupResumeHandler() {
+        if (this.#handlersSetup)
+            return;
+        this.#handlersSetup = true;
+        const THRESHOLD = 10 * 1000; // 10s gap indicates sleep/wake
+        let last = Date.now();
+        const check = () => {
+            const now = Date.now();
+            const delta = now - last;
+            last = now;
+            if (delta > THRESHOLD) {
+                debug(`resume detected (gap ${delta}ms)`);
+                this.reinit().catch((e) => debug('reinit error', e));
+            }
+        };
+        // Start interval checker
+        const iv = setInterval(check, 2000);
+        // Browser specific events
+        if (typeof document !== 'undefined' && document.addEventListener) {
+            document.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'visible') {
+                    // small delay to let timers update
+                    setTimeout(() => check(), 50);
+                }
+            });
+            window.addEventListener('online', () => setTimeout(() => check(), 50));
+        }
+        // Node: listen for SIGCONT (process continued) as well
+        if (globalThis.process?.on) {
+            try {
+                process.on('SIGCONT', () => setTimeout(() => check(), 50));
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        // keep reference so it can be cleared on close
+        // @ts-ignore
+        this._resumeInterval = iv;
     }
     #starJoined = (id) => {
         if (this.#stars[id]) {
@@ -519,20 +637,16 @@ class Client {
             this.#stars[id].close(0);
             delete this.#stars[id];
         }
+        // if we lost all stars, try to reconnect to configured stars with backoff
         if (Object.keys(this.#stars).length === 0) {
             for (const star of this.starsConfig) {
                 try {
-                    const socketClient = await new SocketRequestClient(star, this.networkVersion).init();
-                    if (!socketClient?.client?.OPEN)
-                        return;
-                    this.#stars[star] = socketClient;
-                    this.#stars[star].send({
-                        url: 'join',
-                        params: { peerId: this.peerId, version: this.version }
-                    });
-                    this.setupStarListeners(socketClient);
+                    await this.setupStar(star);
+                    // stop at first success
+                    return;
                 }
                 catch (e) {
+                    debug(`reconnect star ${star} failed: ${e.message || e}`);
                     if (this.starsConfig.indexOf(star) === this.starsConfig.length - 1)
                         throw new Error(`No star available to connect`);
                 }
@@ -611,7 +725,7 @@ class Client {
             // Destroy the existing peer connection
             // peer.destroy()
             // delete this.#connections[from]
-            // // Create a new peer connection with the correct configuration
+            // // // Create a new peer connection with the correct configuration
             // this.#createRTCPeerConnection(from, star, version, false)
             // peer = this.#connections[from]
         }
@@ -685,15 +799,53 @@ class Client {
         peer.destroy();
     };
     async close() {
+        // clear resume interval if set
+        // @ts-ignore
+        if (this._resumeInterval) {
+            // @ts-ignore
+            clearInterval(this._resumeInterval);
+            // @ts-ignore
+            this._resumeInterval = null;
+        }
         for (const star in this.#stars) {
-            if (this.#stars[star].connectionState() === 'open')
+            if (this.#stars[star].connectionState() === 'open') {
                 await this.#stars[star].send({ url: 'leave', params: this.peerId });
+                // unsubscribe handlers we registered earlier
+                const listeners = this.#starListeners[star];
+                if (listeners && listeners.length) {
+                    for (const { topic, handler } of listeners) {
+                        try {
+                            this.#stars[star].pubsub.unsubscribe(topic, handler);
+                        }
+                        catch (e) {
+                            // ignore
+                        }
+                    }
+                }
+            }
         }
-        const promises = [
-            Object.values(this.#connections).map((connection) => connection.destroy()),
-            Object.values(this.#stars).map((connection) => connection.close(0))
-        ];
-        return Promise.allSettled(promises);
+        // Ensure we wait for all peer and star close/destroy operations.
+        // Previous code passed an array of arrays to Promise.allSettled which
+        // resolves immediately; flatten into a single array of promises (or
+        // values) so we actually wait for async close operations.
+        const peerClosers = Object.values(this.#connections).map((connection) => {
+            try {
+                // destroy() may be sync or return a promise
+                return connection.destroy();
+            }
+            catch (e) {
+                return undefined;
+            }
+        });
+        const starClosers = Object.values(this.#stars).map((connection) => {
+            try {
+                return connection.close(0);
+            }
+            catch (e) {
+                return undefined;
+            }
+        });
+        return Promise.allSettled([...peerClosers, ...starClosers]);
     }
 }
 

package/exports/browser/{messages-DDEOxfJp-CggxH-2R.js → messages-CFqwXbrQ-D0JHZ5TG.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './node-browser-D0JliYju.js';
+import { F as FormatInterface } from './node-browser-DPfaEz6Y.js';
 import './identity-Cn0iQbY3-CeW0giQS.js';
 import './index-DUfUgiQY.js';
 

package/exports/browser/{node-browser-D0JliYju.js → node-browser-DPfaEz6Y.js}

@@ -8491,7 +8491,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-DDEOxfJp-CggxH-2R.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-CFqwXbrQ-D0JHZ5TG.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8585,7 +8585,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-BDXkFVRR-BZjYAtds.js');
+        const importee = await import('./client-UwSHOtRi-BsddY8I0.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/node-browser.js

@@ -1,3 +1,3 @@
-export { N as default } from './node-browser-D0JliYju.js';
+export { N as default } from './node-browser-DPfaEz6Y.js';
 import './identity-Cn0iQbY3-CeW0giQS.js';
 import './index-DUfUgiQY.js';

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.98",
+  "version": "1.7.100",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {
@@ -69,7 +69,7 @@
     "@leofcoin/messages": "^1.4.40",
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/networks": "^1.1.25",
-    "@leofcoin/peernet": "^1.1.97",
+    "@leofcoin/peernet": "^1.1.98",
     "@leofcoin/storage": "^3.5.38",
     "@leofcoin/utils": "^1.1.40",
     "@leofcoin/workers": "^1.5.27",