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

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

@@ -1 +1 @@
-{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;gBAEpD,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,aAAa,CAAC,GAAG,EAAE,MAAM;WAIzB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,gBAAgB,GAAE,MAAM,EAAO,GAC9B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA0EZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;WAOrC,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAcH,kBAAkB,CAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC;IA8GH,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}
+{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;gBAEpD,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,aAAa,CAAC,GAAG,EAAE,MAAM;WAIzB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,gBAAgB,GAAE,MAAM,EAAO,GAC9B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA2EZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;WAOrC,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAcH,kBAAkB,CAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC;IA8GH,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}

package/dist/DigNetwork/DigNetwork.js

@@ -50,6 +50,7 @@ class DigNetwork {
     static async findPeerWithStoreKey(storeId, rootHash, key, initialBlackList = []) {
         const peerBlackList = initialBlackList;
         const serverCoin = new blockchain_1.ServerCoin(storeId);
+        const allPeers = await serverCoin.getActiveEpochPeers();
         while (true) {
             try {
                 // Sample 10 peers from the current epoch

package/dist/blockchain/FullNodePeer.d.ts

@@ -1,31 +1,17 @@
 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 cachedPeer;
-    cooldownCache: NodeCache;
-    peerWeights: Map<string, number>;
-    private prioritizedPeers;
-    private peerInfos;
-    private peerIPCache;
-    private availablePeers;
-    private currentPeerIndex;
-    /**
-     * Private constructor for singleton pattern.
-     */
+    private static cachedPeer;
+    private static cooldownCache;
+    private static peerWeights;
+    private static prioritizedPeers;
+    private static peerInfos;
+    private static peerIPCache;
+    private static peerLimiters;
     private constructor();
     /**
      * Retrieves the singleton instance of FullNodePeer.
@@ -49,56 +35,57 @@ export declare class FullNodePeer {
      * @param {number} timeout - Connection timeout in milliseconds.
      * @returns {Promise<boolean>} Whether the port is reachable.
      */
-    private isPortReachable;
+    private static isPortReachable;
     /**
      * Validates an IPv4 address.
      * @param {string} ip - The IP address to validate.
      * @returns {boolean} Whether the IP address is valid.
      */
-    private isValidIpAddress;
+    private static 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 getTrustedFullNode;
+    private static 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 fetchNewPeerIPs;
+    private static fetchNewPeerIPs;
     /**
      * Shuffles an array using the Fisher-Yates algorithm.
      * @param {T[]} array - The array to shuffle.
      * @returns {T[]} The shuffled array.
      */
-    private shuffleArray;
+    private static shuffleArray;
     /**
      * Initializes the peer weights map.
      * Assigns higher initial weights to prioritized peers.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    private initializePeerWeights;
+    private static initializePeerWeights;
     /**
-     * Selects the next peer based on round-robin selection.
-     * @returns {Promise<Peer>} The selected Peer instance.
+     * Selects a peer based on weighted random selection.
+     * Prioritized peers have higher weights.
+     * @returns {string} The selected peer IP.
      */
-    private selectNextPeer;
+    private static selectPeerByWeight;
     /**
      * Retrieves all reachable peer IPs, excluding those in cooldown.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    private getPeerIPs;
+    private static getPeerIPs;
     /**
      * Initializes the peer weights based on prioritization and reliability.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    private setupPeers;
+    private static setupPeers;
     /**
-     * Connects to the best available peer based on round-robin selection and reliability.
+     * Connects to the best available peer based on weighted selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
-    getBestPeer(): Promise<Peer>;
+    private static getBestPeer;
     /**
      * Handles peer disconnection by marking it in cooldown and updating internal states.
      * @param {string} peerIP - The IP address of the disconnected peer.
@@ -109,18 +96,12 @@ export declare class FullNodePeer {
      * @param {Peer} peer - The Peer instance.
      * @returns {string | null} The extracted IP address or null if not found.
      */
-    extractPeerIP(peer: Peer): string | null;
+    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.
      */
     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.
-     */
-    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":"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"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAmCzD;;GAEG;AACH,qBAAa,YAAY;IA0BH,OAAO,CAAC,IAAI;IAxBhC,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,YAAY,CAAsC;IAGjE,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;IAoFpC;;;;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;IA+EhC;;;OAGG;IACI,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAqBpD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;;OAIG;WACiB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAkDpB"}

package/dist/blockchain/FullNodePeer.js

@@ -16,9 +16,7 @@ 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 defining configuration parameters.
- */
+// Constants
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
 const CHIA_NODES_HOST = "chia-nodes";
@@ -30,104 +28,17 @@ const DNS_HOSTS = [
 ];
 const CONNECTION_TIMEOUT = 2000; // in milliseconds
 const CACHE_DURATION = 30000; // in milliseconds
-const COOLDOWN_DURATION = 300000; // 5 minutes in milliseconds
+const COOLDOWN_DURATION = 60000; // 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() {
-        // 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;
+    // Private constructor for singleton pattern
+    constructor(peer) {
+        this.peer = peer;
     }
     /**
      * Retrieves the singleton instance of FullNodePeer.
@@ -135,7 +46,7 @@ class FullNodePeer {
      */
     static getInstance() {
         if (!FullNodePeer.instance) {
-            FullNodePeer.instance = new FullNodePeer();
+            FullNodePeer.instance = new FullNodePeer(null); // Temporarily set to null
         }
         return FullNodePeer.instance;
     }
@@ -143,11 +54,12 @@ class FullNodePeer {
      * Initializes the singleton instance by connecting to the best peer.
      */
     async initialize() {
-        if (this.cachedPeer)
+        if (this.peer)
             return; // Already initialized
         try {
-            const bestPeer = await this.getBestPeer();
-            this.cachedPeer = { peer: bestPeer, timestamp: Date.now() };
+            const bestPeer = await FullNodePeer.getBestPeer();
+            this.peer = bestPeer;
+            FullNodePeer.instance = this; // Assign the initialized instance
         }
         catch (error) {
             console.error(`Initialization failed: ${error.message}`);
@@ -162,7 +74,7 @@ class FullNodePeer {
     static async connect() {
         const instance = FullNodePeer.getInstance();
         await instance.initialize();
-        return instance.cachedPeer.peer;
+        return instance.peer;
     }
     /**
      * Checks if a given port on a host is reachable.
@@ -171,7 +83,7 @@ class FullNodePeer {
      * @param {number} timeout - Connection timeout in milliseconds.
      * @returns {Promise<boolean>} Whether the port is reachable.
      */
-    isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
+    static isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
         return new Promise((resolve) => {
             const socket = new net_1.default.Socket()
                 .setTimeout(timeout)
@@ -194,7 +106,7 @@ class FullNodePeer {
      * @param {string} ip - The IP address to validate.
      * @returns {boolean} Whether the IP address is valid.
      */
-    isValidIpAddress(ip) {
+    static 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);
     }
@@ -202,9 +114,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.
      */
-    getTrustedFullNode() {
+    static getTrustedFullNode() {
         const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
-        if (trustedNodeIp && this.isValidIpAddress(trustedNodeIp)) {
+        if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
             return trustedNodeIp;
         }
         return null;
@@ -214,36 +126,36 @@ class FullNodePeer {
      * Utilizes caching to avoid redundant DNS resolutions.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    async fetchNewPeerIPs() {
-        const trustedNodeIp = this.getTrustedFullNode();
+    static async fetchNewPeerIPs() {
+        const trustedNodeIp = FullNodePeer.getTrustedFullNode();
         const priorityIps = [];
         // Define prioritized peers
-        this.prioritizedPeers = [CHIA_NODES_HOST, LOCALHOST];
+        FullNodePeer.prioritizedPeers = [CHIA_NODES_HOST, LOCALHOST];
         // Add trustedNodeIp if available
         if (trustedNodeIp) {
-            this.prioritizedPeers.unshift(trustedNodeIp);
+            FullNodePeer.prioritizedPeers.unshift(trustedNodeIp);
         }
         // Prioritize trustedNodeIp
         if (trustedNodeIp &&
-            !this.cooldownCache.has(trustedNodeIp) &&
-            (await this.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
+            !FullNodePeer.cooldownCache.has(trustedNodeIp) &&
+            (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
         // Prioritize LOCALHOST
-        if (!this.cooldownCache.has(LOCALHOST) &&
-            (await this.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
+        if (!FullNodePeer.cooldownCache.has(LOCALHOST) &&
+            (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
             priorityIps.push(LOCALHOST);
         }
         // Prioritize CHIA_NODES_HOST
-        if (!this.cooldownCache.has(CHIA_NODES_HOST) &&
-            (await this.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
+        if (!FullNodePeer.cooldownCache.has(CHIA_NODES_HOST) &&
+            (await FullNodePeer.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 = this.peerIPCache.get("peerIPs");
+        const cachedPeerIPs = FullNodePeer.peerIPCache.get("peerIPs");
         if (cachedPeerIPs) {
             return cachedPeerIPs;
         }
@@ -253,11 +165,11 @@ class FullNodePeer {
             try {
                 const ips = await (0, promises_1.resolve4)(DNS_HOST);
                 if (ips && ips.length > 0) {
-                    const shuffledIps = this.shuffleArray(ips);
+                    const shuffledIps = FullNodePeer.shuffleArray(ips);
                     const reachableIps = [];
                     for (const ip of shuffledIps) {
-                        if (!this.cooldownCache.has(ip) &&
-                            (await this.isPortReachable(ip, FULLNODE_PORT))) {
+                        if (!FullNodePeer.cooldownCache.has(ip) &&
+                            (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT))) {
                             reachableIps.push(ip);
                         }
                         if (reachableIps.length === MAX_PEERS_TO_FETCH)
@@ -274,7 +186,7 @@ class FullNodePeer {
         }
         // Cache the fetched peer IPs
         if (fetchedPeers.length > 0) {
-            this.peerIPCache.set("peerIPs", fetchedPeers);
+            FullNodePeer.peerIPCache.set("peerIPs", fetchedPeers);
             return fetchedPeers;
         }
         throw new Error("No reachable IPs found in any DNS records.");
@@ -284,7 +196,7 @@ class FullNodePeer {
      * @param {T[]} array - The array to shuffle.
      * @returns {T[]} The shuffled array.
      */
-    shuffleArray(array) {
+    static shuffleArray(array) {
         const shuffled = [...array];
         for (let i = shuffled.length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
@@ -297,190 +209,145 @@ class FullNodePeer {
      * Assigns higher initial weights to prioritized peers.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    initializePeerWeights(peerIPs) {
+    static initializePeerWeights(peerIPs) {
         for (const ip of peerIPs) {
-            if (!this.peerWeights.has(ip)) {
+            if (!FullNodePeer.peerWeights.has(ip)) {
                 if (ip === CHIA_NODES_HOST ||
                     ip === LOCALHOST ||
-                    ip === this.getTrustedFullNode()) {
-                    this.peerWeights.set(ip, 5); // Higher weight for prioritized peers
+                    ip === FullNodePeer.getTrustedFullNode()) {
+                    FullNodePeer.peerWeights.set(ip, 5); // Higher weight for prioritized peers
                 }
                 else {
-                    this.peerWeights.set(ip, 1); // Default weight
+                    FullNodePeer.peerWeights.set(ip, 1); // Default weight
                 }
             }
         }
     }
     /**
-     * Selects the next peer based on round-robin selection.
-     * @returns {Promise<Peer>} The selected Peer instance.
+     * Selects a peer based on weighted random selection.
+     * Prioritized peers have higher weights.
+     * @returns {string} The selected peer IP.
      */
-    async selectNextPeer() {
-        if (this.availablePeers.length === 0) {
-            throw new Error("No available peers to select.");
+    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.");
         }
-        const peerIP = this.availablePeers[this.currentPeerIndex];
-        this.currentPeerIndex = (this.currentPeerIndex + 1) % this.availablePeers.length;
-        const peerInfo = this.peerInfos.get(peerIP);
-        return peerInfo.peer;
+        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;
     }
     /**
      * Retrieves all reachable peer IPs, excluding those in cooldown.
      * @returns {Promise<string[]>} An array of reachable peer IPs.
      */
-    async getPeerIPs() {
-        const peerIPs = await this.fetchNewPeerIPs();
+    static async getPeerIPs() {
+        const peerIPs = await FullNodePeer.fetchNewPeerIPs();
         return peerIPs;
     }
     /**
      * Initializes the peer weights based on prioritization and reliability.
      * @param {string[]} peerIPs - An array of peer IPs.
      */
-    setupPeers(peerIPs) {
-        this.initializePeerWeights(peerIPs);
+    static setupPeers(peerIPs) {
+        FullNodePeer.initializePeerWeights(peerIPs);
     }
     /**
-     * Connects to the best available peer based on round-robin selection and reliability.
+     * Connects to the best available peer based on weighted selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
-    async getBestPeer() {
+    static async getBestPeer() {
         const now = Date.now();
-        // Refresh cachedPeer if expired or disconnected
-        if (this.cachedPeer &&
-            now - this.cachedPeer.timestamp < CACHE_DURATION &&
-            this.peerInfos.get(this.extractPeerIP(this.cachedPeer.peer) || "")?.isConnected) {
-            return this.cachedPeer.peer;
+        // Refresh cachedPeer if expired
+        if (FullNodePeer.cachedPeer &&
+            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
+            return FullNodePeer.cachedPeer.peer;
         }
         // Fetch peer IPs
-        const peerIPs = await this.getPeerIPs();
+        const peerIPs = await FullNodePeer.getPeerIPs();
         // Setup peer weights with prioritization
-        this.setupPeers(peerIPs);
-        // Initialize or update peerInfos and availablePeers
-        for (const ip of peerIPs) {
-            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");
-                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
-                    this.cooldownCache.set(ip, true);
-                    // Decrease weight or remove peer
-                    const currentWeight = this.peerWeights.get(ip) || 1;
-                    if (currentWeight > 1) {
-                        this.peerWeights.set(ip, currentWeight - 1);
-                    }
-                    else {
-                        this.peerWeights.delete(ip);
-                    }
-                    continue; // Skip adding this peer
-                }
-                // Wrap the peer with proxy to handle errors and retries
-                const proxiedPeer = createPeerProxy(peer, ip);
-                // Store PeerInfo
-                this.peerInfos.set(ip, {
-                    peer: proxiedPeer,
-                    weight: this.peerWeights.get(ip) || 1,
-                    address: ip,
-                    isConnected: true, // Mark as connected
-                    limiter: proxiedPeer.limiter, // Assign the limiter from Proxy
-                });
-                // Add to availablePeers
-                this.availablePeers.push(ip);
+        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);
             }
             else {
-                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");
-                    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
-                        this.cooldownCache.set(ip, true);
-                        // Decrease weight or remove peer
-                        const currentWeight = this.peerWeights.get(ip) || 1;
-                        if (currentWeight > 1) {
-                            this.peerWeights.set(ip, currentWeight - 1);
-                        }
-                        else {
-                            this.peerWeights.delete(ip);
-                        }
-                        continue; // Skip adding this peer
-                    }
-                    // Wrap the peer with proxy to handle errors and retries
-                    const proxiedPeer = createPeerProxy(peer, ip);
-                    // Update PeerInfo
-                    peerInfo.peer = proxiedPeer;
-                    peerInfo.isConnected = true;
-                    // Add back to availablePeers
-                    this.availablePeers.push(ip);
-                }
+                FullNodePeer.peerWeights.delete(selectedPeerIP);
             }
+            throw new Error(`Unable to connect to peer ${selectedPeerIP}`);
         }
-        if (this.availablePeers.length === 0) {
-            throw new Error("No available peers to connect.");
-        }
-        // Select the next peer in round-robin
-        const selectedPeer = await this.selectNextPeer();
+        // Create a Bottleneck limiter for this peer
+        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
+        });
+        // Store PeerInfo
+        FullNodePeer.peerInfos.set(selectedPeerIP, {
+            peer: peer,
+            weight: FullNodePeer.peerWeights.get(selectedPeerIP) || 1,
+            address: selectedPeerIP,
+        });
+        // Initialize rate limiter for this peer
+        FullNodePeer.peerLimiters.set(selectedPeerIP, limiter);
         // Cache the peer
-        this.cachedPeer = { peer: selectedPeer, timestamp: now };
-        console.log(`Using Fullnode Peer: ${this.extractPeerIP(selectedPeer)}`);
-        return selectedPeer;
+        FullNodePeer.cachedPeer = { peer: peer, timestamp: now };
+        console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
+        return peer;
     }
     /**
      * Handles peer disconnection by marking it in cooldown and updating internal states.
      * @param {string} peerIP - The IP address of the disconnected peer.
      */
     handlePeerDisconnection(peerIP) {
-        // Mark the peer in cooldown
-        this.cooldownCache.set(peerIP, true);
+        // Add the faulty peer to the cooldown cache
+        FullNodePeer.cooldownCache.set(peerIP, true);
         // Decrease weight or remove peer
-        const currentWeight = this.peerWeights.get(peerIP) || 1;
+        const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
         if (currentWeight > 1) {
-            this.peerWeights.set(peerIP, currentWeight - 1);
+            FullNodePeer.peerWeights.set(peerIP, currentWeight - 1);
         }
         else {
-            this.peerWeights.delete(peerIP);
-        }
-        // Update the peer's connection status
-        const peerInfo = this.peerInfos.get(peerIP);
-        if (peerInfo) {
-            peerInfo.isConnected = false;
-            this.peerInfos.set(peerIP, peerInfo);
-        }
-        // Remove from availablePeers if present
-        const index = this.availablePeers.indexOf(peerIP);
-        if (index !== -1) {
-            this.availablePeers.splice(index, 1);
-            // Adjust currentPeerIndex if necessary
-            if (this.currentPeerIndex >= this.availablePeers.length) {
-                this.currentPeerIndex = 0;
-            }
-        }
-        // If the disconnected peer was the cached peer, invalidate the cache
-        if (this.cachedPeer &&
-            this.extractPeerIP(this.cachedPeer.peer) === peerIP) {
-            this.cachedPeer = null;
+            FullNodePeer.peerWeights.delete(peerIP);
         }
+        // Remove from peerInfos
+        FullNodePeer.peerInfos.delete(peerIP);
+        // Remove the limiter
+        FullNodePeer.peerLimiters.delete(peerIP);
         console.warn(`Peer ${peerIP} has been marked as disconnected and is in cooldown.`);
     }
     /**
@@ -488,8 +355,8 @@ class FullNodePeer {
      * @param {Peer} peer - The Peer instance.
      * @returns {string | null} The extracted IP address or null if not found.
      */
-    extractPeerIP(peer) {
-        for (const [ip, info] of this.peerInfos.entries()) {
+    static extractPeerIP(peer) {
+        for (const [ip, info] of FullNodePeer.peerInfos.entries()) {
             if (info.peer === peer) {
                 return ip;
             }
@@ -512,14 +379,27 @@ class FullNodePeer {
             console.error(`waitForConfirmation connection error: ${error.message}`);
             throw error;
         }
+        // Extract peer IP to access the corresponding limiter
+        const peerIP = FullNodePeer.extractPeerIP(peer);
+        if (!peerIP) {
+            spinner.error({ text: "Failed to extract peer IP." });
+            throw new Error("Failed to extract peer IP.");
+        }
+        const limiter = FullNodePeer.peerLimiters.get(peerIP);
+        if (!limiter) {
+            spinner.error({ text: "No rate limiter found for the peer." });
+            throw new Error("No rate limiter found for the peer.");
+        }
         try {
             while (true) {
-                const confirmed = await peer.isCoinSpent(parentCoinInfo, config_1.MIN_HEIGHT, Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex"));
+                // Schedule the isCoinSpent method call through the limiter
+                const confirmed = await limiter.schedule(() => peer.isCoinSpent(parentCoinInfo, config_1.MIN_HEIGHT, Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex")));
                 if (confirmed) {
                     spinner.success({ text: "Coin confirmed!" });
                     return true;
                 }
-                await FullNodePeer.delay(5000);
+                // Wait for 5 seconds before the next check
+                await new Promise((resolve) => setTimeout(resolve, 5000));
             }
         }
         catch (error) {
@@ -528,15 +408,21 @@ 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
 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 });
+// Map to store rate limiters per peer IP
+FullNodePeer.peerLimiters = new Map();

package/dist/utils/PeerRanker.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Interface representing the metrics of a peer.
+ */
+export interface PeerMetrics {
+    ip: string;
+    latency: number;
+    bandwidth: number;
+}
+/**
+ * Configuration options for the PeerRanker.
+ */
+interface PeerRankerOptions {
+    clientCertPath: string;
+    clientKeyPath: string;
+    bandwidthTestPath: string;
+    pingPath?: string;
+    timeout?: number;
+    bandwidthTestSize?: number;
+}
+/**
+ * Utility class to rank peers based on latency and bandwidth using HTTPS with mTLS.
+ */
+export declare class PeerRanker {
+    private ipAddresses;
+    private static certPath;
+    private static keyPath;
+    private bandwidthTestPath;
+    private pingPath;
+    private timeout;
+    private bandwidthTestSize;
+    private sortedPeers;
+    private currentIndex;
+    /**
+     * Constructs a PeerRanker instance.
+     * @param ipAddresses - Array of IP addresses to rank.
+     * @param options - Configuration options including paths to client certificates.
+     */
+    constructor(ipAddresses: string[], options: PeerRankerOptions);
+    /**
+     * Measures the latency of a given IP address using an HTTPS request.
+     * Tries HEAD first, then falls back to GET if HEAD is not supported.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the latency in milliseconds.
+     */
+    private measureLatency;
+    /**
+     * Measures the bandwidth of a given IP address by downloading a file and calculating throughput.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the bandwidth in bytes per second.
+     */
+    private measureBandwidth;
+    /**
+     * Ranks the peers based on measured latency and bandwidth.
+     * @returns Promise resolving to an array of PeerMetrics sorted by latency and bandwidth.
+     */
+    rankPeers(): Promise<PeerMetrics[]>;
+    /**
+     * Returns the next best peer based on the ranking.
+     * Cycles through the list, resetting to the beginning once the end is reached.
+     * @returns The next PeerMetrics object or null if no peers are available.
+     */
+    GetNextBestPeer(): PeerMetrics | null;
+    /**
+     * Resets the internal iterator to start from the beginning of the sorted list.
+     */
+    resetIterator(): void;
+}
+export {};
+//# sourceMappingURL=PeerRanker.d.ts.map

package/dist/utils/PeerRanker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeerRanker.d.ts","sourceRoot":"","sources":["../../src/utils/PeerRanker.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,UAAU,iBAAiB;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,iBAAiB,CAAS;IAGlC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAa;IAEjC;;;;OAIG;gBACS,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,iBAAiB;IAY7D;;;;;OAKG;YACW,cAAc;IA8C5B;;;;OAIG;YACW,gBAAgB;IA2C9B;;;OAGG;IACU,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IA4BhD;;;;OAIG;IACI,eAAe,IAAI,WAAW,GAAG,IAAI;IAW5C;;OAEG;IACI,aAAa,IAAI,IAAI;CAG7B"}

package/dist/utils/PeerRanker.js

@@ -0,0 +1,173 @@
+"use strict";
+// src/PeerRanker.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerRanker = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const ssl_1 = require("./ssl");
+/**
+ * Utility class to rank peers based on latency and bandwidth using HTTPS with mTLS.
+ */
+class PeerRanker {
+    /**
+     * Constructs a PeerRanker instance.
+     * @param ipAddresses - Array of IP addresses to rank.
+     * @param options - Configuration options including paths to client certificates.
+     */
+    constructor(ipAddresses, options) {
+        // Internal properties for iteration
+        this.sortedPeers = [];
+        this.currentIndex = 0;
+        this.ipAddresses = ipAddresses;
+        this.bandwidthTestPath = options.bandwidthTestPath;
+        this.pingPath = options.pingPath || '/'; // Default to root path if not provided
+        this.timeout = options.timeout || 5000; // Default timeout: 5 seconds
+        this.bandwidthTestSize = options.bandwidthTestSize || 1024 * 1024; // Default: 1MB
+        const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+        PeerRanker.certPath = certPath;
+        PeerRanker.keyPath = keyPath;
+    }
+    /**
+     * Measures the latency of a given IP address using an HTTPS request.
+     * Tries HEAD first, then falls back to GET if HEAD is not supported.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the latency in milliseconds.
+     */
+    async measureLatency(ip) {
+        const path = this.pingPath;
+        const url = `https://${ip}${path}`;
+        // Configuration for HEAD request
+        const configHead = {
+            url: url,
+            method: 'HEAD',
+            httpsAgent: new https_1.default.Agent({
+                cert: fs_1.default.readFileSync(PeerRanker.certPath),
+                key: fs_1.default.readFileSync(PeerRanker.keyPath),
+                rejectUnauthorized: false, // Set to true in production
+            }),
+            timeout: this.timeout,
+            validateStatus: (status) => status < 500, // Resolve only if status is less than 500
+        };
+        const startTime = Date.now();
+        try {
+            const response = await (0, axios_1.default)(configHead);
+            if (response.status === 405) { // Method Not Allowed
+                // Fallback to GET with Range header to minimize data transfer
+                const configGet = {
+                    url: url,
+                    method: 'GET',
+                    httpsAgent: new https_1.default.Agent({
+                        cert: fs_1.default.readFileSync(PeerRanker.certPath),
+                        key: fs_1.default.readFileSync(PeerRanker.keyPath),
+                        rejectUnauthorized: false, // Set to true in production
+                    }),
+                    timeout: this.timeout,
+                    headers: {
+                        'Range': 'bytes=0-0', // Request only the first byte
+                    },
+                    validateStatus: (status) => status < 500,
+                };
+                await (0, axios_1.default)(configGet);
+            }
+            const latency = Date.now() - startTime;
+            return latency;
+        }
+        catch (error) {
+            console.error(`Latency measurement failed for IP ${ip}:`, error.message);
+            return Infinity; // Indicate unreachable or unresponsive peer
+        }
+    }
+    /**
+     * Measures the bandwidth of a given IP address by downloading a file and calculating throughput.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the bandwidth in bytes per second.
+     */
+    async measureBandwidth(ip) {
+        const url = `https://${ip}${this.bandwidthTestPath}`;
+        const config = {
+            url: url,
+            method: 'GET',
+            responseType: 'stream',
+            httpsAgent: new https_1.default.Agent({
+                cert: fs_1.default.readFileSync(PeerRanker.certPath),
+                key: fs_1.default.readFileSync(PeerRanker.keyPath),
+                rejectUnauthorized: false, // Set to true in production
+            }),
+            timeout: this.timeout,
+        };
+        return new Promise((resolve) => {
+            const startTime = Date.now();
+            let bytesReceived = 0;
+            (0, axios_1.default)(config)
+                .then((response) => {
+                response.data.on('data', (chunk) => {
+                    bytesReceived += chunk.length;
+                });
+                response.data.on('end', () => {
+                    const timeElapsed = (Date.now() - startTime) / 1000; // seconds
+                    const bandwidth = bytesReceived / timeElapsed; // bytes per second
+                    resolve(bandwidth);
+                });
+                response.data.on('error', (err) => {
+                    console.error(`Bandwidth measurement error for IP ${ip}:`, err.message);
+                    resolve(0); // Indicate failure in measuring bandwidth
+                });
+            })
+                .catch((error) => {
+                console.error(`Bandwidth measurement failed for IP ${ip}:`, error.message);
+                resolve(0); // Indicate failure in measuring bandwidth
+            });
+        });
+    }
+    /**
+     * Ranks the peers based on measured latency and bandwidth.
+     * @returns Promise resolving to an array of PeerMetrics sorted by latency and bandwidth.
+     */
+    async rankPeers() {
+        const metricsPromises = this.ipAddresses.map(async (ip) => {
+            const [latency, bandwidth] = await Promise.all([
+                this.measureLatency(ip),
+                this.measureBandwidth(ip),
+            ]);
+            return { ip, latency, bandwidth };
+        });
+        const peerMetrics = await Promise.all(metricsPromises);
+        // Sort by lowest latency first, then by highest bandwidth
+        peerMetrics.sort((a, b) => {
+            if (a.latency === b.latency) {
+                return b.bandwidth - a.bandwidth; // Higher bandwidth is better
+            }
+            return a.latency - b.latency; // Lower latency is better
+        });
+        // Update the internal sorted list
+        this.sortedPeers = peerMetrics;
+        // Reset the iterator index
+        this.currentIndex = 0;
+        return peerMetrics;
+    }
+    /**
+     * Returns the next best peer based on the ranking.
+     * Cycles through the list, resetting to the beginning once the end is reached.
+     * @returns The next PeerMetrics object or null if no peers are available.
+     */
+    GetNextBestPeer() {
+        if (this.sortedPeers.length === 0) {
+            console.warn('Peer list is empty. Please run rankPeers() first.');
+            return null;
+        }
+        const peer = this.sortedPeers[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % this.sortedPeers.length;
+        return peer;
+    }
+    /**
+     * Resets the internal iterator to start from the beginning of the sorted list.
+     */
+    resetIterator() {
+        this.currentIndex = 0;
+    }
+}
+exports.PeerRanker = PeerRanker;

package/package.json

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