@dignetwork/dig-sdk 0.0.1-alpha.2

package/dist/blockchain/FullNodePeer.js

@@ -0,0 +1,215 @@
+"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("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 FULLNODE_PORT = 8444;
+const LOCALHOST = "127.0.0.1";
+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;
+    }
+    static async connect() {
+        const peer = await FullNodePeer.getBestPeer();
+        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);
+    }
+    static async fetchNewPeerIPs() {
+        const trustedNodeIp = process.env.TRUSTED_FULLNODE || null;
+        const priorityIps = [];
+        // Prioritize trustedNodeIp
+        if (trustedNodeIp &&
+            FullNodePeer.isValidIpAddress(trustedNodeIp) &&
+            (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
+            priorityIps.push(trustedNodeIp);
+        }
+        // Prioritize LOCALHOST
+        if (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT)) {
+            priorityIps.push(LOCALHOST);
+        }
+        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) {
+            // @ts-ignore
+            FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
+        }
+        return FullNodePeer.memoizedFetchNewPeerIPs();
+    }
+    static createPeerProxy(peer, certFile, keyFile) {
+        return new Proxy(peer, {
+            get: (target, prop) => {
+                const originalMethod = target[prop];
+                if (typeof originalMethod === "function") {
+                    return async (...args) => {
+                        try {
+                            return await originalMethod.apply(target, args);
+                        }
+                        catch (error) {
+                            if (error.message.includes("WebSocket")) {
+                                FullNodePeer.cachedPeer = null;
+                                const newPeer = await FullNodePeer.getBestPeer();
+                                return newPeer[prop](...args);
+                            }
+                            throw error;
+                        }
+                    };
+                }
+                return originalMethod;
+            },
+        });
+    }
+    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, certFile, keyFile);
+                }
+                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 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;
+    }
+    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.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
+})();

package/dist/blockchain/ServerCoin.d.ts

@@ -0,0 +1,21 @@
+import { ServerCoin as ServerCoinDriver } from "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>;
+    melt(epoch: number, peerIp: string): Promise<void>;
+    private removeServerCoinData;
+    sampleCurrentEpoch(sampleSize?: number, blacklist?: string[]): Promise<string[]>;
+    sampleServerCoinsByEpoch(epoch: number, sampleSize?: number, blacklist?: string[]): Promise<string[]>;
+    static getCurrentEpoch(): 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;
+}
+//# sourceMappingURL=ServerCoin.d.ts.map

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

@@ -0,0 +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"}

package/dist/blockchain/ServerCoin.js

@@ -0,0 +1,261 @@
+"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("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 serverCoinCollateral = 300000000;
+class ServerCoin {
+    constructor(storeId) {
+        this.storeId = storeId;
+    }
+    // Create a new server coin for the current epoch
+    async createForEpoch(peerIp) {
+        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 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);
+                }
+                throw new Error(err);
+            }
+            // Cache the new server coin in the NconfManager
+            await this.saveServerCoinData(newServerCoin.serverCoin, currentEpoch, peerIp);
+            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) {
+        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: epoch,
+        };
+        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);
+    }
+    // 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 = []) {
+        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 (process.env.DIG_DEBUG === "1") {
+            console.log("Server Coin Peers: ", serverCoinPeers);
+        }
+        // Convert the Set back to an array if needed
+        return lodash_1.default.sampleSize(Array.from(serverCoinPeers), sampleSize);
+    }
+    // Get the current epoch based on the current timestamp
+    static getCurrentEpoch() {
+        return ServerCoin.calculateEpoch(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 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);
+            if (existingCoin) {
+                return;
+            }
+            console.log(`No server coin found for epoch ${currentEpoch}. Creating new server coin...`);
+            const serverCoin = await this.createForEpoch(peerIp);
+            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,
+            };
+            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 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 calculateEpoch(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;
+        // 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;
+        return epochNumber;
+    }
+}
+exports.ServerCoin = ServerCoin;
+ServerCoin.serverCoinManager = new NconfManager_1.NconfManager("server_coin.json");

package/dist/blockchain/Wallet.d.ts

@@ -0,0 +1,28 @@
+import { Buffer } from "buffer";
+import { Peer, Coin, CoinSpend } from "datalayer-driver";
+export declare const DEFAULT_FEE_COIN_COST = 64000000;
+export declare class Wallet {
+    private mnemonic;
+    private walletName;
+    private constructor();
+    static load(walletName?: string, createOnUndefined?: boolean): Promise<Wallet>;
+    getMnemonic(): string;
+    static createNewWallet(walletName: string): Promise<string>;
+    static importWallet(walletName: string, seed?: string): Promise<string>;
+    static importWalletFromChia(walletName: string): Promise<string>;
+    getMasterSecretKey(): Promise<Buffer>;
+    getPublicSyntheticKey(): Promise<Buffer>;
+    getPrivateSyntheticKey(): Promise<Buffer>;
+    getOwnerPuzzleHash(): Promise<Buffer>;
+    getOwnerPublicKey(): Promise<string>;
+    static deleteWallet(walletName: string): Promise<boolean>;
+    static listWallets(): Promise<string[]>;
+    private static getWalletFromKeyring;
+    private static saveWalletToKeyring;
+    createKeyOwnershipSignature(nonce: string): Promise<string>;
+    verifyKeyOwnershipSignature(nonce: string, signature: string, publicKey: string): Promise<boolean>;
+    selectUnspentCoins(peer: Peer, coinAmount: bigint, feeBigInt: bigint, omitCoins?: Coin[]): Promise<Coin[]>;
+    static calculateFeeForCoinSpends(peer: Peer, coinSpends: CoinSpend[] | null): Promise<bigint>;
+    static isCoinSpendable(peer: Peer, coinId: Buffer): Promise<boolean>;
+}
+//# sourceMappingURL=Wallet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Wallet.d.ts","sourceRoot":"","sources":["../../src/blockchain/Wallet.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EASL,IAAI,EACJ,IAAI,EAEJ,SAAS,EAEV,MAAM,kBAAkB,CAAC;AAM1B,eAAO,MAAM,qBAAqB,WAAa,CAAC;AAOhD,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO;WAKa,IAAI,CACtB,UAAU,GAAE,MAAkB,EAC9B,iBAAiB,GAAE,OAAc,GAChC,OAAO,CAAC,MAAM,CAAC;IAsBX,WAAW,IAAI,MAAM;WAOR,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;WAMpD,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;WAShE,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA6BhE,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKrC,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC;IAMxC,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKzC,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;IAMrC,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;WAK7B,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;WASlD,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;mBAU/B,oBAAoB;mBAWpB,mBAAmB;IAM3B,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO3D,2BAA2B,CACtC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC;IASN,kBAAkB,CAC7B,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,IAAI,EAAO,GACrB,OAAO,CAAC,IAAI,EAAE,CAAC;WAwCE,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;WAItF,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAOlF"}