@dignetwork/dig-sdk 0.0.1-alpha.13 → 0.0.1-alpha.130

package/dist/blockchain/FullNodePeer.js

@@ -7,91 +7,176 @@ 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"));
+// Constants
 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 = 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
+/**
+ * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
+ */
 class FullNodePeer {
+    // Private constructor for singleton pattern
     constructor(peer) {
         this.peer = peer;
     }
+    /**
+     * Retrieves the singleton instance of FullNodePeer.
+     * @returns {FullNodePeer} The singleton instance.
+     */
+    static getInstance() {
+        if (!FullNodePeer.instance) {
+            FullNodePeer.instance = new FullNodePeer(null); // Temporarily set to null
+        }
+        return FullNodePeer.instance;
+    }
+    /**
+     * Initializes the singleton instance by connecting to the best peer.
+     */
+    async initialize() {
+        if (this.peer)
+            return; // Already initialized
+        try {
+            const bestPeer = await FullNodePeer.getBestPeer();
+            this.peer = bestPeer;
+            FullNodePeer.instance = this; // Assign the initialized instance
+        }
+        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.peer;
     }
+    /**
+     * 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.
+     */
     static 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);
             });
         });
     }
+    /**
+     * Validates an IPv4 address.
+     * @param {string} ip - The IP address to validate.
+     * @returns {boolean} Whether the IP address is valid.
+     */
     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]?)$/;
+        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;
+        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
         if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
             return trustedNodeIp;
         }
         return null;
     }
+    /**
+     * 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.
+     */
     static async fetchNewPeerIPs() {
         const trustedNodeIp = FullNodePeer.getTrustedFullNode();
         const priorityIps = [];
+        // Define prioritized peers
+        FullNodePeer.prioritizedPeers = [
+            ...DNS_HOSTS, // Assuming CHIA_NODES_HOST is included in DNS_HOSTS
+            LOCALHOST,
+        ];
+        // Add trustedNodeIp if available
+        if (trustedNodeIp) {
+            FullNodePeer.prioritizedPeers.unshift(trustedNodeIp);
+        }
         // Prioritize trustedNodeIp
         if (trustedNodeIp &&
+            !FullNodePeer.cooldownCache.has(trustedNodeIp) &&
             (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
         // Prioritize LOCALHOST
-        if (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT)) {
+        if (!FullNodePeer.cooldownCache.has(LOCALHOST) &&
+            (await FullNodePeer.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))) {
+            priorityIps.push(CHIA_NODES_HOST);
+        }
         if (priorityIps.length > 0) {
             return priorityIps;
         }
+        // Check if cached peer IPs exist
+        const cachedPeerIPs = FullNodePeer.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 = FullNodePeer.shuffleArray(ips);
                     const reachableIps = [];
                     for (const ip of shuffledIps) {
-                        if (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT)) {
+                        if (!FullNodePeer.cooldownCache.has(ip) &&
+                            (await FullNodePeer.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,62 +184,209 @@ class FullNodePeer {
                 console.error(`Failed to resolve IPs from ${DNS_HOST}: ${error.message}`);
             }
         }
+        // Cache the fetched peer IPs
+        if (fetchedPeers.length > 0) {
+            FullNodePeer.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;
+    /**
+     * Shuffles an array using the Fisher-Yates algorithm.
+     * @param {T[]} array - The array to shuffle.
+     * @returns {T[]} The shuffled array.
+     */
+    static 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.
+     */
+    static initializePeerWeights(peerIPs) {
+        for (const ip of peerIPs) {
+            if (!FullNodePeer.peerWeights.has(ip)) {
+                if (ip === CHIA_NODES_HOST ||
+                    ip === LOCALHOST ||
+                    ip === FullNodePeer.getTrustedFullNode()) {
+                    FullNodePeer.peerWeights.set(ip, 5); // Higher weight for prioritized peers
+                }
+                else {
+                    FullNodePeer.peerWeights.set(ip, 1); // Default weight
+                }
+            }
+        }
+    }
+    /**
+     * Selects a peer based on weighted random selection.
+     * Prioritized peers have higher weights.
+     * @returns {string} The selected peer IP.
+     */
+    static selectPeerByWeight() {
+        const peers = Array.from(FullNodePeer.peerWeights.entries())
+            .filter(([ip, _]) => !FullNodePeer.cooldownCache.has(ip))
+            .map(([ip, weight]) => ({ ip, weight }));
+        const totalWeight = peers.reduce((sum, peer) => sum + peer.weight, 0);
+        if (totalWeight === 0) {
+            throw new Error("All peers are in cooldown.");
+        }
+        const random = Math.random() * totalWeight;
+        let cumulative = 0;
+        for (const peer of peers) {
+            cumulative += peer.weight;
+            if (random < cumulative) {
+                return peer.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();
+        // 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.
+     */
+    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.
+     */
+    static setupPeers(peerIPs) {
+        FullNodePeer.initializePeerWeights(peerIPs);
+    }
+    /**
+     * Connects to the best available peer based on weighted selection and reliability.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
+    static async getBestPeer() {
+        const now = Date.now();
+        // Refresh cachedPeer if expired
+        if (FullNodePeer.cachedPeer &&
+            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
+            return FullNodePeer.cachedPeer.peer;
+        }
+        // Fetch peer IPs
+        const peerIPs = await FullNodePeer.getPeerIPs();
+        // Setup peer weights with prioritization
+        FullNodePeer.setupPeers(peerIPs);
+        // Weighted random selection
+        let selectedPeerIP;
+        try {
+            selectedPeerIP = FullNodePeer.selectPeerByWeight();
+        }
+        catch (error) {
+            throw new Error(`Failed to select a peer: ${error.message}`);
         }
-        return FullNodePeer.memoizedFetchNewPeerIPs();
+        // 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 {
+                FullNodePeer.peerWeights.delete(selectedPeerIP);
+            }
+            throw new Error(`Unable to connect to peer ${selectedPeerIP}`);
+        }
+        // Wrap the peer with proxy to handle errors and retries
+        const proxiedPeer = FullNodePeer.createPeerProxy(peer, selectedPeerIP);
+        // Store PeerInfo
+        FullNodePeer.peerInfos.set(selectedPeerIP, {
+            peer: proxiedPeer,
+            weight: FullNodePeer.peerWeights.get(selectedPeerIP) || 1,
+            address: selectedPeerIP,
+        });
+        // Cache the peer
+        FullNodePeer.cachedPeer = { peer: proxiedPeer, timestamp: now };
+        console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
+        return proxiedPeer;
     }
-    static createPeerProxy(peer) {
+    /**
+     * Creates a proxy for the peer to handle errors and implement retries.
+     * @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) {
         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);
-                            }
+                            const result = await originalMethod.apply(target, args);
+                            // On successful operation, increase the weight slightly
+                            const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
+                            FullNodePeer.peerWeights.set(peerIP, currentWeight + 0.1); // Increment weight
                             return result;
                         }
                         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);
+                            console.error(`Peer ${peerIP} encountered an error: ${error.message}`);
+                            // Check if the error is related to WebSocket or Operation timed out
+                            if (error.message.includes("WebSocket") ||
+                                error.message.includes("Operation timed out")) {
+                                // Add the faulty peer to the cooldown cache
+                                FullNodePeer.cooldownCache.set(peerIP, true);
+                                // Decrease weight or remove peer
+                                const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
+                                if (currentWeight > 1) {
+                                    FullNodePeer.peerWeights.set(peerIP, currentWeight - 1);
+                                }
+                                else {
+                                    FullNodePeer.peerWeights.delete(peerIP);
+                                }
+                                // If maximum retries reached, throw the error
+                                if (retryCount >= MAX_RETRIES) {
+                                    console.error(`Max retries reached for method ${String(prop)} on peer ${peerIP}.`);
+                                    throw error;
+                                }
+                                // Attempt to select a new peer and retry the method
+                                try {
+                                    console.info(`Selecting a new peer to retry method ${String(prop)}...`);
+                                    const newPeer = await FullNodePeer.getBestPeer();
+                                    // Extract new peer's IP address
+                                    const newPeerIP = FullNodePeer.extractPeerIP(newPeer);
+                                    if (!newPeerIP) {
+                                        throw new Error("Unable to extract IP from the new peer.");
+                                    }
+                                    // Wrap the new peer with a proxy, incrementing the retry count
+                                    const proxiedNewPeer = FullNodePeer.createPeerProxy(newPeer, newPeerIP, retryCount + 1);
+                                    // Retry the method on the new peer
+                                    return await proxiedNewPeer[prop](...args);
+                                }
+                                catch (retryError) {
+                                    console.error(`Retry failed on a new peer: ${retryError.message}`);
+                                    throw retryError;
+                                }
+                            }
+                            else {
+                                // For other errors, handle normally
+                                throw error;
                             }
-                            throw error;
                         }
                     };
                 }
@@ -162,65 +394,24 @@ class FullNodePeer {
             },
         });
     }
-    static 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) {
-                try {
-                    const peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, certFile, keyFile);
-                    return FullNodePeer.createPeerProxy(peer);
-                }
-                catch (error) {
-                    console.error(`Failed to create peer for IP ${ip}: ${error.message}`);
-                    return null;
-                }
+    /**
+     * 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.
+     */
+    static extractPeerIP(peer) {
+        for (const [ip, info] of FullNodePeer.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();
@@ -236,12 +427,23 @@ class FullNodePeer {
         }
         catch (error) {
             spinner.error({ text: "Error while waiting for confirmation." });
+            console.error(`waitForConfirmation error: ${error.message}`);
             throw error;
         }
     }
 }
 exports.FullNodePeer = FullNodePeer;
+// Singleton instance
+FullNodePeer.instance = null;
+// Cached peer with timestamp
 FullNodePeer.cachedPeer = null;
-(() => {
-    FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
-})();
+// 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 });

package/dist/blockchain/ServerCoin.d.ts

@@ -1,21 +1,29 @@
-import { ServerCoin as ServerCoinDriver } from "datalayer-driver";
+import { ServerCoin as ServerCoinDriver } from "@dignetwork/datalayer-driver";
 import { NconfManager } from "../utils/NconfManager";
 export declare class ServerCoin {
     private storeId;
     static readonly serverCoinManager: NconfManager;
     constructor(storeId: string);
-    createForEpoch(peerIp: string): Promise<ServerCoinDriver>;
-    saveServerCoinData(serverCoin: ServerCoinDriver, epoch: number, peerIp: string): Promise<void>;
+    createForEpoch(peerIp: string, rootHash: string): Promise<ServerCoinDriver>;
+    saveServerCoinData(serverCoin: ServerCoinDriver, epoch: number, peerIp: string, rootHash: string): Promise<void>;
     melt(epoch: number, peerIp: string): Promise<void>;
     private removeServerCoinData;
+    getAllEpochPeers(epoch: number, blacklist?: string[]): Promise<string[]>;
+    getActiveEpochPeers(blacklist?: string[]): Promise<string[]>;
     sampleCurrentEpoch(sampleSize?: number, blacklist?: string[]): Promise<string[]>;
     sampleServerCoinsByEpoch(epoch: number, sampleSize?: number, blacklist?: string[]): Promise<string[]>;
-    static getCurrentEpoch(): number;
+    static getCurrentEpoch(): {
+        epoch: number;
+        round: number;
+    };
     ensureServerCoinExists(peerIp: string): Promise<void>;
     meltOutdatedEpochs(peerIp: string): Promise<void>;
     static meltUntrackedStoreCoins(): Promise<void>;
     private getServerCoinsForStore;
     hasEpochCoinBeenCreated(currentEpoch: number, peerIp: string): Promise<boolean>;
-    static calculateEpoch(currentTimestampUTC: Date): number;
+    static calculateEpochAndRound(currentTimestampUTC: Date): {
+        epoch: number;
+        round: number;
+    };
 }
 //# sourceMappingURL=ServerCoin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ServerCoin.d.ts","sourceRoot":"","sources":["../../src/blockchain/ServerCoin.ts"],"names":[],"mappings":"AACA,OAAO,EAML,UAAU,IAAI,gBAAgB,EAE/B,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAMrD,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,gBAAuB,iBAAiB,eAAwC;gBAGpE,OAAO,EAAE,MAAM;IAKd,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA2DzD,kBAAkB,CAC7B,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAqBH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAoDjD,oBAAoB;IAgBrB,kBAAkB,CAC7B,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAMP,wBAAwB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;WAsCN,eAAe,IAAI,MAAM;IAK1B,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDrD,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WA+B1C,uBAAuB;YA4D7B,sBAAsB;IAWvB,uBAAuB,CAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC;WAuBL,cAAc,CAAC,mBAAmB,EAAE,IAAI,GAAG,MAAM;CAiBhE"}
+{"version":3,"file":"ServerCoin.d.ts","sourceRoot":"","sources":["../../src/blockchain/ServerCoin.ts"],"names":[],"mappings":"AACA,OAAO,EAML,UAAU,IAAI,gBAAgB,EAE/B,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAYrD,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,gBAAuB,iBAAiB,eAEtC;gBAEU,OAAO,EAAE,MAAM;IAKd,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA4D3E,kBAAkB,CAC7B,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAsBH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAoDjD,oBAAoB;IAerB,gBAAgB,CAC3B,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAoDP,mBAAmB,CAC9B,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAMP,kBAAkB,CAC7B,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAMP,wBAAwB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;WAeN,eAAe,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAKpD,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiFrD,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WA+B1C,uBAAuB;YAkE7B,sBAAsB;IAWvB,uBAAuB,CAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC;WAuBL,sBAAsB,CAAC,mBAAmB,EAAE,IAAI,GAAG;QAC/D,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf;CA2BF"}