@leofcoin/chain 1.7.76 → 1.7.78

package/exports/browser/browser-Cjcx-T47-D0KbGYCz.js

@@ -0,0 +1,38 @@
+import { g as getDefaultExportFromCjs } from './identity-Cn0iQbY3-CeW0giQS.js';
+
+var browser$2 = {};
+
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser$2;
+	hasRequiredBrowser = 1;
+
+	browser$2.MediaStream = window.MediaStream;
+	browser$2.MediaStreamTrack = window.MediaStreamTrack;
+	browser$2.RTCDataChannel = window.RTCDataChannel;
+	browser$2.RTCDataChannelEvent = window.RTCDataChannelEvent;
+	browser$2.RTCDtlsTransport = window.RTCDtlsTransport;
+	browser$2.RTCIceCandidate = window.RTCIceCandidate;
+	browser$2.RTCIceTransport = window.RTCIceTransport;
+	browser$2.RTCPeerConnection = window.RTCPeerConnection;
+	browser$2.RTCPeerConnectionIceEvent = window.RTCPeerConnectionIceEvent;
+	browser$2.RTCRtpReceiver = window.RTCRtpReceiver;
+	browser$2.RTCRtpSender = window.RTCRtpSender;
+	browser$2.RTCRtpTransceiver = window.RTCRtpTransceiver;
+	browser$2.RTCSctpTransport = window.RTCSctpTransport;
+	browser$2.RTCSessionDescription = window.RTCSessionDescription;
+	browser$2.getUserMedia = window.getUserMedia;
+	browser$2.mediaDevices = navigator.mediaDevices;
+	return browser$2;
+}
+
+var browserExports = requireBrowser();
+var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
+
+var browser$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: browser
+});
+
+export { browser$1 as b };

package/exports/browser/browser-nu3nKt2I-DENgb7BU.js

@@ -0,0 +1,132 @@
+import { g as getDefaultExportFromCjs } from './identity-Cn0iQbY3-CeW0giQS.js';
+
+var global;
+var hasRequiredGlobal;
+
+function requireGlobal () {
+	if (hasRequiredGlobal) return global;
+	hasRequiredGlobal = 1;
+	var naiveFallback = function () {
+		if (typeof self === "object" && self) return self;
+		if (typeof window === "object" && window) return window;
+		throw new Error("Unable to resolve global `this`");
+	};
+
+	global = (function () {
+		if (this) return this;
+
+		// Unexpected strict mode (may happen if e.g. bundled into ESM module)
+
+		// Fallback to standard globalThis if available
+		if (typeof globalThis === "object" && globalThis) return globalThis;
+
+		// Thanks @mathiasbynens -> https://mathiasbynens.be/notes/globalthis
+		// In all ES5+ engines global object inherits from Object.prototype
+		// (if you approached one that doesn't please report)
+		try {
+			Object.defineProperty(Object.prototype, "__global__", {
+				get: function () { return this; },
+				configurable: true
+			});
+		} catch (error) {
+			// Unfortunate case of updates to Object.prototype being restricted
+			// via preventExtensions, seal or freeze
+			return naiveFallback();
+		}
+		try {
+			// Safari case (window.__global__ works, but __global__ does not)
+			if (!__global__) return naiveFallback();
+			return __global__;
+		} finally {
+			delete Object.prototype.__global__;
+		}
+	})();
+	return global;
+}
+
+var version$1 = "1.0.35";
+var require$$0 = {
+	version: version$1};
+
+var version;
+var hasRequiredVersion;
+
+function requireVersion () {
+	if (hasRequiredVersion) return version;
+	hasRequiredVersion = 1;
+	version = require$$0.version;
+	return version;
+}
+
+var browser$2;
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser$2;
+	hasRequiredBrowser = 1;
+	var _globalThis;
+	if (typeof globalThis === 'object') {
+		_globalThis = globalThis;
+	} else {
+		try {
+			_globalThis = requireGlobal();
+		} catch (error) {
+		} finally {
+			if (!_globalThis && typeof window !== 'undefined') { _globalThis = window; }
+			if (!_globalThis) { throw new Error('Could not determine global this'); }
+		}
+	}
+
+	var NativeWebSocket = _globalThis.WebSocket || _globalThis.MozWebSocket;
+	var websocket_version = requireVersion();
+
+
+	/**
+	 * Expose a W3C WebSocket class with just one or two arguments.
+	 */
+	function W3CWebSocket(uri, protocols) {
+		var native_instance;
+
+		if (protocols) {
+			native_instance = new NativeWebSocket(uri, protocols);
+		}
+		else {
+			native_instance = new NativeWebSocket(uri);
+		}
+
+		/**
+		 * 'native_instance' is an instance of nativeWebSocket (the browser's WebSocket
+		 * class). Since it is an Object it will be returned as it is when creating an
+		 * instance of W3CWebSocket via 'new W3CWebSocket()'.
+		 *
+		 * ECMAScript 5: http://bclary.com/2004/11/07/#a-13.2.2
+		 */
+		return native_instance;
+	}
+	if (NativeWebSocket) {
+		['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'].forEach(function(prop) {
+			Object.defineProperty(W3CWebSocket, prop, {
+				get: function() { return NativeWebSocket[prop]; }
+			});
+		});
+	}
+
+	/**
+	 * Module exports.
+	 */
+	browser$2 = {
+	    'w3cwebsocket' : NativeWebSocket ? W3CWebSocket : null,
+	    'version'      : websocket_version
+	};
+	return browser$2;
+}
+
+var browserExports = requireBrowser();
+var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
+
+var browser$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: browser
+});
+
+export { browser$1 as b };

package/exports/browser/chain.js

@@ -5019,7 +5019,7 @@ class State extends Contract {
             const localBlock = await this.lastBlock;
             if (!localBlock || Number(localBlock.index) < Number(lastBlock.index)) {
                 // TODO: check if valid
-                const localIndex = localBlock ? localBlock.index : 0;
+                const localIndex = localBlock ? Number(localBlock.index) : 0;
                 const index = lastBlock.index;
                 await this.resolveBlock(lastBlock.hash);
                 console.log('ok');
@@ -5300,6 +5300,7 @@ class ConnectionMonitor {
     #isMonitoring = false;
     #checkInterval = null;
     #reconnectAttempts = 0;
+    #peerReconnectAttempts = {};
     #maxReconnectAttempts = 10;
     #reconnectDelay = 5000;
     #healthCheckInterval = 10000;
@@ -5313,11 +5314,12 @@ class ConnectionMonitor {
     get compatiblePeers() {
         return this.connectedPeers.filter((peer) => peer.version === this.#version);
     }
-    constructor(version) {
-        console.log(`🔗 Connection Monitor initialized for version: ${this.#version}`);
+    get disconnectedPeers() {
+        return Object.values(globalThis.peernet?.connections || {}).filter((peer) => !peer.connected);
     }
     start(version) {
         this.#version = version;
+        console.log(`🔗 Connection Monitor initialized for version: ${this.#version}`);
         if (this.#isMonitoring)
             return;
         this.#isMonitoring = true;
@@ -5348,12 +5350,24 @@ class ConnectionMonitor {
         }
         else if (compatiblePeers.length === 0) {
             console.warn('⚠️ No compatible peers found');
+            await this.#attemptReconnection();
             // Could attempt to find compatible peers or trigger version negotiation
         }
         else {
             // Reset reconnect attempts on successful connection
             this.#reconnectAttempts = 0;
         }
+        // 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
+            const promises = [];
+            for (const peer of disconnectedPeers) {
+                promises.push(this.#attemptPeerReconnection(peer));
+            }
+            await Promise.all(promises);
+        }
         // Publish connection status
         globalThis.pubsub?.publish('connection-status', {
             connected: connectedPeers.length,
@@ -5361,6 +5375,35 @@ class ConnectionMonitor {
             healthy: compatiblePeers.length > 0
         });
     }
+    async #attemptPeerReconnection(peer) {
+        if (this.#peerReconnectAttempts[peer.peerId] >= this.#maxReconnectAttempts) {
+            console.error('❌ Max reconnection attempts reached');
+            this.#peerReconnectAttempts[peer.peerId] = 0;
+            return;
+        }
+        if (!this.#peerReconnectAttempts[peer.peerId]) {
+            this.#peerReconnectAttempts[peer.peerId] = 0;
+        }
+        this.#peerReconnectAttempts[peer.peerId]++;
+        console.log(`🔄 Attempting reconnection ${this.#peerReconnectAttempts[peer.peerId]}/${this.#maxReconnectAttempts}`);
+        try {
+            const peerId = peer.peerId || peer.id;
+            // Attempt to reconnect the specific peer
+            await peernet.client.reconnect(peerId, globalThis.peernet?.stars[0]);
+        }
+        catch (error) {
+            console.error('❌ Reconnection failed:', error.message);
+        }
+        //   // 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() {
         if (this.#reconnectAttempts >= this.#maxReconnectAttempts) {
             console.error('❌ Max reconnection attempts reached');

package/exports/browser/{client-DD7vhDK_-BdNAdRzV.js → client-MAPwcc7G-CjrC1JNQ.js}

@@ -1,5 +1,5 @@
-import { L as LittlePubSub } from './node-browser-DMmrhyQS.js';
-import './identity--VAIVSMm-DTWL357I.js';
+import { L as LittlePubSub } from './node-browser-Ctauqi8V.js';
+import './identity-Cn0iQbY3-CeW0giQS.js';
 import './index-DUfUgiQY.js';
 
 class Api {
@@ -210,7 +210,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-BogfGRzB-D3fc2MzB.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-nu3nKt2I-DENgb7BU.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);
@@ -314,7 +314,7 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-Vgr1JQcP-DNJYAZ_u.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-CPXJrMI6-Bh4f9JBP.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
@@ -450,7 +450,7 @@ class Client {
     async _init() {
         // reconnectJob()
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-pguCHlVu-pguCHlVu.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-Cjcx-T47-D0KbGYCz.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 const client = new SocketRequestClient(star, this.networkVersion);
@@ -569,13 +569,13 @@ class Client {
             return;
         }
         if (String(peer.channelName) !== String(channelName)) {
-            console.warn(`channelNames don't match: got ${peer.channelName}, expected: ${channelName}. Recreating connection.`);
+            console.warn(`channelNames don't match: got ${peer.channelName}, expected: ${channelName}.`);
             // Destroy the existing peer connection
-            peer.destroy();
-            delete this.#connections[from];
-            // Create a new peer connection with the correct configuration
-            this.#createRTCPeerConnection(from, star, version, false);
-            peer = this.#connections[from];
+            // peer.destroy()
+            // delete this.#connections[from]
+            // // Create a new peer connection with the correct configuration
+            // this.#createRTCPeerConnection(from, star, version, false)
+            // peer = this.#connections[from]
         }
         peer.signal(signal);
     };