@dignetwork/dig-sdk 0.0.1-alpha.98 → 0.1.0

package/dist/blockchain/FullNodePeer.js

@@ -1,295 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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("@dignetwork/datalayer-driver");
-const chia_server_coin_1 = require("chia-server-coin");
-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 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
-class FullNodePeer {
-    constructor(peer) {
-        this.peer = peer;
-    }
-    /**
-     * Connect to the best peer, optionally using custom certificate and key file paths.
-     * @param {string} [certFilePath] - Optional custom certificate file path.
-     * @param {string} [keyFilePath] - Optional custom key file path.
-     * @returns {Promise<Peer>} The connected peer.
-     */
-    static async connect(certFilePath, keyFilePath) {
-        const peer = await FullNodePeer.getBestPeer(certFilePath, keyFilePath);
-        return new FullNodePeer(peer).peer;
-    }
-    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))
-                .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]?)$/;
-        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
-     */
-    static getTrustedFullNode() {
-        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
-        if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
-            return trustedNodeIp;
-        }
-        return null;
-    }
-    static async fetchNewPeerIPs() {
-        const trustedNodeIp = FullNodePeer.getTrustedFullNode();
-        const priorityIps = [];
-        // Prioritize trustedNodeIp unless it's deprioritized
-        if (trustedNodeIp &&
-            !FullNodePeer.deprioritizedIps.has(trustedNodeIp) &&
-            (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
-            priorityIps.push(trustedNodeIp);
-        }
-        // Prioritize LOCALHOST unless it's deprioritized
-        if (!FullNodePeer.deprioritizedIps.has(LOCALHOST) &&
-            (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
-            priorityIps.push(LOCALHOST);
-        }
-        // Prioritize CHIA_NODES_HOST unless it's deprioritized
-        if (!FullNodePeer.deprioritizedIps.has(CHIA_NODES_HOST) &&
-            (await FullNodePeer.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
-            priorityIps.push(CHIA_NODES_HOST);
-        }
-        if (priorityIps.length > 0) {
-            return priorityIps;
-        }
-        // Fetch peers from DNS introducers
-        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 reachableIps = [];
-                    for (const ip of shuffledIps) {
-                        if (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT)) {
-                            reachableIps.push(ip);
-                        }
-                        if (reachableIps.length === 5)
-                            break;
-                    }
-                    if (reachableIps.length > 0) {
-                        return reachableIps;
-                    }
-                }
-            }
-            catch (error) {
-                console.error(`Failed to resolve IPs from ${DNS_HOST}: ${error.message}`);
-            }
-        }
-        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) {
-            // Clear cache and reset deprioritized IPs when cache is cleared
-            FullNodePeer.deprioritizedIps.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();
-                                FullNodePeer.deprioritizedIps.clear();
-                                console.info(`Fullnode Peer error, reconnecting to a new peer...`);
-                                const newPeer = await FullNodePeer.getBestPeer();
-                                return newPeer[prop](...args);
-                            }
-                            throw error;
-                        }
-                    };
-                }
-                return originalMethod;
-            },
-        });
-    }
-    static async getBestPeer(certFilePath, keyFilePath) {
-        const now = Date.now();
-        if (FullNodePeer.cachedPeer &&
-            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
-            return FullNodePeer.cachedPeer.peer;
-        }
-        let certFile;
-        let keyFile;
-        // If certFilePath or keyFilePath is provided, ensure both are provided
-        if (certFilePath && keyFilePath) {
-            certFile = certFilePath;
-            keyFile = keyFilePath;
-            if (!fs_1.default.existsSync(certFile)) {
-                throw new Error(`Certificate file not found: ${certFile}`);
-            }
-            if (!fs_1.default.existsSync(keyFile)) {
-                throw new Error(`Key file not found: ${keyFile}`);
-            }
-        }
-        else {
-            // Use default paths if no custom paths are provided
-            const sslFolder = path_1.default.resolve(os_1.default.homedir(), ".dig", "ssl");
-            certFile = path_1.default.join(sslFolder, "public_dig.crt");
-            keyFile = path_1.default.join(sslFolder, "public_dig.key");
-            if (!fs_1.default.existsSync(sslFolder)) {
-                throw new Error(`SSL folder not found: ${sslFolder}`);
-            }
-        }
-        new chia_server_coin_1.Tls(certFile, keyFile);
-        const peerIPs = await FullNodePeer.getPeerIPs();
-        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
-        const peers = await Promise.all(peerIPs.map(async (ip) => {
-            if (ip) {
-                // Allow override of the trusted fullnode port if the override exists
-                let port = FULLNODE_PORT;
-                if (trustedNodeIp && ip === trustedNodeIp) {
-                    const trustedFullNodePort = Environment_1.Environment.TRUSTED_FULLNODE_PORT;
-                    if (trustedFullNodePort) {
-                        port = trustedFullNodePort;
-                    }
-                }
-                try {
-                    const peer = await datalayer_driver_1.Peer.new(`${ip}:${port}`, false, certFile, keyFile);
-                    return FullNodePeer.createPeerProxy(peer);
-                }
-                catch (error) {
-                    console.error(`Failed to create peer for IP ${ip}: ${error.message}`);
-                    return null;
-                }
-            }
-            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, TRUSTED_NODE_IP, and CHIA_NODES_HOST if they have the highest peak height
-        let bestPeerIndex = validHeights.findIndex((height, index) => height === highestPeak &&
-            !FullNodePeer.deprioritizedIps.has(peerIPs[index]) && // Exclude deprioritized IPs
-            (peerIPs[index] === LOCALHOST ||
-                peerIPs[index] === trustedNodeIp ||
-                peerIPs[index] === CHIA_NODES_HOST));
-        // If LOCALHOST, TRUSTED_NODE_IP, or CHIA_NODES_HOST 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 Fullnode Peer: ${peerIPs[bestPeerIndex]}`);
-        return bestPeer;
-    }
-    getPeer() {
-        return this.peer;
-    }
-    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;
-                }
-                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.deprioritizedIps = new Set(); // New set for deprioritized IPs
-(() => {
-    FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
-})();

package/dist/blockchain/ServerCoin.d.ts

@@ -1,29 +0,0 @@
-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, 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(): {
-        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 calculateEpochAndRound(currentTimestampUTC: Date): {
-        epoch: number;
-        round: number;
-    };
-}
-//# sourceMappingURL=ServerCoin.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAItC,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;IAgDP,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"}

package/dist/blockchain/ServerCoin.js

@@ -1,321 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerCoin = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
-const FullNodePeer_1 = require("./FullNodePeer");
-const coins_1 = require("./coins");
-const Wallet_1 = require("./Wallet");
-const NconfManager_1 = require("../utils/NconfManager");
-const DataStore_1 = require("./DataStore");
-const node_cache_1 = __importDefault(require("node-cache"));
-const network_1 = require("../utils/network");
-const Environment_1 = require("../utils/Environment");
-const serverCoinCollateral = 300000000;
-// Initialize the cache with a TTL of 300 seconds (5 minutes)
-const serverCoinPeersCache = new node_cache_1.default({ stdTTL: 300 });
-class ServerCoin {
-    constructor(storeId) {
-        this.storeId = storeId;
-    }
-    // Create a new server coin for the current epoch
-    async createForEpoch(peerIp, rootHash) {
-        try {
-            const peer = await FullNodePeer_1.FullNodePeer.connect();
-            const wallet = await Wallet_1.Wallet.load("default");
-            const publicSyntheticKey = await wallet.getPublicSyntheticKey();
-            const serverCoinCreationCoins = await (0, coins_1.selectUnspentCoins)(peer, BigInt(serverCoinCollateral), BigInt(1000000));
-            const { epoch: currentEpoch } = ServerCoin.getCurrentEpoch();
-            const epochBasedHint = (0, datalayer_driver_1.morphLauncherId)(Buffer.from(this.storeId, "hex"), BigInt(currentEpoch));
-            const newServerCoin = (0, datalayer_driver_1.createServerCoin)(publicSyntheticKey, serverCoinCreationCoins, epochBasedHint, [peerIp], BigInt(serverCoinCollateral), BigInt(1000000));
-            const combinedCoinSpends = [...newServerCoin.coinSpends];
-            const sig = (0, datalayer_driver_1.signCoinSpends)(combinedCoinSpends, [await wallet.getPrivateSyntheticKey()], false);
-            const err = await peer.broadcastSpend(combinedCoinSpends, [sig]);
-            if (err) {
-                if (err.includes("no spendable coins")) {
-                    console.log("No coins available. Will try again in 5 seconds...");
-                    await new Promise((resolve) => setTimeout(resolve, 5000));
-                    return this.createForEpoch(peerIp, rootHash);
-                }
-                throw new Error(err);
-            }
-            // Cache the new server coin in the NconfManager
-            await this.saveServerCoinData(newServerCoin.serverCoin, currentEpoch, peerIp, rootHash);
-            return newServerCoin.serverCoin;
-        }
-        catch (error) {
-            throw new Error("Failed to create server coin: " + error.message);
-        }
-    }
-    // Save the server coin data to NconfManager
-    async saveServerCoinData(serverCoin, epoch, peerIp, rootHash) {
-        const newServerCoinData = {
-            coin: {
-                amount: serverCoin.coin.amount.toString(),
-                puzzleHash: serverCoin.coin.puzzleHash.toString("hex"),
-                parentCoinInfo: serverCoin.coin.parentCoinInfo.toString("hex"),
-            },
-            createdAt: new Date().toISOString(),
-            epoch,
-            rootHash,
-        };
-        const serverCoins = await this.getServerCoinsForStore(peerIp);
-        serverCoins.push(newServerCoinData);
-        await ServerCoin.serverCoinManager.setConfigValue(`${this.storeId}:${peerIp}`, serverCoins);
-    }
-    // Melt server coin by epoch
-    async melt(epoch, peerIp) {
-        const peer = await FullNodePeer_1.FullNodePeer.connect();
-        const wallet = await Wallet_1.Wallet.load("default");
-        const publicSyntheticKey = await wallet.getPublicSyntheticKey();
-        const serverCoins = await this.getServerCoinsForStore(peerIp);
-        const serverCoin = serverCoins.find((coin) => coin.epoch === epoch);
-        if (!serverCoin) {
-            throw new Error(`No server coin found for epoch ${epoch} in store ${this.storeId}.`);
-        }
-        const feeCoins = await (0, coins_1.selectUnspentCoins)(peer, BigInt(0), BigInt(1000000));
-        const coin = {
-            amount: BigInt(serverCoin.coin.amount),
-            puzzleHash: Buffer.from(serverCoin.coin.puzzleHash, "hex"),
-            parentCoinInfo: Buffer.from(serverCoin.coin.parentCoinInfo, "hex"),
-        };
-        const serverCoinId = (0, datalayer_driver_1.getCoinId)(coin);
-        console.log("Melt Coin ID: ", serverCoinId.toString("hex"));
-        const spendBundle = await peer.lookupAndSpendServerCoins(publicSyntheticKey, [coin, ...feeCoins], BigInt(1000000), false);
-        const sig = (0, datalayer_driver_1.signCoinSpends)(spendBundle, [await wallet.getPrivateSyntheticKey()], false);
-        const err = await peer.broadcastSpend(spendBundle, [sig]);
-        if (err) {
-            throw new Error(err);
-        }
-        await FullNodePeer_1.FullNodePeer.waitForConfirmation(serverCoinId);
-        // Remove the melted coin from the NconfManager
-        await this.removeServerCoinData(serverCoin.coin, peerIp);
-    }
-    // Remove the melted server coin from NconfManager
-    async removeServerCoinData(serverCoin, peerIp) {
-        let serverCoins = await this.getServerCoinsForStore(peerIp);
-        serverCoins = serverCoins.filter((coin) => coin.coin.parentCoinInfo !== serverCoin.parentCoinInfo);
-        await ServerCoin.serverCoinManager.setConfigValue(`${this.storeId}:${peerIp}`, serverCoins);
-    }
-    async getAllEpochPeers(epoch, blacklist = []) {
-        const cacheKey = `serverCoinPeers-${this.storeId}-${epoch}`;
-        // Check if the result is already cached
-        const cachedPeers = serverCoinPeersCache.get(cacheKey);
-        if (cachedPeers) {
-            return cachedPeers;
-        }
-        const epochBasedHint = (0, datalayer_driver_1.morphLauncherId)(Buffer.from(this.storeId, "hex"), BigInt(epoch));
-        const peer = await FullNodePeer_1.FullNodePeer.connect();
-        const maxClvmCost = BigInt(11000000000);
-        const hintedCoinStates = await peer.getHintedCoinStates(epochBasedHint, false);
-        const filteredCoinStates = hintedCoinStates.filter((coinState) => coinState.coin.amount >= serverCoinCollateral);
-        // Use a Set to ensure uniqueness
-        const serverCoinPeers = new Set();
-        for (const coinState of filteredCoinStates) {
-            const serverCoin = await peer.fetchServerCoin(coinState, maxClvmCost);
-            const peerUrl = serverCoin.memoUrls[0];
-            if (!blacklist.includes(peerUrl)) {
-                serverCoinPeers.add(peerUrl);
-            }
-        }
-        if (Environment_1.Environment.DEBUG) {
-            console.log("Server Coin Peers: ", serverCoinPeers);
-        }
-        const peerList = Array.from(serverCoinPeers);
-        // Cache the result
-        serverCoinPeersCache.set(cacheKey, peerList);
-        return peerList;
-    }
-    async getActiveEpochPeers(blacklist = []) {
-        const { epoch } = ServerCoin.getCurrentEpoch();
-        return this.getAllEpochPeers(epoch, blacklist);
-    }
-    // Sample server coins for the current epoch
-    async sampleCurrentEpoch(sampleSize = 5, blacklist = []) {
-        const { epoch } = ServerCoin.getCurrentEpoch();
-        return this.sampleServerCoinsByEpoch(epoch, sampleSize, blacklist);
-    }
-    // Sample server coins by epoch
-    async sampleServerCoinsByEpoch(epoch, sampleSize = 5, blacklist = []) {
-        // We dont want our own IP to be included
-        const myIp = await (0, network_1.getPublicIpAddress)();
-        if (myIp) {
-            blacklist.push(myIp);
-        }
-        const serverCoinPeers = await this.getAllEpochPeers(epoch, blacklist);
-        if (Environment_1.Environment.DEBUG) {
-            console.log("Server Coin Peers: ", serverCoinPeers);
-        }
-        return lodash_1.default.sampleSize(serverCoinPeers, sampleSize);
-    }
-    // Get the current epoch based on the current timestamp
-    static getCurrentEpoch() {
-        return ServerCoin.calculateEpochAndRound(new Date());
-    }
-    // Ensure server coin exists for the current epoch
-    async ensureServerCoinExists(peerIp) {
-        try {
-            console.log(`Ensuring server coin exists for store ${this.storeId}...`);
-            const { epoch: currentEpoch } = ServerCoin.getCurrentEpoch();
-            const serverCoins = await this.getServerCoinsForStore(peerIp);
-            // Check if a server coin already exists for the current epoch
-            const existingCoin = serverCoins.find((coin) => coin.epoch === currentEpoch);
-            const dataStore = DataStore_1.DataStore.from(this.storeId);
-            const rootHistory = await dataStore.getRootHistory(true);
-            const lastRoot = lodash_1.default.last(rootHistory);
-            if (!lastRoot) {
-                throw new Error('Cant get the last root on chain, something is wrong.');
-            }
-            if (existingCoin) {
-                // nothing to do
-                if (lastRoot?.synced && lastRoot?.root_hash === existingCoin.rootHash) {
-                    return;
-                }
-                // everything is fine, lets just update the roothash for tracking
-                if (lastRoot?.synced && lastRoot?.root_hash !== existingCoin.rootHash) {
-                    existingCoin.rootHash = lastRoot.root_hash;
-                    // Update the conf with the modified server coin
-                    await ServerCoin.serverCoinManager.setConfigValue(`${this.storeId}:${peerIp}`, serverCoins);
-                    return;
-                }
-                // If not synced, melt the coin, a new one will be created when synced up
-                // this helps prevent penalties for not having a valid peer registered
-                await this.melt(currentEpoch, peerIp);
-            }
-            // Don't create a server coin until you're synced up
-            if (!lodash_1.default.last(rootHistory)?.synced) {
-                return;
-            }
-            console.log(`No server coin found for epoch ${currentEpoch}. Creating new server coin...`);
-            const serverCoin = await this.createForEpoch(peerIp, lastRoot?.root_hash);
-            const newServerCoinData = {
-                coin: {
-                    amount: serverCoin.coin.amount.toString(),
-                    puzzleHash: serverCoin.coin.puzzleHash.toString("hex"),
-                    parentCoinInfo: serverCoin.coin.parentCoinInfo.toString("hex"),
-                },
-                createdAt: new Date().toISOString(),
-                epoch: currentEpoch,
-                rootHash: lodash_1.default.last(rootHistory)?.root_hash || "",
-            };
-            await FullNodePeer_1.FullNodePeer.waitForConfirmation(serverCoin.coin.parentCoinInfo);
-            serverCoins.push(newServerCoinData);
-            await ServerCoin.serverCoinManager.setConfigValue(`${this.storeId}:${peerIp}`, serverCoins);
-            console.log(`Server coin created and saved for store ${this.storeId}. Epoch: ${currentEpoch}`);
-        }
-        catch (error) {
-            console.error(`Error ensuring server coin: ${error.message}`);
-            throw error;
-        }
-    }
-    // Melt outdated server coins
-    async meltOutdatedEpochs(peerIp) {
-        try {
-            const { epoch: currentEpoch } = ServerCoin.getCurrentEpoch();
-            let serverCoins = await this.getServerCoinsForStore(peerIp);
-            // Filter out coins that are not in the current epoch
-            const outdatedCoins = serverCoins.filter((coin) => coin.epoch < currentEpoch);
-            for (const serverCoin of outdatedCoins) {
-                await this.melt(serverCoin.epoch, peerIp);
-                // Remove the processed coin from the serverCoins array
-                serverCoins = serverCoins.filter((coin) => coin.epoch !== serverCoin.epoch);
-                // Update the nconf file with the updated array
-                await ServerCoin.serverCoinManager.setConfigValue(`${this.storeId}:${peerIp}`, serverCoins);
-            }
-        }
-        catch (error) {
-            console.error(`Error processing outdated epochs: ${error.message}`);
-            throw error;
-        }
-    }
-    // If a store is unsubscribed this will melt all of its untracked coins and recover the locked amount
-    static async meltUntrackedStoreCoins() {
-        // Get all the store coins from the server config
-        const allServerCoins = await ServerCoin.serverCoinManager.getFullConfig();
-        // Get all the store ids from the server config
-        const storeIdsWithCoins = Object.keys(allServerCoins);
-        // Get all the subscribed stores and map them to their StoreId
-        const allSubscribedStores = DataStore_1.DataStore.getAllStores();
-        const allSubscribedStoreIds = allSubscribedStores.map((store) => store.StoreId);
-        // Iterate over each store in the server coins
-        for (const storeCoin of storeIdsWithCoins) {
-            const serverCoin = new ServerCoin(storeCoin);
-            // If the store is no longer subscribed
-            if (!allSubscribedStoreIds.includes(storeCoin)) {
-                // Get all the IPs that have coins for this untracked store
-                const ips = Object.keys(allServerCoins[storeCoin]);
-                // Iterate over each IP (e.g., "71.121.246.129")
-                for (const ip of ips) {
-                    // Get the array of coins for that IP
-                    let coins = allServerCoins[storeCoin][ip];
-                    // Iterate over each coin and melt it
-                    for (const coinInfo of coins) {
-                        const { epoch, coin } = coinInfo;
-                        // Melt the coin
-                        await serverCoin.melt(epoch, ip);
-                        // Remove the melted coin from the array
-                        coins = coins.filter((c) => c !== coinInfo);
-                        // Update the config to reflect the remaining coins for this IP
-                        await ServerCoin.serverCoinManager.setConfigValue(`${storeCoin}:${ip}`, coins);
-                    }
-                    // If no coins are left for this IP, optionally remove the entire IP entry
-                    if (coins.length === 0) {
-                        delete allServerCoins[storeCoin][ip];
-                        await ServerCoin.serverCoinManager.setConfigValue(`${storeCoin}:${ip}`, undefined);
-                    }
-                }
-                // If no IPs are left for this store, optionally remove the store entry
-                if (Object.keys(allServerCoins[storeCoin]).length === 0) {
-                    delete allServerCoins[storeCoin];
-                    await ServerCoin.serverCoinManager.setConfigValue(storeCoin, undefined);
-                }
-            }
-        }
-    }
-    // Retrieve server coins from the store
-    async getServerCoinsForStore(peerIp) {
-        const serverCoins = (await ServerCoin.serverCoinManager.getConfigValue(`${this.storeId}:${peerIp}`)) || [];
-        return serverCoins;
-    }
-    // Check if the server coin has been created for the current epoch
-    async hasEpochCoinBeenCreated(currentEpoch, peerIp) {
-        try {
-            const serverCoins = await this.getServerCoinsForStore(peerIp);
-            const existingCoin = serverCoins.find((coin) => coin.epoch === currentEpoch);
-            if (!existingCoin) {
-                console.log(`No server coin found for epoch ${currentEpoch}.`);
-                return false;
-            }
-            console.log(`Server coin found for epoch ${currentEpoch}.`);
-            return true;
-        }
-        catch (error) {
-            console.error(`Error checking for existing server coin: ${error.message}`);
-            return false;
-        }
-    }
-    // Static method to calculate the current epoch
-    static calculateEpochAndRound(currentTimestampUTC) {
-        const firstEpochStart = new Date(Date.UTC(2024, 8, 3, 0, 0)); // Sept 3, 2024, 00:00 UTC
-        // Convert the current timestamp to milliseconds
-        const currentTimestampMillis = currentTimestampUTC.getTime();
-        // Calculate the number of milliseconds in one epoch (7 days)
-        const millisecondsInEpoch = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds
-        // Calculate the difference in milliseconds between the current timestamp and the first epoch start
-        const differenceMillis = currentTimestampMillis - firstEpochStart.getTime();
-        // Calculate the current epoch number
-        const epochNumber = Math.floor(differenceMillis / millisecondsInEpoch) + 1;
-        // Calculate the milliseconds elapsed since the start of the current epoch
-        const elapsedMillisInCurrentEpoch = differenceMillis % millisecondsInEpoch;
-        // Calculate the number of milliseconds in a round (10 minutes)
-        const millisecondsInRound = 10 * 60 * 1000; // 10 minutes in milliseconds
-        // Calculate the current round number
-        const roundNumber = Math.floor(elapsedMillisInCurrentEpoch / millisecondsInRound) + 1;
-        return { epoch: epochNumber, round: roundNumber };
-    }
-}
-exports.ServerCoin = ServerCoin;
-ServerCoin.serverCoinManager = new NconfManager_1.NconfManager("server_coin.json");