@leofcoin/chain 1.7.73 → 1.7.75

package/exports/browser/chain.js

@@ -5201,6 +5201,12 @@ class State extends Contract {
     get shouldSync() {
         if (this.#chainSyncing)
             return false;
+        // Check if we have any connected peers with the same version
+        const compatiblePeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
+        if (compatiblePeers.length === 0) {
+            debug$1('No compatible peers available for sync');
+            return false;
+        }
         if (!this.#chainSyncing ||
             this.#resolveErrored ||
             this.#syncState === 'errored' ||
@@ -5209,6 +5215,25 @@ class State extends Contract {
             return true;
         return false;
     }
+    async #waitForPeers(timeoutMs = 30000) {
+        return new Promise((resolve) => {
+            const checkPeers = () => {
+                const peers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
+                if (peers.length > 0) {
+                    resolve(true);
+                }
+            };
+            // Check immediately
+            checkPeers();
+            // Set up interval to check periodically
+            const interval = setInterval(checkPeers, 1000);
+            // Set timeout
+            setTimeout(() => {
+                clearInterval(interval);
+                resolve(false);
+            }, timeoutMs);
+        });
+    }
     async triggerSync() {
         const latest = await this.#getLatestBlock();
         return this.syncChain(latest);
@@ -5268,6 +5293,114 @@ class VersionControl extends State {
     }
 }
 
+/**
+ * Connection Monitor - Monitors peer connections and handles reconnection logic
+ */
+class ConnectionMonitor {
+    #isMonitoring = false;
+    #checkInterval = null;
+    #reconnectAttempts = 0;
+    #maxReconnectAttempts = 10;
+    #reconnectDelay = 5000;
+    #healthCheckInterval = 10000;
+    #version;
+    get isMonitoring() {
+        return this.#isMonitoring;
+    }
+    get connectedPeers() {
+        return Object.values(globalThis.peernet?.connections || {}).filter((peer) => peer.connected);
+    }
+    get compatiblePeers() {
+        return this.connectedPeers.filter((peer) => peer.version === this.#version);
+    }
+    constructor(version) {
+        this.#version = version;
+        console.log(`🔗 Connection Monitor initialized for version: ${this.#version}`);
+    }
+    start() {
+        if (this.#isMonitoring)
+            return;
+        this.#isMonitoring = true;
+        console.log('🔄 Starting connection monitor...');
+        this.#checkInterval = setInterval(() => {
+            this.#healthCheck();
+        }, this.#healthCheckInterval);
+        // Initial health check
+        this.#healthCheck();
+    }
+    stop() {
+        if (!this.#isMonitoring)
+            return;
+        this.#isMonitoring = false;
+        if (this.#checkInterval) {
+            clearInterval(this.#checkInterval);
+            this.#checkInterval = null;
+        }
+        console.log('⏹️ Connection monitor stopped');
+    }
+    async #healthCheck() {
+        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');
+            // Could attempt to find compatible peers or trigger version negotiation
+        }
+        else {
+            // Reset reconnect attempts on successful connection
+            this.#reconnectAttempts = 0;
+        }
+        // Publish connection status
+        globalThis.pubsub?.publish('connection-status', {
+            connected: connectedPeers.length,
+            compatible: compatiblePeers.length,
+            healthy: compatiblePeers.length > 0
+        });
+    }
+    async #attemptReconnection() {
+        if (this.#reconnectAttempts >= this.#maxReconnectAttempts) {
+            console.error('❌ Max reconnection attempts reached');
+            return;
+        }
+        this.#reconnectAttempts++;
+        console.log(`🔄 Attempting reconnection ${this.#reconnectAttempts}/${this.#maxReconnectAttempts}`);
+        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));
+        }
+        catch (error) {
+            console.error('❌ Reconnection failed:', error.message);
+            // Exponential backoff
+            this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 30000);
+        }
+    }
+    async waitForPeers(timeoutMs = 30000) {
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            const checkPeers = () => {
+                if (this.compatiblePeers.length > 0) {
+                    resolve(true);
+                    return;
+                }
+                if (Date.now() - startTime >= timeoutMs) {
+                    resolve(false);
+                    return;
+                }
+                setTimeout(checkPeers, 1000);
+            };
+            checkPeers();
+        });
+    }
+}
+
 const debug = globalThis.createDebugger('leofcoin/chain');
 // check if browser or local
 class Chain extends VersionControl {
@@ -5280,6 +5413,10 @@ class Chain extends VersionControl {
     #participants;
     #participating;
     #jail;
+    #peerConnectionRetries;
+    #maxPeerRetries;
+    #peerRetryDelay;
+    #connectionMonitor;
     constructor(config) {
         super(config);
         this.#slotTime = 10000;
@@ -5291,6 +5428,9 @@ class Chain extends VersionControl {
         this.#participants = [];
         this.#participating = false;
         this.#jail = [];
+        this.#peerConnectionRetries = new Map();
+        this.#maxPeerRetries = 5;
+        this.#peerRetryDelay = 5000;
         this.#addTransaction = async (message) => {
             const transaction = new TransactionMessage(message);
             const hash = await transaction.hash();
@@ -5365,6 +5505,7 @@ class Chain extends VersionControl {
         // this.node = await new Node()
         this.#participants = [];
         this.#participating = false;
+        this.#connectionMonitor = new ConnectionMonitor(this.version);
         const initialized = await globalThis.contractStore.has(addresses.contractFactory);
         if (!initialized)
             await this.#setup();
@@ -5372,8 +5513,11 @@ class Chain extends VersionControl {
         // this.#state = new State()
         // todo some functions rely on state
         await super.init();
+        // Start connection monitoring
+        this.#connectionMonitor.start();
         await globalThis.peernet.addRequestHandler('bw-request-message', () => {
-            return new BWMessage(globalThis.peernet.client.bw) || { up: 0, down: 0 };
+            const bw = globalThis.peernet.client?.bw || { up: 0, down: 0 };
+            return new BWMessage(bw);
         });
         // await globalThis.peernet.addRequestHandler('peerId', () => {
         //   let node =
@@ -5454,7 +5598,7 @@ class Chain extends VersionControl {
             }
         }
         if (this.wantList.length > 0) {
-            const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash)));
+            const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash, 'block')));
             for (let i = 0; i < promises.length; i++) {
                 const result = promises[i];
                 if (result.status === 'fulfilled')
@@ -5781,7 +5925,7 @@ class Chain extends VersionControl {
      * @returns
      */
     internalCall(sender, contract, method, parameters) {
-        globalThis.msg = this.#createMessage(sender, contract);
+        // globalThis.msg = this.#createMessage(sender, contract) // Debug line removed
         return this.machine.execute(contract, method, parameters);
     }
     /**
@@ -5792,11 +5936,11 @@ class Chain extends VersionControl {
      * @returns
      */
     call(contract, method, parameters) {
-        globalThis.msg = this.#createMessage(peernet.selectedAccount, contract);
+        // globalThis.msg = this.#createMessage(peernet.selectedAccount, contract) // Debug line removed
         return this.machine.execute(contract, method, parameters);
     }
     staticCall(contract, method, parameters) {
-        globalThis.msg = this.#createMessage(peernet.selectedAccount, contract);
+        // globalThis.msg = this.#createMessage(peernet.selectedAccount, contract) // Debug line removed
         return this.machine.get(contract, method, parameters);
     }
     mint(to, amount) {
@@ -5826,6 +5970,27 @@ class Chain extends VersionControl {
     lookup(name) {
         return this.call(addresses.nameService, 'lookup', [name]);
     }
+    #monitorPeerConnections() {
+        setInterval(() => {
+            const connectedPeers = Object.values(globalThis.peernet.connections).filter((peer) => peer.connected);
+            debug(`Connected peers: ${connectedPeers.length}`);
+            if (connectedPeers.length === 0) {
+                debug('No peers connected, attempting to reconnect...');
+                this.#attemptPeerReconnection();
+            }
+        }, 10000); // Check every 10 seconds
+    }
+    async #attemptPeerReconnection() {
+        try {
+            // Try to reconnect to star servers
+            if (globalThis.peernet && globalThis.peernet.start) {
+                await globalThis.peernet.start();
+            }
+        }
+        catch (error) {
+            console.warn('Failed to reconnect to peers:', error.message);
+        }
+    }
 }
 
 export { Chain as default };

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

@@ -1,4 +1,4 @@
-import { L as LittlePubSub } from './node-browser-BvxzAdLe.js';
+import { L as LittlePubSub } from './node-browser-DMmrhyQS.js';
 import './identity--VAIVSMm-DTWL357I.js';
 import './index-DUfUgiQY.js';
 

package/exports/browser/{messages-CW17jRdc-c9cSXiiQ.js → messages-CW17jRdc-Dtrj-vba.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './node-browser-BvxzAdLe.js';
+import { F as FormatInterface } from './node-browser-DMmrhyQS.js';
 import './identity--VAIVSMm-DTWL357I.js';
 import './index-DUfUgiQY.js';
 

package/exports/browser/{node-browser-BvxzAdLe.js → node-browser-DMmrhyQS.js}

@@ -8495,7 +8495,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-CW17jRdc-c9cSXiiQ.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-CW17jRdc-Dtrj-vba.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8589,7 +8589,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-DD7vhDK_-UAymLS2i.js');
+        const importee = await import('./client-DD7vhDK_-BdNAdRzV.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -9078,7 +9078,7 @@ globalThis.Peernet = Peernet;
 var networks = {
     leofcoin: {
         peach: {
-            stars: ['wss://star.leofcoin.org'] // todo webrtc and bittorent stars
+            stars: ['wss://star-testnet.leofcoin.org', 'wss://star.leofcoin.org'] // Separate testnet stars
         }
     }
 };

package/exports/browser/node-browser.js

@@ -1,3 +1,3 @@
-export { N as default } from './node-browser-BvxzAdLe.js';
+export { N as default } from './node-browser-DMmrhyQS.js';
 import './identity--VAIVSMm-DTWL357I.js';
 import './index-DUfUgiQY.js';

package/exports/chain.js

@@ -1347,6 +1347,12 @@ class State extends Contract {
     get shouldSync() {
         if (this.#chainSyncing)
             return false;
+        // Check if we have any connected peers with the same version
+        const compatiblePeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
+        if (compatiblePeers.length === 0) {
+            debug$1('No compatible peers available for sync');
+            return false;
+        }
         if (!this.#chainSyncing ||
             this.#resolveErrored ||
             this.#syncState === 'errored' ||
@@ -1355,6 +1361,25 @@ class State extends Contract {
             return true;
         return false;
     }
+    async #waitForPeers(timeoutMs = 30000) {
+        return new Promise((resolve) => {
+            const checkPeers = () => {
+                const peers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
+                if (peers.length > 0) {
+                    resolve(true);
+                }
+            };
+            // Check immediately
+            checkPeers();
+            // Set up interval to check periodically
+            const interval = setInterval(checkPeers, 1000);
+            // Set timeout
+            setTimeout(() => {
+                clearInterval(interval);
+                resolve(false);
+            }, timeoutMs);
+        });
+    }
     async triggerSync() {
         const latest = await this.#getLatestBlock();
         return this.syncChain(latest);
@@ -1414,6 +1439,114 @@ class VersionControl extends State {
     }
 }
 
+/**
+ * Connection Monitor - Monitors peer connections and handles reconnection logic
+ */
+class ConnectionMonitor {
+    #isMonitoring = false;
+    #checkInterval = null;
+    #reconnectAttempts = 0;
+    #maxReconnectAttempts = 10;
+    #reconnectDelay = 5000;
+    #healthCheckInterval = 10000;
+    #version;
+    get isMonitoring() {
+        return this.#isMonitoring;
+    }
+    get connectedPeers() {
+        return Object.values(globalThis.peernet?.connections || {}).filter((peer) => peer.connected);
+    }
+    get compatiblePeers() {
+        return this.connectedPeers.filter((peer) => peer.version === this.#version);
+    }
+    constructor(version) {
+        this.#version = version;
+        console.log(`🔗 Connection Monitor initialized for version: ${this.#version}`);
+    }
+    start() {
+        if (this.#isMonitoring)
+            return;
+        this.#isMonitoring = true;
+        console.log('🔄 Starting connection monitor...');
+        this.#checkInterval = setInterval(() => {
+            this.#healthCheck();
+        }, this.#healthCheckInterval);
+        // Initial health check
+        this.#healthCheck();
+    }
+    stop() {
+        if (!this.#isMonitoring)
+            return;
+        this.#isMonitoring = false;
+        if (this.#checkInterval) {
+            clearInterval(this.#checkInterval);
+            this.#checkInterval = null;
+        }
+        console.log('⏹️ Connection monitor stopped');
+    }
+    async #healthCheck() {
+        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');
+            // Could attempt to find compatible peers or trigger version negotiation
+        }
+        else {
+            // Reset reconnect attempts on successful connection
+            this.#reconnectAttempts = 0;
+        }
+        // Publish connection status
+        globalThis.pubsub?.publish('connection-status', {
+            connected: connectedPeers.length,
+            compatible: compatiblePeers.length,
+            healthy: compatiblePeers.length > 0
+        });
+    }
+    async #attemptReconnection() {
+        if (this.#reconnectAttempts >= this.#maxReconnectAttempts) {
+            console.error('❌ Max reconnection attempts reached');
+            return;
+        }
+        this.#reconnectAttempts++;
+        console.log(`🔄 Attempting reconnection ${this.#reconnectAttempts}/${this.#maxReconnectAttempts}`);
+        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));
+        }
+        catch (error) {
+            console.error('❌ Reconnection failed:', error.message);
+            // Exponential backoff
+            this.#reconnectDelay = Math.min(this.#reconnectDelay * 1.5, 30000);
+        }
+    }
+    async waitForPeers(timeoutMs = 30000) {
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            const checkPeers = () => {
+                if (this.compatiblePeers.length > 0) {
+                    resolve(true);
+                    return;
+                }
+                if (Date.now() - startTime >= timeoutMs) {
+                    resolve(false);
+                    return;
+                }
+                setTimeout(checkPeers, 1000);
+            };
+            checkPeers();
+        });
+    }
+}
+
 const debug = globalThis.createDebugger('leofcoin/chain');
 // check if browser or local
 class Chain extends VersionControl {
@@ -1426,6 +1559,10 @@ class Chain extends VersionControl {
     #participants;
     #participating;
     #jail;
+    #peerConnectionRetries;
+    #maxPeerRetries;
+    #peerRetryDelay;
+    #connectionMonitor;
     constructor(config) {
         super(config);
         this.#slotTime = 10000;
@@ -1437,6 +1574,9 @@ class Chain extends VersionControl {
         this.#participants = [];
         this.#participating = false;
         this.#jail = [];
+        this.#peerConnectionRetries = new Map();
+        this.#maxPeerRetries = 5;
+        this.#peerRetryDelay = 5000;
         this.#addTransaction = async (message) => {
             const transaction = new TransactionMessage(message);
             const hash = await transaction.hash();
@@ -1511,6 +1651,7 @@ class Chain extends VersionControl {
         // this.node = await new Node()
         this.#participants = [];
         this.#participating = false;
+        this.#connectionMonitor = new ConnectionMonitor(this.version);
         const initialized = await globalThis.contractStore.has(addresses.contractFactory);
         if (!initialized)
             await this.#setup();
@@ -1518,8 +1659,11 @@ class Chain extends VersionControl {
         // this.#state = new State()
         // todo some functions rely on state
         await super.init();
+        // Start connection monitoring
+        this.#connectionMonitor.start();
         await globalThis.peernet.addRequestHandler('bw-request-message', () => {
-            return new BWMessage(globalThis.peernet.client.bw) || { up: 0, down: 0 };
+            const bw = globalThis.peernet.client?.bw || { up: 0, down: 0 };
+            return new BWMessage(bw);
         });
         // await globalThis.peernet.addRequestHandler('peerId', () => {
         //   let node =
@@ -1600,7 +1744,7 @@ class Chain extends VersionControl {
             }
         }
         if (this.wantList.length > 0) {
-            const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash)));
+            const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash, 'block')));
             for (let i = 0; i < promises.length; i++) {
                 const result = promises[i];
                 if (result.status === 'fulfilled')
@@ -1927,7 +2071,7 @@ class Chain extends VersionControl {
      * @returns
      */
     internalCall(sender, contract, method, parameters) {
-        globalThis.msg = this.#createMessage(sender, contract);
+        // globalThis.msg = this.#createMessage(sender, contract) // Debug line removed
         return this.machine.execute(contract, method, parameters);
     }
     /**
@@ -1938,11 +2082,11 @@ class Chain extends VersionControl {
      * @returns
      */
     call(contract, method, parameters) {
-        globalThis.msg = this.#createMessage(peernet.selectedAccount, contract);
+        // globalThis.msg = this.#createMessage(peernet.selectedAccount, contract) // Debug line removed
         return this.machine.execute(contract, method, parameters);
     }
     staticCall(contract, method, parameters) {
-        globalThis.msg = this.#createMessage(peernet.selectedAccount, contract);
+        // globalThis.msg = this.#createMessage(peernet.selectedAccount, contract) // Debug line removed
         return this.machine.get(contract, method, parameters);
     }
     mint(to, amount) {
@@ -1972,6 +2116,27 @@ class Chain extends VersionControl {
     lookup(name) {
         return this.call(addresses.nameService, 'lookup', [name]);
     }
+    #monitorPeerConnections() {
+        setInterval(() => {
+            const connectedPeers = Object.values(globalThis.peernet.connections).filter((peer) => peer.connected);
+            debug(`Connected peers: ${connectedPeers.length}`);
+            if (connectedPeers.length === 0) {
+                debug('No peers connected, attempting to reconnect...');
+                this.#attemptPeerReconnection();
+            }
+        }, 10000); // Check every 10 seconds
+    }
+    async #attemptPeerReconnection() {
+        try {
+            // Try to reconnect to star servers
+            if (globalThis.peernet && globalThis.peernet.start) {
+                await globalThis.peernet.start();
+            }
+        }
+        catch (error) {
+            console.warn('Failed to reconnect to peers:', error.message);
+        }
+    }
 }
 
 export { Chain as default };

package/exports/connection-monitor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Connection Monitor - Monitors peer connections and handles reconnection logic
+ */
+export default class ConnectionMonitor {
+    #private;
+    get isMonitoring(): boolean;
+    get connectedPeers(): import("@netpeer/swarm/peer").default[];
+    get compatiblePeers(): import("@netpeer/swarm/peer").default[];
+    constructor(version: string);
+    start(): void;
+    stop(): void;
+    waitForPeers(timeoutMs?: number): Promise<boolean>;
+}

package/exports/sync-controller.d.ts

@@ -7,7 +7,8 @@ export default class SyncController {
     get fullyLoaded(): boolean;
     constructor();
     /**
-     * Resolves/rejects a promise or rejects on timeout
+     * Resolves/rejects a promise or rejects on timeout with retry logic
      */
-    resolve(): void;
+    resolve(operation: () => Promise<any>, timeoutMs?: number): Promise<any>;
+    stop(): void;
 }

package/package.json

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