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

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 };
 };
@@ -7,91 +8,263 @@ exports.FullNodePeer = void 0;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
-const datalayer_driver_1 = require("datalayer-driver");
-const chia_server_coin_1 = require("chia-server-coin");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const promises_1 = require("dns/promises");
 const net_1 = __importDefault(require("net"));
-const lodash_1 = require("lodash");
 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 defining configuration parameters.
+ */
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
+const CHIA_NODES_HOST = "chia-nodes";
 const DNS_HOSTS = [
     "dns-introducer.chia.net",
     "chia.ctrlaltdel.ch",
     "seeder.dexie.space",
     "chia.hoffmang.com",
 ];
-const CONNECTION_TIMEOUT = 2000;
-const CACHE_DURATION = 30000; // Cache duration in milliseconds
+const CONNECTION_TIMEOUT = 2000; // in milliseconds
+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 {
-    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.
+     * @returns {FullNodePeer} The singleton instance.
+     */
+    static getInstance() {
+        if (!FullNodePeer.instance) {
+            FullNodePeer.instance = new FullNodePeer();
+        }
+        return FullNodePeer.instance;
     }
+    /**
+     * Initializes the singleton instance by connecting to the best peer.
+     */
+    async initialize() {
+        if (this.cachedPeer)
+            return; // Already initialized
+        try {
+            const bestPeer = await this.getBestPeer();
+            this.cachedPeer = { peer: bestPeer, timestamp: Date.now() };
+        }
+        catch (error) {
+            console.error(`Initialization failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Connects and returns the best available peer.
+     * Implements singleton behavior.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
     static async connect() {
-        const peer = await FullNodePeer.getBestPeer();
-        return new FullNodePeer(peer).peer;
+        const instance = FullNodePeer.getInstance();
+        await instance.initialize();
+        return instance.cachedPeer.peer;
     }
-    static isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
+    /**
+     * Checks if a given port on a host is reachable.
+     * @param {string} host - The host IP address.
+     * @param {number} port - The port number.
+     * @param {number} timeout - Connection timeout in milliseconds.
+     * @returns {Promise<boolean>} Whether the port is reachable.
+     */
+    isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
         return new Promise((resolve) => {
             const socket = new net_1.default.Socket()
                 .setTimeout(timeout)
-                .once("error", () => resolve(false))
-                .once("timeout", () => resolve(false))
+                .once("error", () => {
+                socket.destroy();
+                resolve(false);
+            })
+                .once("timeout", () => {
+                socket.destroy();
+                resolve(false);
+            })
                 .connect(port, host, () => {
                 socket.end();
                 resolve(true);
             });
         });
     }
-    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]?)\.(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]?)$/;
+    /**
+     * Validates an IPv4 address.
+     * @param {string} ip - The IP address to validate.
+     * @returns {boolean} Whether the IP address is valid.
+     */
+    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);
     }
     /**
-     * Retrieves the TRUSTED_FULLNODE IP from the environment
-     * and verifies if it is a valid IP address.
-     *
-     * @returns {string | null} The valid IP address or null if invalid
+     * 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() {
-        const trustedNodeIp = process.env.TRUSTED_FULLNODE || null;
-        if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
+    getTrustedFullNode() {
+        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
+        if (trustedNodeIp && this.isValidIpAddress(trustedNodeIp)) {
             return trustedNodeIp;
         }
         return null;
     }
-    static async fetchNewPeerIPs() {
-        const trustedNodeIp = FullNodePeer.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.
+     */
+    async fetchNewPeerIPs() {
+        const trustedNodeIp = this.getTrustedFullNode();
         const priorityIps = [];
+        // Define prioritized peers
+        this.prioritizedPeers = [CHIA_NODES_HOST, LOCALHOST];
+        // Add trustedNodeIp if available
+        if (trustedNodeIp) {
+            this.prioritizedPeers.unshift(trustedNodeIp);
+        }
         // Prioritize trustedNodeIp
         if (trustedNodeIp &&
-            (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
+            !this.cooldownCache.has(trustedNodeIp) &&
+            (await this.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
         // Prioritize LOCALHOST
-        if (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 (!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 = this.peerIPCache.get("peerIPs");
+        if (cachedPeerIPs) {
+            return cachedPeerIPs;
+        }
         // Fetch peers from DNS introducers
+        const fetchedPeers = [];
         for (const DNS_HOST of DNS_HOSTS) {
             try {
                 const ips = await (0, promises_1.resolve4)(DNS_HOST);
                 if (ips && ips.length > 0) {
-                    const shuffledIps = ips.sort(() => 0.5 - Math.random());
+                    const shuffledIps = this.shuffleArray(ips);
                     const reachableIps = [];
                     for (const ip of shuffledIps) {
-                        if (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT)) {
+                        if (!this.cooldownCache.has(ip) &&
+                            (await this.isPortReachable(ip, FULLNODE_PORT))) {
                             reachableIps.push(ip);
                         }
-                        if (reachableIps.length === 5)
-                            break;
+                        if (reachableIps.length === MAX_PEERS_TO_FETCH)
+                            break; // Limit to MAX_PEERS_TO_FETCH peers
                     }
                     if (reachableIps.length > 0) {
-                        return reachableIps;
+                        fetchedPeers.push(...reachableIps);
                     }
                 }
             }
@@ -99,131 +272,246 @@ class FullNodePeer {
                 console.error(`Failed to resolve IPs from ${DNS_HOST}: ${error.message}`);
             }
         }
+        // Cache the fetched peer IPs
+        if (fetchedPeers.length > 0) {
+            this.peerIPCache.set("peerIPs", fetchedPeers);
+            return fetchedPeers;
+        }
         throw new Error("No reachable IPs found in any DNS records.");
     }
-    static async getPeerIPs() {
-        const ips = await FullNodePeer.memoizedFetchNewPeerIPs();
-        const reachableIps = await Promise.all(ips.map(async (ip) => {
-            if (ip && (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT))) {
-                return ip;
-            }
-            return null;
-        })).then((results) => results.filter((ip) => ip !== null));
-        if (reachableIps.length > 0) {
-            return reachableIps;
-        }
-        // @ts-ignore
-        if (FullNodePeer.memoizedFetchNewPeerIPs?.cache?.clear) {
-            // @ts-ignore
-            FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
-        }
-        return FullNodePeer.memoizedFetchNewPeerIPs();
-    }
-    static createPeerProxy(peer) {
-        return new Proxy(peer, {
-            get: (target, prop) => {
-                const originalMethod = target[prop];
-                if (typeof originalMethod === "function") {
-                    return async (...args) => {
-                        let timeoutId;
-                        // Start the timeout to forget the peer after 1 minute
-                        const timeoutPromise = new Promise((_, reject) => {
-                            timeoutId = setTimeout(() => {
-                                FullNodePeer.cachedPeer = null;
-                                reject(new Error("Operation timed out. Reconnecting to a new peer."));
-                            }, 60000); // 1 minute
-                        });
-                        try {
-                            // Run the original method and race it against the timeout
-                            const result = await Promise.race([
-                                originalMethod.apply(target, args),
-                                timeoutPromise,
-                            ]);
-                            // Clear the timeout if the operation succeeded
-                            if (timeoutId) {
-                                clearTimeout(timeoutId);
-                            }
-                            return result;
-                        }
-                        catch (error) {
-                            // If the error is WebSocket-related or timeout, reset the peer
-                            if (error.message.includes("WebSocket") || error.message.includes("Operation timed out")) {
-                                FullNodePeer.cachedPeer = null;
-                                // @ts-ignore
-                                FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
-                                const newPeer = await FullNodePeer.getBestPeer();
-                                return newPeer[prop](...args);
-                            }
-                            throw error;
-                        }
-                    };
+    /**
+     * Shuffles an array using the Fisher-Yates algorithm.
+     * @param {T[]} array - The array to shuffle.
+     * @returns {T[]} The shuffled array.
+     */
+    shuffleArray(array) {
+        const shuffled = [...array];
+        for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled;
+    }
+    /**
+     * Initializes the peer weights map.
+     * Assigns higher initial weights to prioritized peers.
+     * @param {string[]} peerIPs - An array of peer IPs.
+     */
+    initializePeerWeights(peerIPs) {
+        for (const ip of peerIPs) {
+            if (!this.peerWeights.has(ip)) {
+                if (ip === CHIA_NODES_HOST ||
+                    ip === LOCALHOST ||
+                    ip === this.getTrustedFullNode()) {
+                    this.peerWeights.set(ip, 5); // Higher weight for prioritized peers
                 }
-                return originalMethod;
-            },
-        });
+                else {
+                    this.peerWeights.set(ip, 1); // Default weight
+                }
+            }
+        }
     }
-    static async getBestPeer() {
+    /**
+     * Selects the next peer based on round-robin selection.
+     * @returns {Promise<Peer>} The selected Peer instance.
+     */
+    async selectNextPeer() {
+        if (this.availablePeers.length === 0) {
+            throw new Error("No available peers to select.");
+        }
+        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.
+     */
+    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.
+     */
+    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.
+     */
+    async getBestPeer() {
         const now = Date.now();
-        if (FullNodePeer.cachedPeer &&
-            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
-            return FullNodePeer.cachedPeer.peer;
-        }
-        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 });
-        }
-        new chia_server_coin_1.Tls(certFile, keyFile);
-        const peerIPs = await FullNodePeer.getPeerIPs();
-        const trustedNodeIp = process.env.TRUSTED_FULLNODE || null;
-        const peers = await Promise.all(peerIPs.map(async (ip) => {
-            if (ip) {
+        // 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;
+        }
+        // Fetch peer IPs
+        const peerIPs = await this.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 {
-                    const peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, certFile, keyFile);
-                    return FullNodePeer.createPeerProxy(peer);
+                    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}`);
-                    return null;
+                    // 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);
+            }
+            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);
+                }
+            }
+        }
+        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();
+        // Cache the peer
+        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.
+     */
+    handlePeerDisconnection(peerIP) {
+        // Mark the peer in cooldown
+        this.cooldownCache.set(peerIP, true);
+        // Decrease weight or remove peer
+        const currentWeight = this.peerWeights.get(peerIP) || 1;
+        if (currentWeight > 1) {
+            this.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;
+        }
+        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.
+     * @returns {string | null} The extracted IP address or null if not found.
+     */
+    extractPeerIP(peer) {
+        for (const [ip, info] of this.peerInfos.entries()) {
+            if (info.peer === peer) {
+                return ip;
             }
-            return null;
-        })).then((results) => results.filter((peer) => peer !== null));
-        if (peers.length === 0) {
-            throw new Error("No peers available, please try again.");
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const peakHeights = await Promise.all(peers.map((peer) => peer
-            .getPeak()
-            .then((height) => height)
-            .catch((error) => {
-            console.error(`Failed to get peak for peer: ${error.message}`);
-            return null;
-        })));
-        const validHeights = peakHeights.filter((height) => height !== null);
-        if (validHeights.length === 0) {
-            throw new Error("No valid peak heights obtained from any peer.");
-        }
-        const highestPeak = Math.max(...validHeights);
-        // Prioritize LOCALHOST and TRUSTED_NODE_IP if they have the highest peak height
-        let bestPeerIndex = validHeights.findIndex((height, index) => height === highestPeak &&
-            (peerIPs[index] === LOCALHOST || peerIPs[index] === trustedNodeIp));
-        // If LOCALHOST or TRUSTED_NODE_IP don't have the highest peak, select any peer with the highest peak
-        if (bestPeerIndex === -1) {
-            bestPeerIndex = validHeights.findIndex((height) => height === highestPeak);
-        }
-        const bestPeer = peers[bestPeerIndex];
-        FullNodePeer.cachedPeer = { peer: bestPeer, timestamp: now };
-        console.log(`Using Peer: ${peerIPs[bestPeerIndex]}`);
-        return bestPeer;
-    }
-    getPeer() {
-        return this.peer;
+        }
+        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.
+     */
     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"));
@@ -231,17 +519,24 @@ class FullNodePeer {
                     spinner.success({ text: "Coin confirmed!" });
                     return true;
                 }
-                await new Promise((resolve) => setTimeout(resolve, 5000));
+                await FullNodePeer.delay(5000);
             }
         }
         catch (error) {
             spinner.error({ text: "Error while waiting for confirmation." });
+            console.error(`waitForConfirmation error: ${error.message}`);
             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;
-FullNodePeer.cachedPeer = null;
-(() => {
-    FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
-})();
+// Singleton instance
+FullNodePeer.instance = null;