@dignetwork/dig-sdk 0.0.1-alpha.19 → 0.0.1-alpha.191

package/dist/blockchain/FullNodePeer.js

@@ -7,13 +7,14 @@ 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"));
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
 const DNS_HOSTS = [
@@ -22,104 +23,312 @@ const DNS_HOSTS = [
     "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 = 600000; // 10 minutes in milliseconds
+const MAX_PEERS_TO_FETCH = 5; // Maximum number of peers to fetch from DNS
+const MAX_REQUESTS_PER_MINUTE = 100; // Per-peer rate limit
+/**
+ * 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 this.getBestPeer();
+            this.peer = bestPeer;
+            FullNodePeer.instance = this; // Assign the initialized instance
+        }
+        catch (error) {
+            console.error(`Fullnode 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();
+        // Remove cached peer to ensure a new connection each time
+        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 = [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);
         }
         if (priorityIps.length > 0) {
             return priorityIps;
         }
+        // Check if cached peer IPs exist
+        const cachedPeerIPs = await FullNodePeer.peerIPCache.get("peerIPs");
+        if (cachedPeerIPs) {
+            return cachedPeerIPs;
+        }
         // Fetch peers from DNS introducers
+        const fetchedPeers = [];
         for (const DNS_HOST of DNS_HOSTS) {
+            // Check if DNS_HOST is in failedDNSCache
+            if (await FullNodePeer.failedDNSCache.has(DNS_HOST)) {
+                continue;
+            }
             try {
-                const ips = await (0, promises_1.resolve4)(DNS_HOST);
-                if (ips && ips.length > 0) {
-                    const shuffledIps = ips.sort(() => 0.5 - Math.random());
+                let ips = [];
+                // Check if DNS_HOST's IPs are cached
+                if (await FullNodePeer.dnsCache.has(DNS_HOST)) {
+                    ips = (await FullNodePeer.dnsCache.get(DNS_HOST)) || [];
+                }
+                else {
+                    // Resolve DNS_HOST and cache the results
+                    ips = await (0, promises_1.resolve4)(DNS_HOST);
+                    if (ips && ips.length > 0) {
+                        FullNodePeer.dnsCache.set(DNS_HOST, ips);
+                    }
+                }
+                if (ips.length > 0) {
+                    const shuffledIps = FullNodePeer.shuffleArray(ips);
                     const reachableIps = [];
                     for (const ip of shuffledIps) {
-                        if (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT)) {
+                        if (!FullNodePeer.cooldownCache.has(ip) &&
+                            FullNodePeer.isValidIpAddress(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);
                     }
                 }
             }
             catch (error) {
                 console.error(`Failed to resolve IPs from ${DNS_HOST}: ${error.message}`);
+                // Add DNS_HOST to failedDNSCache for cooldown
+                FullNodePeer.failedDNSCache.set(DNS_HOST, true);
             }
         }
+        // Cache the fetched peer IPs if any
+        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 === LOCALHOST || ip === FullNodePeer.getTrustedFullNode()) {
+                    FullNodePeer.peerWeights.set(ip, 5); // Higher weight for prioritized peers
+                }
+                else {
+                    FullNodePeer.peerWeights.set(ip, 1); // Default weight
+                }
             }
-            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();
+    }
+    /**
+     * Selects the next peer based on round-robin selection.
+     * @returns {string} The selected peer IP.
+     */
+    static selectPeerRoundRobin() {
+        const availablePrioritizedPeers = FullNodePeer.prioritizedPeers.filter((ip) => !FullNodePeer.cooldownCache.has(ip) && FullNodePeer.peerWeights.has(ip));
+        if (availablePrioritizedPeers.length > 0) {
+            // Select the first available prioritized peer
+            return availablePrioritizedPeers[0];
+        }
+        // If no prioritized peers are available, proceed with round-robin among other peers
+        const regularPeers = Array.from(FullNodePeer.peerWeights.keys()).filter((ip) => !FullNodePeer.prioritizedPeers.includes(ip) &&
+            !FullNodePeer.cooldownCache.has(ip));
+        if (regularPeers.length === 0) {
+            throw new Error("No available peers to connect.");
+        }
+        const selectedPeer = regularPeers[FullNodePeer.roundRobinIndex % regularPeers.length];
+        FullNodePeer.roundRobinIndex += 1;
+        return selectedPeer;
+    }
+    /**
+     * 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 round-robin selection and reliability.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
+    async getBestPeer() {
+        const now = Date.now();
+        // Removed cachedPeer logic to ensure a new connection each time
+        // Fetch peer IPs
+        const peerIPs = await FullNodePeer.getPeerIPs();
+        // Setup peer weights with prioritization
+        FullNodePeer.setupPeers(peerIPs);
+        // Round-robin selection
+        let selectedPeerIP;
+        try {
+            selectedPeerIP = FullNodePeer.selectPeerRoundRobin();
+        }
+        catch (error) {
+            throw new Error(`Failed to select a fullnode 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 fullnode 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 fullnode peer ${selectedPeerIP}`);
+        }
+        // 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);
+        const proxiedPeer = this.createPeerProxy(peer, selectedPeerIP);
+        console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
+        return proxiedPeer;
     }
-    static createPeerProxy(peer) {
+    createPeerProxy(peer, peerIP) {
         return new Proxy(peer, {
             get: (target, prop) => {
                 const originalMethod = target[prop];
@@ -129,8 +338,7 @@ class FullNodePeer {
                         // 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."));
+                                reject(new Error("Operation timed out. Reconnecting to a new fullnode peer."));
                             }, 60000); // 1 minute
                         });
                         try {
@@ -146,12 +354,11 @@ class FullNodePeer {
                             return result;
                         }
                         catch (error) {
+                            FullNodePeer.handlePeerDisconnection(peerIP);
                             // 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();
+                            if (error.message.includes("WebSocket") ||
+                                error.message.includes("Operation timed out")) {
+                                const newPeer = await this.getBestPeer();
                                 return newPeer[prop](...args);
                             }
                             throw error;
@@ -162,86 +369,89 @@ class FullNodePeer {
             },
         });
     }
-    static async getBestPeer() {
-        const now = Date.now();
-        if (FullNodePeer.cachedPeer &&
-            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
-            return FullNodePeer.cachedPeer.peer;
+    /**
+     * Handles peer disconnection by marking it in cooldown and updating internal states.
+     * @param {string} peerIP - The IP address of the disconnected peer.
+     */
+    static handlePeerDisconnection(peerIP) {
+        // 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);
         }
-        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 });
+        else {
+            FullNodePeer.peerWeights.delete(peerIP);
         }
-        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;
-                }
+        // Remove from peerInfos
+        FullNodePeer.peerInfos.delete(peerIP);
+        // Remove the limiter
+        FullNodePeer.peerLimiters.delete(peerIP);
+    }
+    /**
+     * 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();
-        try {
-            while (true) {
-                const confirmed = await 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;
+        while (true) {
+            try {
+                await peer.waitForCoinToBeSpent(parentCoinInfo, config_1.MIN_HEIGHT, Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex"));
+                spinner.success({ text: "Coin confirmed!" });
+                return true;
+            }
+            catch (error) {
+                if (error.message.includes("UnknownCoin")) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                else {
+                    spinner.error({ text: "Error while waiting for confirmation." });
+                    console.error(`waitForConfirmation error: ${error.message}`);
+                    throw error;
                 }
-                await new Promise((resolve) => setTimeout(resolve, 5000));
             }
         }
-        catch (error) {
-            spinner.error({ text: "Error while waiting for confirmation." });
-            throw error;
-        }
     }
 }
 exports.FullNodePeer = FullNodePeer;
-FullNodePeer.cachedPeer = null;
-(() => {
-    FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
-})();
+// Singleton instance
+FullNodePeer.instance = null;
+// Cooldown cache to exclude faulty peers temporarily
+FullNodePeer.cooldownCache = new node_cache_1.default({
+    stdTTL: COOLDOWN_DURATION / 1000,
+});
+// Failed DNS hosts cooldown cache
+FullNodePeer.failedDNSCache = new node_cache_1.default({ stdTTL: 86400 });
+// 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 });
+// Cache for DNS_HOST resolved IPs with a TTL of 3 days (259200 seconds)
+FullNodePeer.dnsCache = new node_cache_1.default({
+    stdTTL: 259200,
+    checkperiod: 3600,
+});
+// Map to store rate limiters per peer IP
+FullNodePeer.peerLimiters = new Map();
+// Round-robin index
+FullNodePeer.roundRobinIndex = 0;

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;AAWrD,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"}