@dignetwork/dig-sdk 0.0.1-alpha.135 → 0.0.1-alpha.138

package/dist/blockchain/FullNodePeer.d.ts

@@ -11,7 +11,8 @@ export declare class FullNodePeer {
     private static prioritizedPeers;
     private static peerInfos;
     private static peerIPCache;
-    private static limiter;
+    private static availablePeers;
+    private static currentPeerIndex;
     private constructor();
     /**
      * Retrieves the singleton instance of FullNodePeer.
@@ -66,11 +67,10 @@ export declare class FullNodePeer {
      */
     private static initializePeerWeights;
     /**
-     * Selects a peer based on weighted random selection.
-     * Prioritized peers have higher weights.
+     * Selects the next peer based on round-robin selection.
      * @returns {string} The selected peer IP.
      */
-    private static selectPeerByWeight;
+    private static getNextPeerIP;
     /**
      * Retrieves all reachable peer IPs, excluding those in cooldown.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
@@ -82,12 +82,12 @@ export declare class FullNodePeer {
      */
     private static setupPeers;
     /**
-     * Connects to the best available peer based on weighted selection and reliability.
+     * Connects to the best available peer based on round-robin selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
     private static getBestPeer;
     /**
-     * Creates a proxy for the peer to handle errors, implement retries, and enforce throttling.
+     * Creates a proxy for the peer to handle errors, implement retries, and enforce per-peer throttling.
      * @param {Peer} peer - The Peer instance.
      * @param {string} peerIP - The IP address of the peer.
      * @param {number} [retryCount=0] - The current retry attempt.

package/dist/blockchain/FullNodePeer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AA6CzD;;GAEG;AACH,qBAAa,YAAY;IA6BH,OAAO,CAAC,IAAI;IA3BhC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAGpD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAG3E,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuD;IAGnF,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkC;IAG5D,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAgB;IAG/C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAoC;IAG5D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAoD;IAG9E,OAAO,CAAC,MAAM,CAAC,OAAO,CAGnB;IAGH,OAAO;IAEP;;;OAGG;WACW,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC;;;;OAIG;WACiB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuB9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IASjC;;;;OAIG;mBACkB,eAAe;IAyFpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAgBpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAwBjC;;;OAGG;mBACkB,UAAU;IAK/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;OAGG;mBACkB,WAAW;IA2EhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAsF9B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA4BtC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;;OAIG;WACiB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;IAkCnB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK;CAGrB"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAqCzD;;GAEG;AACH,qBAAa,YAAY;IA6BH,OAAO,CAAC,IAAI;IA3BhC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAGpD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAG3E,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuD;IAGnF,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkC;IAG5D,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAgB;IAG/C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAoC;IAG5D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAoD;IAG9E,OAAO,CAAC,MAAM,CAAC,cAAc,CAAgB;IAG7C,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAa;IAG5C,OAAO;IAEP;;;OAGG;WACW,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC;;;;OAIG;WACiB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuB9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IASjC;;;;OAIG;mBACkB,eAAe;IAyFpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAgBpC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;OAGG;mBACkB,UAAU;IAK/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;OAGG;mBACkB,WAAW;IAiIhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAkG9B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAwCtC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;;OAIG;WACiB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;IAkCnB;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,KAAK;CAGrB"}

package/dist/blockchain/FullNodePeer.js

@@ -30,7 +30,7 @@ const CACHE_DURATION = 30000; // in milliseconds
 const COOLDOWN_DURATION = 300000; // 5 minutes in milliseconds
 const MAX_PEERS_TO_FETCH = 5; // Maximum number of peers to fetch from DNS
 const MAX_RETRIES = 3; // Maximum number of retry attempts
-const MAX_REQUESTS_PER_MINUTE = 100; // Throttle limit
+const MAX_REQUESTS_PER_MINUTE = 100; // Per-peer rate limit
 /**
  * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
  */
@@ -130,7 +130,7 @@ class FullNodePeer {
         const priorityIps = [];
         // Define prioritized peers
         FullNodePeer.prioritizedPeers = [
-            ...DNS_HOSTS, // Assuming CHIA_NODES_HOST is included in DNS_HOSTS
+            CHIA_NODES_HOST,
             LOCALHOST,
         ];
         // Add trustedNodeIp if available
@@ -226,28 +226,16 @@ class FullNodePeer {
         }
     }
     /**
-     * Selects a peer based on weighted random selection.
-     * Prioritized peers have higher weights.
+     * Selects the next peer based on round-robin selection.
      * @returns {string} The selected peer IP.
      */
-    static selectPeerByWeight() {
-        const peers = Array.from(FullNodePeer.peerWeights.entries())
-            .filter(([ip, _]) => !FullNodePeer.cooldownCache.has(ip))
-            .map(([ip, weight]) => ({ ip, weight }));
-        const totalWeight = peers.reduce((sum, peer) => sum + peer.weight, 0);
-        if (totalWeight === 0) {
-            throw new Error("All peers are in cooldown.");
+    static getNextPeerIP() {
+        if (FullNodePeer.availablePeers.length === 0) {
+            throw new Error("No available peers to select.");
         }
-        const random = Math.random() * totalWeight;
-        let cumulative = 0;
-        for (const peer of peers) {
-            cumulative += peer.weight;
-            if (random < cumulative) {
-                return peer.ip;
-            }
-        }
-        // Fallback
-        return peers[peers.length - 1].ip;
+        const peerIP = FullNodePeer.availablePeers[FullNodePeer.currentPeerIndex];
+        FullNodePeer.currentPeerIndex = (FullNodePeer.currentPeerIndex + 1) % FullNodePeer.availablePeers.length;
+        return peerIP;
     }
     /**
      * Retrieves all reachable peer IPs, excluding those in cooldown.
@@ -265,7 +253,7 @@ class FullNodePeer {
         FullNodePeer.initializePeerWeights(peerIPs);
     }
     /**
-     * Connects to the best available peer based on weighted selection and reliability.
+     * Connects to the best available peer based on round-robin selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
     static async getBestPeer() {
@@ -280,56 +268,105 @@ class FullNodePeer {
         const peerIPs = await FullNodePeer.getPeerIPs();
         // Setup peer weights with prioritization
         FullNodePeer.setupPeers(peerIPs);
-        // Weighted random selection
-        let selectedPeerIP;
-        try {
-            selectedPeerIP = FullNodePeer.selectPeerByWeight();
-        }
-        catch (error) {
-            throw new Error(`Failed to select a peer: ${error.message}`);
-        }
-        // Attempt to create a peer connection
-        const sslFolder = path_1.default.resolve(os_1.default.homedir(), ".dig", "ssl");
-        const certFile = path_1.default.join(sslFolder, "public_dig.crt");
-        const keyFile = path_1.default.join(sslFolder, "public_dig.key");
-        if (!fs_1.default.existsSync(sslFolder)) {
-            fs_1.default.mkdirSync(sslFolder, { recursive: true });
-        }
-        const tls = new datalayer_driver_1.Tls(certFile, keyFile);
-        let peer;
-        try {
-            peer = await datalayer_driver_1.Peer.new(`${selectedPeerIP}:${FULLNODE_PORT}`, false, tls);
-        }
-        catch (error) {
-            console.error(`Failed to create peer for IP ${selectedPeerIP}: ${error.message}`);
-            // Add to cooldown
-            FullNodePeer.cooldownCache.set(selectedPeerIP, true);
-            // Decrease weight or remove peer
-            const currentWeight = FullNodePeer.peerWeights.get(selectedPeerIP) || 1;
-            if (currentWeight > 1) {
-                FullNodePeer.peerWeights.set(selectedPeerIP, currentWeight - 1);
+        // Initialize or update peerInfos and availablePeers
+        for (const ip of peerIPs) {
+            if (!FullNodePeer.peerInfos.has(ip)) {
+                // Create a new Bottleneck limiter for the peer
+                const limiter = new bottleneck_1.default({
+                    maxConcurrent: 1, // One request at a time per peer
+                    minTime: 60000 / MAX_REQUESTS_PER_MINUTE, // 600 ms between requests for 100 requests/min
+                });
+                // Attempt to create a peer connection
+                const sslFolder = path_1.default.resolve(os_1.default.homedir(), ".dig", "ssl");
+                const certFile = path_1.default.join(sslFolder, "public_dig.crt");
+                const keyFile = path_1.default.join(sslFolder, "public_dig.key");
+                if (!fs_1.default.existsSync(sslFolder)) {
+                    fs_1.default.mkdirSync(sslFolder, { recursive: true });
+                }
+                const tls = new datalayer_driver_1.Tls(certFile, keyFile);
+                let peer;
+                try {
+                    peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, tls);
+                }
+                catch (error) {
+                    console.error(`Failed to create peer for IP ${ip}: ${error.message}`);
+                    // Add to cooldown
+                    FullNodePeer.cooldownCache.set(ip, true);
+                    // Decrease weight or remove peer
+                    const currentWeight = FullNodePeer.peerWeights.get(ip) || 1;
+                    if (currentWeight > 1) {
+                        FullNodePeer.peerWeights.set(ip, currentWeight - 1);
+                    }
+                    else {
+                        FullNodePeer.peerWeights.delete(ip);
+                    }
+                    continue; // Skip adding this peer
+                }
+                // Wrap the peer with proxy to handle errors and retries
+                const proxiedPeer = FullNodePeer.createPeerProxy(peer, ip);
+                // Store PeerInfo
+                FullNodePeer.peerInfos.set(ip, {
+                    peer: proxiedPeer,
+                    weight: FullNodePeer.peerWeights.get(ip) || 1,
+                    address: ip,
+                    isConnected: true, // Mark as connected
+                    limiter, // Assign the limiter
+                });
+                // Add to availablePeers
+                FullNodePeer.availablePeers.push(ip);
             }
             else {
-                FullNodePeer.peerWeights.delete(selectedPeerIP);
+                const peerInfo = FullNodePeer.peerInfos.get(ip);
+                if (!peerInfo.isConnected) {
+                    // Peer is back from cooldown, re-establish connection
+                    const sslFolder = path_1.default.resolve(os_1.default.homedir(), ".dig", "ssl");
+                    const certFile = path_1.default.join(sslFolder, "public_dig.crt");
+                    const keyFile = path_1.default.join(sslFolder, "public_dig.key");
+                    if (!fs_1.default.existsSync(sslFolder)) {
+                        fs_1.default.mkdirSync(sslFolder, { recursive: true });
+                    }
+                    const tls = new datalayer_driver_1.Tls(certFile, keyFile);
+                    let peer;
+                    try {
+                        peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, tls);
+                    }
+                    catch (error) {
+                        console.error(`Failed to reconnect peer for IP ${ip}: ${error.message}`);
+                        // Re-add to cooldown
+                        FullNodePeer.cooldownCache.set(ip, true);
+                        // Decrease weight or remove peer
+                        const currentWeight = FullNodePeer.peerWeights.get(ip) || 1;
+                        if (currentWeight > 1) {
+                            FullNodePeer.peerWeights.set(ip, currentWeight - 1);
+                        }
+                        else {
+                            FullNodePeer.peerWeights.delete(ip);
+                        }
+                        continue; // Skip adding this peer
+                    }
+                    // Wrap the peer with proxy to handle errors and retries
+                    const proxiedPeer = FullNodePeer.createPeerProxy(peer, ip);
+                    // Update PeerInfo
+                    peerInfo.peer = proxiedPeer;
+                    peerInfo.isConnected = true;
+                    // Add back to availablePeers
+                    FullNodePeer.availablePeers.push(ip);
+                }
             }
-            throw new Error(`Unable to connect to peer ${selectedPeerIP}`);
         }
-        // Wrap the peer with proxy to handle errors and retries
-        const proxiedPeer = FullNodePeer.createPeerProxy(peer, selectedPeerIP);
-        // Store PeerInfo
-        FullNodePeer.peerInfos.set(selectedPeerIP, {
-            peer: proxiedPeer,
-            weight: FullNodePeer.peerWeights.get(selectedPeerIP) || 1,
-            address: selectedPeerIP,
-            isConnected: true, // Mark as connected
-        });
+        if (FullNodePeer.availablePeers.length === 0) {
+            throw new Error("No available peers to connect.");
+        }
+        // Select the next peer in round-robin
+        const selectedPeerIP = FullNodePeer.getNextPeerIP();
+        const selectedPeerInfo = FullNodePeer.peerInfos.get(selectedPeerIP);
         // Cache the peer
-        FullNodePeer.cachedPeer = { peer: proxiedPeer, timestamp: now };
+        FullNodePeer.cachedPeer = { peer: selectedPeerInfo.peer, timestamp: now };
         console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
-        return proxiedPeer;
+        return selectedPeerInfo.peer;
     }
     /**
-     * Creates a proxy for the peer to handle errors, implement retries, and enforce throttling.
+     * Creates a proxy for the peer to handle errors, implement retries, and enforce per-peer throttling.
      * @param {Peer} peer - The Peer instance.
      * @param {string} peerIP - The IP address of the peer.
      * @param {number} [retryCount=0] - The current retry attempt.
@@ -354,29 +391,40 @@ class FullNodePeer {
                 const originalMethod = target[prop];
                 if (typeof originalMethod === "function") {
                     return (...args) => {
-                        // Wrap the method call with Bottleneck's scheduling
-                        return FullNodePeer.limiter.schedule(async () => {
-                            const peerInfo = FullNodePeer.peerInfos.get(peerIP);
+                        // Select the next peer in round-robin
+                        let selectedPeerIP;
+                        try {
+                            selectedPeerIP = FullNodePeer.getNextPeerIP();
+                        }
+                        catch (error) {
+                            return Promise.reject(error);
+                        }
+                        const selectedPeerInfo = FullNodePeer.peerInfos.get(selectedPeerIP);
+                        // Schedule the method call via the selected peer's limiter
+                        return selectedPeerInfo.limiter.schedule(async () => {
+                            const peerInfo = FullNodePeer.peerInfos.get(selectedPeerIP);
                             if (!peerInfo || !peerInfo.isConnected) {
-                                throw new Error(`Cannot perform operation: Peer ${peerIP} is disconnected.`);
+                                throw new Error(`Cannot perform operation: Peer ${selectedPeerIP} is disconnected.`);
                             }
                             try {
-                                const result = await originalMethod.apply(target, args);
+                                // Bind the original method to the peer instance to preserve 'this'
+                                const boundMethod = originalMethod.bind(peerInfo.peer);
+                                const result = await boundMethod(...args);
                                 // On successful operation, increase the weight slightly
-                                const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
-                                FullNodePeer.peerWeights.set(peerIP, currentWeight + 0.1); // Increment weight
+                                const currentWeight = FullNodePeer.peerWeights.get(selectedPeerIP) || 1;
+                                FullNodePeer.peerWeights.set(selectedPeerIP, currentWeight + 0.1); // Increment weight
                                 return result;
                             }
                             catch (error) {
-                                console.error(`Peer ${peerIP} encountered an error: ${error.message}`);
+                                console.error(`Peer ${selectedPeerIP} encountered an error: ${error.message}`);
                                 // Check if the error is related to WebSocket or Operation timed out
                                 if (error.message.includes("WebSocket") ||
                                     error.message.includes("Operation timed out")) {
                                     // Handle the disconnection and mark the peer accordingly
-                                    FullNodePeer.handlePeerDisconnection(peerIP);
+                                    FullNodePeer.handlePeerDisconnection(selectedPeerIP);
                                     // If maximum retries reached, throw the error
                                     if (retryCount >= MAX_RETRIES) {
-                                        console.error(`Max retries reached for method ${String(prop)} on peer ${peerIP}.`);
+                                        console.error(`Max retries reached for method ${String(prop)} on peer ${selectedPeerIP}.`);
                                         throw error;
                                     }
                                     // Attempt to select a new peer and retry the method
@@ -431,11 +479,21 @@ class FullNodePeer {
             peerInfo.isConnected = false;
             FullNodePeer.peerInfos.set(peerIP, peerInfo);
         }
+        // Remove from availablePeers if present
+        const index = FullNodePeer.availablePeers.indexOf(peerIP);
+        if (index !== -1) {
+            FullNodePeer.availablePeers.splice(index, 1);
+            // Adjust currentPeerIndex if necessary
+            if (FullNodePeer.currentPeerIndex >= FullNodePeer.availablePeers.length) {
+                FullNodePeer.currentPeerIndex = 0;
+            }
+        }
         // If the disconnected peer was the cached peer, invalidate the cache
         if (FullNodePeer.cachedPeer &&
             FullNodePeer.extractPeerIP(FullNodePeer.cachedPeer.peer) === peerIP) {
             FullNodePeer.cachedPeer = null;
         }
+        console.warn(`Peer ${peerIP} has been marked as disconnected and is in cooldown.`);
     }
     /**
      * Extracts the IP address from a Peer instance.
@@ -506,8 +564,7 @@ FullNodePeer.prioritizedPeers = [];
 FullNodePeer.peerInfos = new Map();
 // Cache for fetched peer IPs
 FullNodePeer.peerIPCache = new node_cache_1.default({ stdTTL: CACHE_DURATION / 1000 });
-// Bottleneck instance for global throttling
-FullNodePeer.limiter = new bottleneck_1.default({
-    maxConcurrent: 1, // Ensures only one request is processed at a time
-    minTime: 60000 / MAX_REQUESTS_PER_MINUTE, // Calculated delay between requests
-});
+// List of available peers for round-robin
+FullNodePeer.availablePeers = [];
+// Current index for round-robin selection
+FullNodePeer.currentPeerIndex = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/dig-sdk",
-  "version": "0.0.1-alpha.135",
+  "version": "0.0.1-alpha.138",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",