@dignetwork/dig-sdk 0.0.1-alpha.134 → 0.0.1-alpha.136

package/dist/DigNetwork/PropagationServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PropagationServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/PropagationServer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAkBrC,qBAAa,iBAAiB;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;gBAErC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAY9C;;OAEG;IACG,gBAAgB;IAOtB;;OAEG;IACH,gBAAgB;IAQhB;;;OAGG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BpD;;;OAGG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA8EjD;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM;IAyB3D;;OAEG;IACG,gBAAgB,CACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;IA4C7D;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM;IAyDzC;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IA2BlD;;;OAGG;IACG,UAAU,CACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,OAAe;IAsH7B;;OAEG;IACG,mBAAmB;IAkCzB;;OAEG;WACU,WAAW,CACtB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;IA0DnB;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkFlD;;OAEG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA4B7C;;;OAGG;IACG,YAAY,CAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM;IA0GjB;;OAEG;WACU,aAAa,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;CA2FpB"}
+{"version":3,"file":"PropagationServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/PropagationServer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAkBrC,qBAAa,iBAAiB;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;gBAErC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAY9C;;OAEG;IACG,gBAAgB;IAOtB;;OAEG;IACH,gBAAgB;IAQhB;;;OAGG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BpD;;;OAGG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmCjD;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM;IAyB3D;;OAEG;IACG,gBAAgB,CACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;IA4C7D;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM;IAyDzC;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IA2BlD;;;OAGG;IACG,UAAU,CACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,OAAe;IAsH7B;;OAEG;IACG,mBAAmB;IAkCzB;;OAEG;WACU,WAAW,CACtB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;IA0DnB;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkFlD;;OAEG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA4B7C;;;OAGG;IACG,YAAY,CAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM;IA0GjB;;OAEG;WACU,aAAa,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;CA2FpB"}

package/dist/DigNetwork/PropagationServer.js

@@ -128,10 +128,6 @@ class PropagationServer {
                 headers: {
                     "Content-Type": "application/json",
                 },
-                validateStatus: (status) => {
-                    // Accept all status codes to handle them manually
-                    return true;
-                },
             };
             // Data to send in the request (storeId and rootHash)
             const data = {
@@ -141,31 +137,10 @@ class PropagationServer {
             };
             try {
                 const response = await axios_1.default.post(url, data, config);
-                if (response.status === 200) {
-                    console.log((0, colorette_1.green)(`✔ Peer was up to date: ${this.ipAddress}`));
-                    return;
-                }
-                else if (response.status === 400 &&
-                    response.data?.error?.includes("does not exist")) {
-                    console.log((0, colorette_1.yellow)(`⚠ Peer ${this.ipAddress} does not have store ${this.storeId}. Notifying for update.`));
-                    // You can implement additional logic here if needed, such as retrying or logging
-                    return;
-                }
-                else {
-                    console.error((0, colorette_1.red)(`✖ Unexpected response from peer ${this.ipAddress}: ${response.status} ${response.statusText}`));
-                    throw new Error(`Unexpected response: ${response.status} ${response.statusText}`);
-                }
+                console.log((0, colorette_1.green)(`✔ Successfully pinged peer: ${this.ipAddress}`));
+                return response.data;
             }
             catch (error) {
-                if (error.response) {
-                    // Server responded with a status other than 2xx
-                    if (error.response.status === 400 &&
-                        error.response.data?.error?.includes("does not exist")) {
-                        console.log((0, colorette_1.yellow)(`⚠ Peer ${this.ipAddress} does not have store ${this.storeId}. Notifying for update.`));
-                        // You can implement additional logic here if needed
-                        return;
-                    }
-                }
                 console.error((0, colorette_1.red)(`✖ Failed to ping peer: ${this.ipAddress}`));
                 console.error((0, colorette_1.red)(error.message));
                 throw error;

package/dist/blockchain/DataStore.js

@@ -197,9 +197,9 @@ class DataStore {
     }
     static getAllStores() {
         const storeFolders = fs_1.default.readdirSync(config_1.STORE_PATH);
-        const storIds = storeFolders.filter((folder) => /^[a-f0-9]{64}$/.test(folder) &&
+        const storeIds = storeFolders.filter((folder) => /^[a-f0-9]{64}$/.test(folder) &&
             fs_1.default.lstatSync(path_1.default.join(config_1.STORE_PATH, folder)).isDirectory());
-        return storIds.map((storeId) => DataStore.from(storeId));
+        return storeIds.map((storeId) => DataStore.from(storeId));
     }
     /**
      * Fetches the latest coin information using the StoreMonitorRegistry.

package/dist/blockchain/FullNodePeer.d.ts

@@ -11,6 +11,8 @@ export declare class FullNodePeer {
     private static prioritizedPeers;
     private static peerInfos;
     private static peerIPCache;
+    private static availablePeers;
+    private static currentPeerIndex;
     private constructor();
     /**
      * Retrieves the singleton instance of FullNodePeer.
@@ -65,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.
@@ -81,18 +82,23 @@ 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 and implement retries.
+     * 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.
      * @returns {Peer} The proxied Peer instance.
      */
     private static createPeerProxy;
+    /**
+     * Handles peer disconnection by marking it in cooldown and updating internal states.
+     * @param {string} peerIP - The IP address of the disconnected peer.
+     */
+    private static handlePeerDisconnection;
     /**
      * Extracts the IP address from a Peer instance.
      * @param {Peer} peer - The Peer instance.
@@ -100,10 +106,16 @@ export declare class FullNodePeer {
      */
     private static extractPeerIP;
     /**
-   * Waits for a coin to be confirmed (spent) on the blockchain.
-   * @param {Buffer} parentCoinInfo - The parent coin information.
-   * @returns {Promise<boolean>} Whether the coin was confirmed.
-   */
+     * Waits for a coin to be confirmed (spent) on the blockchain.
+     * @param {Buffer} parentCoinInfo - The parent coin information.
+     * @returns {Promise<boolean>} Whether the coin was confirmed.
+     */
     static waitForConfirmation(parentCoinInfo: Buffer): Promise<boolean>;
+    /**
+     * Delays execution for a specified amount of time.
+     * @param {number} ms - Milliseconds to delay.
+     * @returns {Promise<void>} A promise that resolves after the delay.
+     */
+    private static delay;
 }
 //# sourceMappingURL=FullNodePeer.d.ts.map

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;AAiCzD;;GAEG;AACH,qBAAa,YAAY;IAuBH,OAAO,CAAC,IAAI;IArBhC,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;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;IAyEhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuE9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS1B;;;;KAIC;WACmB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAyBtB"}
+{"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;IAgG9B;;;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

@@ -14,6 +14,7 @@ const nanospinner_1 = require("nanospinner");
 const config_1 = require("../utils/config");
 const Environment_1 = require("../utils/Environment");
 const node_cache_1 = __importDefault(require("node-cache"));
+const bottleneck_1 = __importDefault(require("bottleneck"));
 // Constants
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
@@ -26,9 +27,10 @@ const DNS_HOSTS = [
 ];
 const CONNECTION_TIMEOUT = 2000; // in milliseconds
 const CACHE_DURATION = 30000; // in milliseconds
-const COOLDOWN_DURATION = 60000; // 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; // Per-peer rate limit
 /**
  * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
  */
@@ -224,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.
@@ -263,137 +253,246 @@ 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() {
         const now = Date.now();
-        // Refresh cachedPeer if expired
+        // Refresh cachedPeer if expired or disconnected
         if (FullNodePeer.cachedPeer &&
-            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
+            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION &&
+            FullNodePeer.peerInfos.get(FullNodePeer.extractPeerIP(FullNodePeer.cachedPeer.peer) || "")?.isConnected) {
             return FullNodePeer.cachedPeer.peer;
         }
         // Fetch peer IPs
         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,
-        });
+        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 and implement retries.
+     * 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.
      * @returns {Peer} The proxied Peer instance.
      */
     static createPeerProxy(peer, peerIP, retryCount = 0) {
+        // Listen for close events if the Peer class supports it
+        // This assumes that the Peer class emits a 'close' event when the connection is closed
+        // Adjust accordingly based on the actual Peer implementation
+        if (typeof peer.on === "function") {
+            peer.on("close", () => {
+                console.warn(`Peer ${peerIP} connection closed.`);
+                FullNodePeer.handlePeerDisconnection(peerIP);
+            });
+            peer.on("error", (error) => {
+                console.error(`Peer ${peerIP} encountered an error: ${error.message}`);
+                FullNodePeer.handlePeerDisconnection(peerIP);
+            });
+        }
         return new Proxy(peer, {
             get: (target, prop) => {
                 const originalMethod = target[prop];
                 if (typeof originalMethod === "function") {
-                    return async (...args) => {
+                    return (...args) => {
+                        // Select the next peer in round-robin
+                        let selectedPeerIP;
                         try {
-                            const result = await originalMethod.apply(target, args);
-                            // On successful operation, increase the weight slightly
-                            const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
-                            FullNodePeer.peerWeights.set(peerIP, currentWeight + 0.1); // Increment weight
-                            return result;
+                            selectedPeerIP = FullNodePeer.getNextPeerIP();
                         }
                         catch (error) {
-                            console.error(`Peer ${peerIP} 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")) {
-                                // Add the faulty peer to the cooldown cache
-                                FullNodePeer.cooldownCache.set(peerIP, true);
-                                // Decrease weight or remove peer
-                                const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
-                                if (currentWeight > 1) {
-                                    FullNodePeer.peerWeights.set(peerIP, currentWeight - 1);
+                            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 ${selectedPeerIP} is disconnected.`);
+                            }
+                            try {
+                                const result = await originalMethod.apply(peerInfo.peer, args);
+                                // On successful operation, increase the weight slightly
+                                const currentWeight = FullNodePeer.peerWeights.get(selectedPeerIP) || 1;
+                                FullNodePeer.peerWeights.set(selectedPeerIP, currentWeight + 0.1); // Increment weight
+                                return result;
+                            }
+                            catch (error) {
+                                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(selectedPeerIP);
+                                    // If maximum retries reached, throw the error
+                                    if (retryCount >= MAX_RETRIES) {
+                                        console.error(`Max retries reached for method ${String(prop)} on peer ${selectedPeerIP}.`);
+                                        throw error;
+                                    }
+                                    // Attempt to select a new peer and retry the method
+                                    try {
+                                        console.info(`Selecting a new peer to retry method ${String(prop)}...`);
+                                        const newPeer = await FullNodePeer.getBestPeer();
+                                        // Extract new peer's IP address
+                                        const newPeerIP = FullNodePeer.extractPeerIP(newPeer);
+                                        if (!newPeerIP) {
+                                            throw new Error("Unable to extract IP from the new peer.");
+                                        }
+                                        // Wrap the new peer with a proxy, incrementing the retry count
+                                        const proxiedNewPeer = FullNodePeer.createPeerProxy(newPeer, newPeerIP, retryCount + 1);
+                                        // Retry the method on the new peer
+                                        return await proxiedNewPeer[prop](...args);
+                                    }
+                                    catch (retryError) {
+                                        console.error(`Retry failed on a new peer: ${retryError.message}`);
+                                        throw retryError;
+                                    }
                                 }
                                 else {
-                                    FullNodePeer.peerWeights.delete(peerIP);
-                                }
-                                // If maximum retries reached, throw the error
-                                if (retryCount >= MAX_RETRIES) {
-                                    console.error(`Max retries reached for method ${String(prop)} on peer ${peerIP}.`);
+                                    // For other errors, handle normally
                                     throw error;
                                 }
-                                // Attempt to select a new peer and retry the method
-                                try {
-                                    console.info(`Selecting a new peer to retry method ${String(prop)}...`);
-                                    const newPeer = await FullNodePeer.getBestPeer();
-                                    // Extract new peer's IP address
-                                    const newPeerIP = FullNodePeer.extractPeerIP(newPeer);
-                                    if (!newPeerIP) {
-                                        throw new Error("Unable to extract IP from the new peer.");
-                                    }
-                                    // Wrap the new peer with a proxy, incrementing the retry count
-                                    const proxiedNewPeer = FullNodePeer.createPeerProxy(newPeer, newPeerIP, retryCount + 1);
-                                    // Retry the method on the new peer
-                                    return await proxiedNewPeer[prop](...args);
-                                }
-                                catch (retryError) {
-                                    console.error(`Retry failed on a new peer: ${retryError.message}`);
-                                    throw retryError;
-                                }
                             }
-                            else {
-                                // For other errors, handle normally
-                                throw error;
-                            }
-                        }
+                        });
                     };
                 }
                 return originalMethod;
             },
         });
     }
+    /**
+     * Handles peer disconnection by marking it in cooldown and updating internal states.
+     * @param {string} peerIP - The IP address of the disconnected peer.
+     */
+    static handlePeerDisconnection(peerIP) {
+        // Mark the peer in cooldown
+        FullNodePeer.cooldownCache.set(peerIP, true);
+        // Decrease weight or remove peer
+        const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
+        if (currentWeight > 1) {
+            FullNodePeer.peerWeights.set(peerIP, currentWeight - 1);
+        }
+        else {
+            FullNodePeer.peerWeights.delete(peerIP);
+        }
+        // Update the peer's connection status
+        const peerInfo = FullNodePeer.peerInfos.get(peerIP);
+        if (peerInfo) {
+            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.
      * @param {Peer} peer - The Peer instance.
@@ -408,13 +507,21 @@ class FullNodePeer {
         return null;
     }
     /**
-   * Waits for a coin to be confirmed (spent) on the blockchain.
-   * @param {Buffer} parentCoinInfo - The parent coin information.
-   * @returns {Promise<boolean>} Whether the coin was confirmed.
-   */
+     * Waits for a coin to be confirmed (spent) on the blockchain.
+     * @param {Buffer} parentCoinInfo - The parent coin information.
+     * @returns {Promise<boolean>} Whether the coin was confirmed.
+     */
     static async waitForConfirmation(parentCoinInfo) {
         const spinner = (0, nanospinner_1.createSpinner)("Waiting for confirmation...").start();
-        const peer = await FullNodePeer.connect();
+        let peer;
+        try {
+            peer = await FullNodePeer.connect();
+        }
+        catch (error) {
+            spinner.error({ text: "Failed to connect to a peer." });
+            console.error(`waitForConfirmation connection error: ${error.message}`);
+            throw error;
+        }
         try {
             while (true) {
                 const confirmed = await peer.isCoinSpent(parentCoinInfo, config_1.MIN_HEIGHT, Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex"));
@@ -422,7 +529,7 @@ class FullNodePeer {
                     spinner.success({ text: "Coin confirmed!" });
                     return true;
                 }
-                await new Promise((resolve) => setTimeout(resolve, 5000));
+                await FullNodePeer.delay(5000);
             }
         }
         catch (error) {
@@ -431,6 +538,14 @@ class FullNodePeer {
             throw error;
         }
     }
+    /**
+     * Delays execution for a specified amount of time.
+     * @param {number} ms - Milliseconds to delay.
+     * @returns {Promise<void>} A promise that resolves after the delay.
+     */
+    static delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
 }
 exports.FullNodePeer = FullNodePeer;
 // Singleton instance
@@ -447,3 +562,7 @@ FullNodePeer.prioritizedPeers = [];
 FullNodePeer.peerInfos = new Map();
 // Cache for fetched peer IPs
 FullNodePeer.peerIPCache = new node_cache_1.default({ stdTTL: CACHE_DURATION / 1000 });
+// 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.134",
+  "version": "0.0.1-alpha.136",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",
@@ -30,6 +30,7 @@
     "archiver": "^7.0.1",
     "axios": "^1.7.7",
     "bip39": "^3.1.0",
+    "bottleneck": "^2.19.5",
     "chia-bls": "^1.0.2",
     "chia-config-loader": "^1.0.1",
     "chia-root-resolver": "^1.0.0",