@dignetwork/dig-sdk 0.0.1-alpha.139 → 0.0.1-alpha.141

package/dist/blockchain/FullNodePeer.d.ts

@@ -1,18 +1,31 @@
 import { Peer } from "@dignetwork/datalayer-driver";
+import NodeCache from "node-cache";
+/**
+ * Module Augmentation to extend the Peer interface with the 'on' method.
+ * This resolves the TypeScript error: Property 'on' does not exist on type 'Peer'.
+ */
+declare module "@dignetwork/datalayer-driver" {
+    interface Peer {
+        on(event: string, listener: (...args: any[]) => void): this;
+    }
+}
 /**
  * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
+ * It implements a singleton pattern to ensure a single instance throughout the application.
  */
 export declare class FullNodePeer {
-    private peer;
     private static instance;
-    private static cachedPeer;
-    private static cooldownCache;
-    private static peerWeights;
-    private static prioritizedPeers;
-    private static peerInfos;
-    private static peerIPCache;
-    private static availablePeers;
-    private static currentPeerIndex;
+    private cachedPeer;
+    cooldownCache: NodeCache;
+    peerWeights: Map<string, number>;
+    private prioritizedPeers;
+    private peerInfos;
+    private peerIPCache;
+    private availablePeers;
+    private currentPeerIndex;
+    /**
+     * Private constructor for singleton pattern.
+     */
     private constructor();
     /**
      * Retrieves the singleton instance of FullNodePeer.
@@ -36,75 +49,67 @@ export declare class FullNodePeer {
      * @param {number} timeout - Connection timeout in milliseconds.
      * @returns {Promise<boolean>} Whether the port is reachable.
      */
-    private static isPortReachable;
+    private isPortReachable;
     /**
      * Validates an IPv4 address.
      * @param {string} ip - The IP address to validate.
      * @returns {boolean} Whether the IP address is valid.
      */
-    private static isValidIpAddress;
+    private isValidIpAddress;
     /**
      * Retrieves the TRUSTED_FULLNODE IP from the environment and verifies its validity.
      * @returns {string | null} The trusted full node IP or null if invalid.
      */
-    private static getTrustedFullNode;
+    private getTrustedFullNode;
     /**
      * Fetches new peer IPs from DNS introducers and prioritized hosts.
      * Utilizes caching to avoid redundant DNS resolutions.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    private static fetchNewPeerIPs;
+    private fetchNewPeerIPs;
     /**
      * Shuffles an array using the Fisher-Yates algorithm.
      * @param {T[]} array - The array to shuffle.
      * @returns {T[]} The shuffled array.
      */
-    private static shuffleArray;
+    private shuffleArray;
     /**
      * Initializes the peer weights map.
      * Assigns higher initial weights to prioritized peers.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    private static initializePeerWeights;
+    private initializePeerWeights;
     /**
      * Selects the next peer based on round-robin selection.
-     * @returns {string} The selected peer IP.
+     * @returns {Promise<Peer>} The selected Peer instance.
      */
-    private static getNextPeerIP;
+    private selectNextPeer;
     /**
      * Retrieves all reachable peer IPs, excluding those in cooldown.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    private static getPeerIPs;
+    private getPeerIPs;
     /**
      * Initializes the peer weights based on prioritization and reliability.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    private static setupPeers;
+    private setupPeers;
     /**
      * 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 round-robin selection.
-     * @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;
+    getBestPeer(): Promise<Peer>;
     /**
      * 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;
+    handlePeerDisconnection(peerIP: string): void;
     /**
      * Extracts the IP address from a Peer instance.
      * @param {Peer} peer - The Peer instance.
      * @returns {string | null} The extracted IP address or null if not found.
      */
-    private static extractPeerIP;
+    extractPeerIP(peer: Peer): string | null;
     /**
      * Waits for a coin to be confirmed (spent) on the blockchain.
      * @param {Buffer} parentCoinInfo - The parent coin information.
@@ -116,6 +121,6 @@ export declare class FullNodePeer {
      * @param {number} ms - Milliseconds to delay.
      * @returns {Promise<void>} A promise that resolves after the delay.
      */
-    private static delay;
+    static delay(ms: number): Promise<void>;
 }
 //# 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;AAkCzD;;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;IA0HhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAiF9B;;;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"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAMzD,OAAO,SAAS,MAAM,YAAY,CAAC;AAGnC;;;GAGG;AACH,OAAO,QAAQ,8BAA8B,CAAC;IAC5C,UAAU,IAAI;QACZ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;KAC7D;CACF;AA6GD;;;GAGG;AACH,qBAAa,YAAY;IAEvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAGpD,OAAO,CAAC,UAAU,CAAkD;IAG7D,aAAa,YAAuD;IAGpE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAa;IAGpD,OAAO,CAAC,gBAAgB,CAAgB;IAGxC,OAAO,CAAC,SAAS,CAAoC;IAGrD,OAAO,CAAC,WAAW,CAAoD;IAGvE,OAAO,CAAC,cAAc,CAAgB;IAGtC,OAAO,CAAC,gBAAgB,CAAa;IAErC;;OAEG;IACH,OAAO;IAEP;;;OAGG;WACW,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYxC;;;;OAIG;WACiB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5C;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAuBvB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;;OAIG;YACW,eAAe;IAoF7B;;;;OAIG;IACH,OAAO,CAAC,YAAY;IASpB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;;OAGG;YACW,cAAc;IAW5B;;;OAGG;YACW,UAAU;IAKxB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAIlB;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IA0HzC;;;OAGG;IACI,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAwCpD;;;;OAIG;IACI,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI;IAS/C;;;;OAIG;WACiB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;IAkCnB;;;;OAIG;WACW,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/C"}

package/dist/blockchain/FullNodePeer.js

@@ -1,4 +1,5 @@
 "use strict";
+// FullNodePeer.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -14,7 +15,10 @@ 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"));
-// Constants
+const bottleneck_1 = __importDefault(require("bottleneck"));
+/**
+ * Constants defining configuration parameters.
+ */
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
 const CHIA_NODES_HOST = "chia-nodes";
@@ -29,13 +33,101 @@ 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; // Per-peer rate limit
+/**
+ * Creates a proxy for the Peer instance to handle errors, retries, and rate limiting.
+ * @param peer - The original Peer instance.
+ * @param peerIP - The IP address of the peer.
+ * @param retryCount - The current retry attempt.
+ * @returns {Peer} - The proxied Peer instance.
+ */
+function createPeerProxy(peer, peerIP, retryCount = 0) {
+    // Initialize Bottleneck limiter for rate limiting
+    const limiter = new bottleneck_1.default({
+        maxConcurrent: 1, // One request at a time per peer
+        minTime: 60000 / MAX_REQUESTS_PER_MINUTE, // e.g., 600 ms between requests for 100 requests/min
+    });
+    return new Proxy(peer, {
+        get(target, prop, receiver) {
+            const originalMethod = target[prop];
+            if (typeof originalMethod === "function") {
+                return async (...args) => {
+                    try {
+                        // Schedule the method call with Bottleneck's limiter
+                        const result = await limiter.schedule(() => originalMethod.apply(target, args));
+                        // On successful operation, increase the weight slightly
+                        const fullNodePeer = FullNodePeer.getInstance();
+                        const currentWeight = fullNodePeer.peerWeights.get(peerIP) || 1;
+                        fullNodePeer.peerWeights.set(peerIP, currentWeight + 0.1); // Increment weight
+                        return result;
+                    }
+                    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")) {
+                            // Handle the disconnection and mark the peer accordingly
+                            FullNodePeer.getInstance().handlePeerDisconnection(peerIP);
+                            // If maximum retries reached, throw the error
+                            if (retryCount >= MAX_RETRIES) {
+                                console.error(`Max retries reached for method ${String(prop)} on peer ${peerIP}.`);
+                                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.getInstance().getBestPeer();
+                                // Extract new peer's IP address
+                                const newPeerIP = FullNodePeer.getInstance().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 = 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;
+        },
+    });
+}
 /**
  * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
+ * It implements a singleton pattern to ensure a single instance throughout the application.
  */
 class FullNodePeer {
-    // Private constructor for singleton pattern
-    constructor(peer) {
-        this.peer = peer;
+    /**
+     * Private constructor for singleton pattern.
+     */
+    constructor() {
+        // Cached peer with timestamp
+        this.cachedPeer = null;
+        // Cooldown cache to exclude faulty peers temporarily
+        this.cooldownCache = new node_cache_1.default({ stdTTL: COOLDOWN_DURATION / 1000 });
+        // Peer reliability weights
+        this.peerWeights = new Map();
+        // List of prioritized peers
+        this.prioritizedPeers = [];
+        // Map to store PeerInfo
+        this.peerInfos = new Map();
+        // Cache for fetched peer IPs
+        this.peerIPCache = new node_cache_1.default({ stdTTL: CACHE_DURATION / 1000 });
+        // List of available peers for round-robin
+        this.availablePeers = [];
+        // Current index for round-robin selection
+        this.currentPeerIndex = 0;
     }
     /**
      * Retrieves the singleton instance of FullNodePeer.
@@ -43,7 +135,7 @@ class FullNodePeer {
      */
     static getInstance() {
         if (!FullNodePeer.instance) {
-            FullNodePeer.instance = new FullNodePeer(null); // Temporarily set to null
+            FullNodePeer.instance = new FullNodePeer();
         }
         return FullNodePeer.instance;
     }
@@ -51,12 +143,11 @@ class FullNodePeer {
      * Initializes the singleton instance by connecting to the best peer.
      */
     async initialize() {
-        if (this.peer)
+        if (this.cachedPeer)
             return; // Already initialized
         try {
-            const bestPeer = await FullNodePeer.getBestPeer();
-            this.peer = bestPeer;
-            FullNodePeer.instance = this; // Assign the initialized instance
+            const bestPeer = await this.getBestPeer();
+            this.cachedPeer = { peer: bestPeer, timestamp: Date.now() };
         }
         catch (error) {
             console.error(`Initialization failed: ${error.message}`);
@@ -71,7 +162,7 @@ class FullNodePeer {
     static async connect() {
         const instance = FullNodePeer.getInstance();
         await instance.initialize();
-        return instance.peer;
+        return instance.cachedPeer.peer;
     }
     /**
      * Checks if a given port on a host is reachable.
@@ -80,7 +171,7 @@ class FullNodePeer {
      * @param {number} timeout - Connection timeout in milliseconds.
      * @returns {Promise<boolean>} Whether the port is reachable.
      */
-    static isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
+    isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
         return new Promise((resolve) => {
             const socket = new net_1.default.Socket()
                 .setTimeout(timeout)
@@ -103,7 +194,7 @@ class FullNodePeer {
      * @param {string} ip - The IP address to validate.
      * @returns {boolean} Whether the IP address is valid.
      */
-    static isValidIpAddress(ip) {
+    isValidIpAddress(ip) {
         const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/;
         return ipv4Regex.test(ip);
     }
@@ -111,9 +202,9 @@ class FullNodePeer {
      * Retrieves the TRUSTED_FULLNODE IP from the environment and verifies its validity.
      * @returns {string | null} The trusted full node IP or null if invalid.
      */
-    static getTrustedFullNode() {
+    getTrustedFullNode() {
         const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
-        if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
+        if (trustedNodeIp && this.isValidIpAddress(trustedNodeIp)) {
             return trustedNodeIp;
         }
         return null;
@@ -123,39 +214,36 @@ class FullNodePeer {
      * Utilizes caching to avoid redundant DNS resolutions.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    static async fetchNewPeerIPs() {
-        const trustedNodeIp = FullNodePeer.getTrustedFullNode();
+    async fetchNewPeerIPs() {
+        const trustedNodeIp = this.getTrustedFullNode();
         const priorityIps = [];
         // Define prioritized peers
-        FullNodePeer.prioritizedPeers = [
-            ...DNS_HOSTS, // Assuming CHIA_NODES_HOST is included in DNS_HOSTS
-            LOCALHOST,
-        ];
+        this.prioritizedPeers = [CHIA_NODES_HOST, LOCALHOST];
         // Add trustedNodeIp if available
         if (trustedNodeIp) {
-            FullNodePeer.prioritizedPeers.unshift(trustedNodeIp);
+            this.prioritizedPeers.unshift(trustedNodeIp);
         }
         // Prioritize trustedNodeIp
         if (trustedNodeIp &&
-            !FullNodePeer.cooldownCache.has(trustedNodeIp) &&
-            (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
+            !this.cooldownCache.has(trustedNodeIp) &&
+            (await this.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
         // Prioritize LOCALHOST
-        if (!FullNodePeer.cooldownCache.has(LOCALHOST) &&
-            (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
+        if (!this.cooldownCache.has(LOCALHOST) &&
+            (await this.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
             priorityIps.push(LOCALHOST);
         }
         // Prioritize CHIA_NODES_HOST
-        if (!FullNodePeer.cooldownCache.has(CHIA_NODES_HOST) &&
-            (await FullNodePeer.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
+        if (!this.cooldownCache.has(CHIA_NODES_HOST) &&
+            (await this.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
             priorityIps.push(CHIA_NODES_HOST);
         }
         if (priorityIps.length > 0) {
             return priorityIps;
         }
         // Check if cached peer IPs exist
-        const cachedPeerIPs = FullNodePeer.peerIPCache.get("peerIPs");
+        const cachedPeerIPs = this.peerIPCache.get("peerIPs");
         if (cachedPeerIPs) {
             return cachedPeerIPs;
         }
@@ -165,11 +253,11 @@ class FullNodePeer {
             try {
                 const ips = await (0, promises_1.resolve4)(DNS_HOST);
                 if (ips && ips.length > 0) {
-                    const shuffledIps = FullNodePeer.shuffleArray(ips);
+                    const shuffledIps = this.shuffleArray(ips);
                     const reachableIps = [];
                     for (const ip of shuffledIps) {
-                        if (!FullNodePeer.cooldownCache.has(ip) &&
-                            (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT))) {
+                        if (!this.cooldownCache.has(ip) &&
+                            (await this.isPortReachable(ip, FULLNODE_PORT))) {
                             reachableIps.push(ip);
                         }
                         if (reachableIps.length === MAX_PEERS_TO_FETCH)
@@ -186,7 +274,7 @@ class FullNodePeer {
         }
         // Cache the fetched peer IPs
         if (fetchedPeers.length > 0) {
-            FullNodePeer.peerIPCache.set("peerIPs", fetchedPeers);
+            this.peerIPCache.set("peerIPs", fetchedPeers);
             return fetchedPeers;
         }
         throw new Error("No reachable IPs found in any DNS records.");
@@ -196,7 +284,7 @@ class FullNodePeer {
      * @param {T[]} array - The array to shuffle.
      * @returns {T[]} The shuffled array.
      */
-    static shuffleArray(array) {
+    shuffleArray(array) {
         const shuffled = [...array];
         for (let i = shuffled.length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
@@ -209,66 +297,67 @@ class FullNodePeer {
      * Assigns higher initial weights to prioritized peers.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    static initializePeerWeights(peerIPs) {
+    initializePeerWeights(peerIPs) {
         for (const ip of peerIPs) {
-            if (!FullNodePeer.peerWeights.has(ip)) {
+            if (!this.peerWeights.has(ip)) {
                 if (ip === CHIA_NODES_HOST ||
                     ip === LOCALHOST ||
-                    ip === FullNodePeer.getTrustedFullNode()) {
-                    FullNodePeer.peerWeights.set(ip, 5); // Higher weight for prioritized peers
+                    ip === this.getTrustedFullNode()) {
+                    this.peerWeights.set(ip, 5); // Higher weight for prioritized peers
                 }
                 else {
-                    FullNodePeer.peerWeights.set(ip, 1); // Default weight
+                    this.peerWeights.set(ip, 1); // Default weight
                 }
             }
         }
     }
     /**
      * Selects the next peer based on round-robin selection.
-     * @returns {string} The selected peer IP.
+     * @returns {Promise<Peer>} The selected Peer instance.
      */
-    static getNextPeerIP() {
-        if (FullNodePeer.availablePeers.length === 0) {
+    async selectNextPeer() {
+        if (this.availablePeers.length === 0) {
             throw new Error("No available peers to select.");
         }
-        const peerIP = FullNodePeer.availablePeers[FullNodePeer.currentPeerIndex];
-        FullNodePeer.currentPeerIndex = (FullNodePeer.currentPeerIndex + 1) % FullNodePeer.availablePeers.length;
-        return peerIP;
+        const peerIP = this.availablePeers[this.currentPeerIndex];
+        this.currentPeerIndex = (this.currentPeerIndex + 1) % this.availablePeers.length;
+        const peerInfo = this.peerInfos.get(peerIP);
+        return peerInfo.peer;
     }
     /**
      * Retrieves all reachable peer IPs, excluding those in cooldown.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    static async getPeerIPs() {
-        const peerIPs = await FullNodePeer.fetchNewPeerIPs();
+    async getPeerIPs() {
+        const peerIPs = await this.fetchNewPeerIPs();
         return peerIPs;
     }
     /**
      * Initializes the peer weights based on prioritization and reliability.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    static setupPeers(peerIPs) {
-        FullNodePeer.initializePeerWeights(peerIPs);
+    setupPeers(peerIPs) {
+        this.initializePeerWeights(peerIPs);
     }
     /**
      * Connects to the best available peer based on round-robin selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
-    static async getBestPeer() {
+    async getBestPeer() {
         const now = Date.now();
         // Refresh cachedPeer if expired or disconnected
-        if (FullNodePeer.cachedPeer &&
-            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION &&
-            FullNodePeer.peerInfos.get(FullNodePeer.extractPeerIP(FullNodePeer.cachedPeer.peer) || "")?.isConnected) {
-            return FullNodePeer.cachedPeer.peer;
+        if (this.cachedPeer &&
+            now - this.cachedPeer.timestamp < CACHE_DURATION &&
+            this.peerInfos.get(this.extractPeerIP(this.cachedPeer.peer) || "")?.isConnected) {
+            return this.cachedPeer.peer;
         }
         // Fetch peer IPs
-        const peerIPs = await FullNodePeer.getPeerIPs();
+        const peerIPs = await this.getPeerIPs();
         // Setup peer weights with prioritization
-        FullNodePeer.setupPeers(peerIPs);
+        this.setupPeers(peerIPs);
         // Initialize or update peerInfos and availablePeers
         for (const ip of peerIPs) {
-            if (!FullNodePeer.peerInfos.has(ip)) {
+            if (!this.peerInfos.has(ip)) {
                 // 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");
@@ -284,31 +373,32 @@ class FullNodePeer {
                 catch (error) {
                     console.error(`Failed to create peer for IP ${ip}: ${error.message}`);
                     // Add to cooldown
-                    FullNodePeer.cooldownCache.set(ip, true);
+                    this.cooldownCache.set(ip, true);
                     // Decrease weight or remove peer
-                    const currentWeight = FullNodePeer.peerWeights.get(ip) || 1;
+                    const currentWeight = this.peerWeights.get(ip) || 1;
                     if (currentWeight > 1) {
-                        FullNodePeer.peerWeights.set(ip, currentWeight - 1);
+                        this.peerWeights.set(ip, currentWeight - 1);
                     }
                     else {
-                        FullNodePeer.peerWeights.delete(ip);
+                        this.peerWeights.delete(ip);
                     }
                     continue; // Skip adding this peer
                 }
                 // Wrap the peer with proxy to handle errors and retries
-                const proxiedPeer = FullNodePeer.createPeerProxy(peer, ip);
+                const proxiedPeer = createPeerProxy(peer, ip);
                 // Store PeerInfo
-                FullNodePeer.peerInfos.set(ip, {
+                this.peerInfos.set(ip, {
                     peer: proxiedPeer,
-                    weight: FullNodePeer.peerWeights.get(ip) || 1,
+                    weight: this.peerWeights.get(ip) || 1,
                     address: ip,
                     isConnected: true, // Mark as connected
+                    limiter: proxiedPeer.limiter, // Assign the limiter from Proxy
                 });
                 // Add to availablePeers
-                FullNodePeer.availablePeers.push(ip);
+                this.availablePeers.push(ip);
             }
             else {
-                const peerInfo = FullNodePeer.peerInfos.get(ip);
+                const peerInfo = this.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");
@@ -325,149 +415,71 @@ class FullNodePeer {
                     catch (error) {
                         console.error(`Failed to reconnect peer for IP ${ip}: ${error.message}`);
                         // Re-add to cooldown
-                        FullNodePeer.cooldownCache.set(ip, true);
+                        this.cooldownCache.set(ip, true);
                         // Decrease weight or remove peer
-                        const currentWeight = FullNodePeer.peerWeights.get(ip) || 1;
+                        const currentWeight = this.peerWeights.get(ip) || 1;
                         if (currentWeight > 1) {
-                            FullNodePeer.peerWeights.set(ip, currentWeight - 1);
+                            this.peerWeights.set(ip, currentWeight - 1);
                         }
                         else {
-                            FullNodePeer.peerWeights.delete(ip);
+                            this.peerWeights.delete(ip);
                         }
                         continue; // Skip adding this peer
                     }
                     // Wrap the peer with proxy to handle errors and retries
-                    const proxiedPeer = FullNodePeer.createPeerProxy(peer, ip);
+                    const proxiedPeer = createPeerProxy(peer, ip);
                     // Update PeerInfo
                     peerInfo.peer = proxiedPeer;
                     peerInfo.isConnected = true;
                     // Add back to availablePeers
-                    FullNodePeer.availablePeers.push(ip);
+                    this.availablePeers.push(ip);
                 }
             }
         }
-        if (FullNodePeer.availablePeers.length === 0) {
+        if (this.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);
+        const selectedPeer = await this.selectNextPeer();
         // Cache the peer
-        FullNodePeer.cachedPeer = { peer: selectedPeerInfo.peer, timestamp: now };
-        console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
-        return selectedPeerInfo.peer;
-    }
-    /**
-     * Creates a proxy for the peer to handle errors, implement retries, and enforce round-robin selection.
-     * @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 (...args) => {
-                        // 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);
-                        if (!selectedPeerInfo || !selectedPeerInfo.isConnected) {
-                            return Promise.reject(new Error(`Peer ${selectedPeerIP} is disconnected.`));
-                        }
-                        try {
-                            // Bind the original method to the peer instance to preserve 'this'
-                            const boundMethod = originalMethod.bind(selectedPeerInfo.peer);
-                            const result = boundMethod(...args);
-                            return result;
-                        }
-                        catch (error) {
-                            console.error(`Peer ${selectedPeerIP} encountered an error: ${error.message}`);
-                            // Handle disconnection and retries
-                            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}.`);
-                                return Promise.reject(error);
-                            }
-                            // Attempt to select a new peer and retry the method
-                            return FullNodePeer.getBestPeer()
-                                .then((newPeer) => {
-                                // 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 proxiedNewPeer[prop](...args);
-                            })
-                                .catch((retryError) => {
-                                console.error(`Retry failed on a new peer: ${retryError.message}`);
-                                return Promise.reject(retryError);
-                            });
-                        }
-                    };
-                }
-                return originalMethod;
-            },
-        });
+        this.cachedPeer = { peer: selectedPeer, timestamp: now };
+        console.log(`Using Fullnode Peer: ${this.extractPeerIP(selectedPeer)}`);
+        return selectedPeer;
     }
     /**
      * 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) {
+    handlePeerDisconnection(peerIP) {
         // Mark the peer in cooldown
-        FullNodePeer.cooldownCache.set(peerIP, true);
+        this.cooldownCache.set(peerIP, true);
         // Decrease weight or remove peer
-        const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
+        const currentWeight = this.peerWeights.get(peerIP) || 1;
         if (currentWeight > 1) {
-            FullNodePeer.peerWeights.set(peerIP, currentWeight - 1);
+            this.peerWeights.set(peerIP, currentWeight - 1);
         }
         else {
-            FullNodePeer.peerWeights.delete(peerIP);
+            this.peerWeights.delete(peerIP);
         }
         // Update the peer's connection status
-        const peerInfo = FullNodePeer.peerInfos.get(peerIP);
+        const peerInfo = this.peerInfos.get(peerIP);
         if (peerInfo) {
             peerInfo.isConnected = false;
-            FullNodePeer.peerInfos.set(peerIP, peerInfo);
+            this.peerInfos.set(peerIP, peerInfo);
         }
         // Remove from availablePeers if present
-        const index = FullNodePeer.availablePeers.indexOf(peerIP);
+        const index = this.availablePeers.indexOf(peerIP);
         if (index !== -1) {
-            FullNodePeer.availablePeers.splice(index, 1);
+            this.availablePeers.splice(index, 1);
             // Adjust currentPeerIndex if necessary
-            if (FullNodePeer.currentPeerIndex >= FullNodePeer.availablePeers.length) {
-                FullNodePeer.currentPeerIndex = 0;
+            if (this.currentPeerIndex >= this.availablePeers.length) {
+                this.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;
+        if (this.cachedPeer &&
+            this.extractPeerIP(this.cachedPeer.peer) === peerIP) {
+            this.cachedPeer = null;
         }
         console.warn(`Peer ${peerIP} has been marked as disconnected and is in cooldown.`);
     }
@@ -476,8 +488,8 @@ class FullNodePeer {
      * @param {Peer} peer - The Peer instance.
      * @returns {string | null} The extracted IP address or null if not found.
      */
-    static extractPeerIP(peer) {
-        for (const [ip, info] of FullNodePeer.peerInfos.entries()) {
+    extractPeerIP(peer) {
+        for (const [ip, info] of this.peerInfos.entries()) {
             if (info.peer === peer) {
                 return ip;
             }
@@ -528,19 +540,3 @@ class FullNodePeer {
 exports.FullNodePeer = FullNodePeer;
 // Singleton instance
 FullNodePeer.instance = null;
-// Cached peer with timestamp
-FullNodePeer.cachedPeer = null;
-// Cooldown cache to exclude faulty peers temporarily
-FullNodePeer.cooldownCache = new node_cache_1.default({ stdTTL: COOLDOWN_DURATION / 1000 });
-// Peer reliability weights
-FullNodePeer.peerWeights = new Map();
-// List of prioritized peers
-FullNodePeer.prioritizedPeers = [];
-// Map to store PeerInfo
-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.139",
+  "version": "0.0.1-alpha.141",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",