@dignetwork/dig-sdk 0.0.1-alpha.12 → 0.0.1-alpha.120

package/dist/blockchain/ServerCoin.js

@@ -5,27 +5,31 @@ var __importDefault = (this && this.__importDefault) || function (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 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) {
+    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 currentEpoch = ServerCoin.getCurrentEpoch();
+            const serverCoinCreationCoins = await wallet.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 newServerCoin = (0, datalayer_driver_1.createServerCoin)(publicSyntheticKey, serverCoinCreationCoins, epochBasedHint, [peerIp, publicSyntheticKey.toString("hex")], 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]);
@@ -33,12 +37,12 @@ class ServerCoin {
                 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);
+                    return this.createForEpoch(peerIp, rootHash);
                 }
                 throw new Error(err);
             }
             // Cache the new server coin in the NconfManager
-            await this.saveServerCoinData(newServerCoin.serverCoin, currentEpoch, peerIp);
+            await this.saveServerCoinData(newServerCoin.serverCoin, currentEpoch, peerIp, rootHash);
             return newServerCoin.serverCoin;
         }
         catch (error) {
@@ -46,7 +50,7 @@ class ServerCoin {
         }
     }
     // Save the server coin data to NconfManager
-    async saveServerCoinData(serverCoin, epoch, peerIp) {
+    async saveServerCoinData(serverCoin, epoch, peerIp, rootHash) {
         const newServerCoinData = {
             coin: {
                 amount: serverCoin.coin.amount.toString(),
@@ -54,7 +58,8 @@ class ServerCoin {
                 parentCoinInfo: serverCoin.coin.parentCoinInfo.toString("hex"),
             },
             createdAt: new Date().toISOString(),
-            epoch: epoch,
+            epoch,
+            rootHash,
         };
         const serverCoins = await this.getServerCoinsForStore(peerIp);
         serverCoins.push(newServerCoinData);
@@ -70,7 +75,7 @@ class ServerCoin {
         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 feeCoins = await wallet.selectUnspentCoins(peer, BigInt(0), BigInt(1000000));
         const coin = {
             amount: BigInt(serverCoin.coin.amount),
             puzzleHash: Buffer.from(serverCoin.coin.puzzleHash, "hex"),
@@ -94,13 +99,13 @@ class ServerCoin {
         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 = []) {
+    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);
@@ -111,33 +116,83 @@ class ServerCoin {
         for (const coinState of filteredCoinStates) {
             const serverCoin = await peer.fetchServerCoin(coinState, maxClvmCost);
             const peerUrl = serverCoin.memoUrls[0];
+            // The second memo URL is the public key
+            // We will utilize this for future features
+            const publicKey = serverCoin.memoUrls[1];
             if (!blacklist.includes(peerUrl)) {
                 serverCoinPeers.add(peerUrl);
             }
         }
-        if (process.env.DIG_DEBUG === "1") {
+        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);
         }
-        // Convert the Set back to an array if needed
-        return lodash_1.default.sampleSize(Array.from(serverCoinPeers), sampleSize);
+        return lodash_1.default.sampleSize(serverCoinPeers, sampleSize);
     }
     // Get the current epoch based on the current timestamp
     static getCurrentEpoch() {
-        return ServerCoin.calculateEpoch(new Date());
+        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 currentEpoch = ServerCoin.getCurrentEpoch();
+            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);
+            const serverCoin = await this.createForEpoch(peerIp, lastRoot?.root_hash);
             const newServerCoinData = {
                 coin: {
                     amount: serverCoin.coin.amount.toString(),
@@ -146,6 +201,7 @@ class ServerCoin {
                 },
                 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);
@@ -160,7 +216,7 @@ class ServerCoin {
     // Melt outdated server coins
     async meltOutdatedEpochs(peerIp) {
         try {
-            const currentEpoch = ServerCoin.getCurrentEpoch();
+            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);
@@ -244,17 +300,23 @@ class ServerCoin {
         }
     }
     // Static method to calculate the current epoch
-    static calculateEpoch(currentTimestampUTC) {
+    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;
+        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;
-        return epochNumber;
+        // 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;

package/dist/blockchain/StoreInfoCacheUpdater.d.ts

@@ -0,0 +1,16 @@
+export declare class StoreInfoCacheUpdater {
+    private static instance;
+    private storeCoinCache;
+    private monitors;
+    private lockFilePath;
+    private releaseLock;
+    private isMonitoring;
+    private lockRenewalInterval;
+    private constructor();
+    static initInstance(): StoreInfoCacheUpdater;
+    private startMonitors;
+    private renewLock;
+    private monitorStore;
+    private isUnrecoverableError;
+}
+//# sourceMappingURL=StoreInfoCacheUpdater.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StoreInfoCacheUpdater.d.ts","sourceRoot":"","sources":["../../src/blockchain/StoreInfoCacheUpdater.ts"],"names":[],"mappings":"AAcA,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAwB;IAC/C,OAAO,CAAC,cAAc,CAIsB;IAC5C,OAAO,CAAC,QAAQ,CAAyC;IACzD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,mBAAmB,CAA+B;IAE1D,OAAO;WAiBO,YAAY,IAAI,qBAAqB;YAQrC,aAAa;IA6E3B,OAAO,CAAC,SAAS;YA0BH,YAAY;IAyI1B,OAAO,CAAC,oBAAoB;CAG7B"}

package/dist/blockchain/StoreInfoCacheUpdater.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreInfoCacheUpdater = void 0;
+const fs_1 = __importDefault(require("fs"));
+const FullNodePeer_1 = require("./FullNodePeer");
+const utils_1 = require("../utils");
+const DataStoreSerializer_1 = require("./DataStoreSerializer");
+const utils_2 = require("../utils");
+const lockfile = __importStar(require("proper-lockfile"));
+const path = __importStar(require("path"));
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
+class StoreInfoCacheUpdater {
+    constructor() {
+        this.storeCoinCache = new utils_1.FileCache(`stores`, utils_1.USER_DIR_PATH);
+        this.monitors = new Map();
+        this.releaseLock = null;
+        this.isMonitoring = true;
+        this.lockRenewalInterval = null;
+        console.log("Constructor: Initializing StoreInfoCacheUpdater");
+        // Construct lock file path using the path module
+        this.lockFilePath = path.join(utils_1.USER_DIR_PATH, "store-info-cache.lock");
+        console.log("Lock file path:", this.lockFilePath);
+        const lockDir = path.dirname(this.lockFilePath);
+        if (!fs_1.default.existsSync(lockDir)) {
+            console.log(`Creating lock directory: ${lockDir}`);
+            fs_1.default.mkdirSync(lockDir, { recursive: true });
+        }
+        // Start monitors for existing storeIds
+        this.startMonitors();
+    }
+    static initInstance() {
+        if (!StoreInfoCacheUpdater.instance) {
+            console.log("Initializing DataStore Monitor");
+            StoreInfoCacheUpdater.instance = new StoreInfoCacheUpdater();
+        }
+        return StoreInfoCacheUpdater.instance;
+    }
+    async startMonitors() {
+        try {
+            console.log("Checking if lockfile exists...");
+            // Check if the lock file exists
+            if (!fs_1.default.existsSync(this.lockFilePath)) {
+                console.log("Lockfile does not exist. Proceeding without lock.");
+            }
+            else {
+                // Check if the lockfile is already held
+                const isLocked = await lockfile.check(this.lockFilePath, {
+                    realpath: false,
+                });
+                if (isLocked) {
+                    console.log("Another process is already running the StoreInfoCacheUpdater.");
+                    return;
+                }
+            }
+            // Attempt to acquire the lock
+            console.log("Attempting to acquire lock...");
+            this.releaseLock = await lockfile.lock(this.lockFilePath, {
+                retries: {
+                    retries: 0, // No retries since we only need one lock
+                },
+                stale: 60000, // Lock expires after 1 minute
+                realpath: false, // Ensure lockfile uses the exact path
+            });
+            console.log("Lock acquired, starting monitors...");
+            // Renew the lock every minute by reacquiring it
+            this.renewLock();
+            const storeIds = this.storeCoinCache.getCachedKeys();
+            console.log(`Found ${storeIds.length} store IDs in cache:`, storeIds);
+            for (const storeId of storeIds) {
+                // Check if a monitor is already running for this storeId
+                if (!this.monitors.has(storeId)) {
+                    console.log(`Starting monitor for storeId: ${storeId}`);
+                    // Start monitoring in the background
+                    const monitorPromise = this.monitorStore(storeId);
+                    this.monitors.set(storeId, monitorPromise);
+                }
+                else {
+                    console.log(`Monitor already exists for storeId: ${storeId}`);
+                }
+            }
+            this.isMonitoring = true;
+            // Wait for all monitors to settle
+            const monitorPromises = Array.from(this.monitors.values());
+            console.log("Waiting for all monitor promises to settle...");
+            await Promise.all(monitorPromises);
+        }
+        catch (error) {
+            console.error("Monitor system encountered an error:", error);
+        }
+        finally {
+            // Release the lock
+            if (this.releaseLock) {
+                try {
+                    console.log("Releasing lock...");
+                    await this.releaseLock();
+                    console.log("Lock released successfully.");
+                }
+                catch (releaseError) {
+                    console.error("Error releasing the lock:", releaseError);
+                }
+            }
+            // Clear the lock renewal interval
+            if (this.lockRenewalInterval) {
+                clearInterval(this.lockRenewalInterval);
+                this.lockRenewalInterval = null;
+            }
+        }
+    }
+    renewLock() {
+        // Set up a renewal process that releases and reacquires the lock every minute
+        this.lockRenewalInterval = setInterval(async () => {
+            try {
+                if (this.releaseLock) {
+                    console.log("Releasing the lock for renewal...");
+                    await this.releaseLock();
+                    console.log("Lock released for renewal.");
+                }
+                // Reacquire the lock
+                this.releaseLock = await lockfile.lock(this.lockFilePath, {
+                    retries: {
+                        retries: 0, // No retries since we only need one lock
+                    },
+                    stale: 60000, // Lock expires after 1 minute
+                    realpath: false, // Ensure lockfile uses the exact path
+                });
+                console.log("Lock reacquired for renewal.");
+            }
+            catch (error) {
+                console.error("Error renewing the lock:", error);
+            }
+        }, 60000); // Renew the lock every 60 seconds
+    }
+    // Monitor a single store's coin
+    async monitorStore(storeId) {
+        while (this.isMonitoring) {
+            let peer = null;
+            try {
+                console.log(`Monitoring store ${storeId}`);
+                // Connect to a peer
+                peer = await (0, utils_2.withTimeout)(FullNodePeer_1.FullNodePeer.connect(), 60000, "Timeout connecting to FullNodePeer");
+                // Get the latest store info (from cache if available)
+                const cachedInfo = this.storeCoinCache.get(storeId);
+                if (!cachedInfo) {
+                    // If no cached info, skip and wait before retrying
+                    console.error(`No cached info for storeId ${storeId}`);
+                    await new Promise((resolve) => setTimeout(resolve, 5000));
+                    continue;
+                }
+                const { latestStore: serializedStore, latestHeight, latestHash, } = cachedInfo;
+                const { latestStore } = DataStoreSerializer_1.DataStoreSerializer.deserialize({
+                    latestStore: serializedStore,
+                    latestHeight: latestHeight.toString(),
+                    latestHash: latestHash,
+                });
+                // Get the coinId associated with the store
+                const coinId = (0, datalayer_driver_1.getCoinId)(latestStore.coin);
+                console.log(`Waiting for coin to be spent: ${coinId.toString("hex")}`);
+                try {
+                    // Wait for the coin to be spent
+                    await peer.waitForCoinToBeSpent(coinId, latestHeight, Buffer.from(latestHash, "hex"));
+                }
+                catch {
+                    const genesisChallenge = await (0, datalayer_driver_1.getMainnetGenesisChallenge)();
+                    const storeInfo = await (0, utils_2.withTimeout)(peer.syncStore(latestStore, null, genesisChallenge, false), 60000, `Timeout syncing store for storeId ${storeId}`);
+                    const headerHash = await peer.getHeaderHash(storeInfo.latestHeight);
+                    await peer.waitForCoinToBeSpent((0, datalayer_driver_1.getCoinId)(storeInfo.latestStore.coin), storeInfo.latestHeight, headerHash);
+                }
+                console.log(`Detected Coin Spend: ${coinId.toString("hex")}`);
+                let updatedStore, newHeight;
+                try {
+                    // When resolved, sync the store
+                    const storeInfo = await (0, utils_2.withTimeout)(peer.syncStore(latestStore, latestHeight, Buffer.from(latestHash, "hex"), false // withHistory
+                    ), 60000, `Timeout syncing store for storeId ${storeId}`);
+                    updatedStore = storeInfo.latestStore;
+                    newHeight = storeInfo.latestHeight;
+                }
+                catch {
+                    const genesisChallenge = await (0, datalayer_driver_1.getMainnetGenesisChallenge)();
+                    const storeInfo = await (0, utils_2.withTimeout)(peer.syncStore(latestStore, null, genesisChallenge, false), 60000, `Timeout syncing store for storeId ${storeId}`);
+                    updatedStore = storeInfo.latestStore;
+                    newHeight = storeInfo.latestHeight;
+                }
+                // Get the latest header hash
+                const latestHashBuffer = await (0, utils_2.withTimeout)(peer.getHeaderHash(newHeight), 60000, `Timeout getting header hash for height ${newHeight}`);
+                // Serialize the updated store data for caching
+                const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(updatedStore, newHeight, latestHashBuffer).serialize();
+                // Update the cache
+                this.storeCoinCache.set(storeId, {
+                    latestStore: serializedLatestStore,
+                    latestHeight: newHeight,
+                    latestHash: latestHashBuffer.toString("hex"),
+                });
+                peer = null;
+                // Continue monitoring
+            }
+            catch (error) {
+                console.error(`Error monitoring store ${storeId}:`, error);
+                // Close the peer connection if it's open
+                if (peer) {
+                    peer = null;
+                }
+                // Determine if the error is unrecoverable
+                if (this.isUnrecoverableError(error)) {
+                    this.isMonitoring = false; // Signal other monitors to stop
+                    throw error; // Propagate error up to stop monitoring
+                }
+                // Wait before retrying
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+            }
+        }
+    }
+    isUnrecoverableError(error) {
+        return true;
+    }
+}
+exports.StoreInfoCacheUpdater = StoreInfoCacheUpdater;

package/dist/blockchain/Wallet.d.ts

@@ -1,5 +1,5 @@
 import { Buffer } from "buffer";
-import { Peer, Coin, CoinSpend } from "datalayer-driver";
+import { Peer, Coin, CoinSpend } from "@dignetwork/datalayer-driver";
 export declare const DEFAULT_FEE_COIN_COST = 64000000;
 export declare class Wallet {
     private mnemonic;
@@ -20,7 +20,7 @@ export declare class Wallet {
     private static getWalletFromKeyring;
     private static saveWalletToKeyring;
     createKeyOwnershipSignature(nonce: string): Promise<string>;
-    verifyKeyOwnershipSignature(nonce: string, signature: string, publicKey: string): Promise<boolean>;
+    static 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>;

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

@@ -1 +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"}
+{"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,8BAA8B,CAAC;AAQtC,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,CAC9B,UAAU,EAAE,MAAM,EAClB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,CAAC;WASE,oBAAoB,CACtC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC;IA6BL,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;mBAcpB,mBAAmB;IAS3B,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;WAUpD,2BAA2B,CAC7C,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;WAiFE,yBAAyB,CAC3C,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI,GAC7B,OAAO,CAAC,MAAM,CAAC;WAIE,eAAe,CACjC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC;CAWpB"}

package/dist/blockchain/Wallet.js

@@ -38,9 +38,10 @@ const chia_root_resolver_1 = require("chia-root-resolver");
 const chia_config_loader_1 = require("chia-config-loader");
 const encryption_1 = require("../utils/encryption");
 const buffer_1 = require("buffer");
-const datalayer_driver_1 = require("datalayer-driver");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const config_1 = require("../utils/config");
 const FileCache_1 = require("../utils/FileCache");
+const config_2 = require("../utils/config");
 const KEYRING_FILE = "keyring.json";
 const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
 exports.DEFAULT_FEE_COIN_COST = 64000000;
@@ -174,31 +175,62 @@ class Wallet {
         const signature = (0, datalayer_driver_1.signMessage)(buffer_1.Buffer.from(message, "utf-8"), privateSyntheticKey);
         return signature.toString("hex");
     }
-    async verifyKeyOwnershipSignature(nonce, signature, publicKey) {
+    static async verifyKeyOwnershipSignature(nonce, signature, publicKey) {
         const message = `Signing this message to prove ownership of key.\n\nNonce: ${nonce}`;
         return (0, datalayer_driver_1.verifySignedMessage)(buffer_1.Buffer.from(signature, "hex"), buffer_1.Buffer.from(publicKey, "hex"), buffer_1.Buffer.from(message, "utf-8"));
     }
     async selectUnspentCoins(peer, coinAmount, feeBigInt, omitCoins = []) {
-        const cache = new FileCache_1.FileCache("reserved_coins");
-        const cachedReservedCoins = cache.getCachedKeys();
-        const now = Date.now();
-        const omitCoinIds = omitCoins.map((coin) => (0, datalayer_driver_1.getCoinId)(coin).toString("hex"));
-        cachedReservedCoins.forEach((coinId) => {
-            const reservation = cache.get(coinId);
-            if (reservation && reservation.expiry > now) {
-                omitCoinIds.push(coinId);
+        const cache = new FileCache_1.FileCache("reserved_coins", config_2.USER_DIR_PATH);
+        const ownerPuzzleHash = await this.getOwnerPuzzleHash();
+        // Define a function to attempt selecting unspent coins
+        const trySelectCoins = async () => {
+            const now = Date.now();
+            const omitCoinIds = omitCoins.map((coin) => (0, datalayer_driver_1.getCoinId)(coin).toString("hex"));
+            // Update omitCoinIds with currently valid reserved coins
+            const cachedReservedCoins = cache.getCachedKeys();
+            cachedReservedCoins.forEach((coinId) => {
+                const reservation = cache.get(coinId);
+                if (reservation && reservation.expiry > now) {
+                    if (!omitCoinIds.includes(coinId)) {
+                        omitCoinIds.push(coinId);
+                    }
+                }
+                else {
+                    cache.delete(coinId);
+                }
+            });
+            const coinsResp = await peer.getAllUnspentCoins(ownerPuzzleHash, config_1.MIN_HEIGHT, buffer_1.Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex"));
+            const unspentCoins = coinsResp.coins.filter((coin) => !omitCoinIds.includes((0, datalayer_driver_1.getCoinId)(coin).toString("hex")));
+            const selectedCoins = (0, datalayer_driver_1.selectCoins)(unspentCoins, feeBigInt + coinAmount);
+            return selectedCoins;
+        };
+        let selectedCoins = [];
+        let retry = true;
+        while (retry) {
+            selectedCoins = await trySelectCoins();
+            if (selectedCoins.length > 0) {
+                // Coins have been successfully selected
+                retry = false;
             }
             else {
-                cache.delete(coinId);
+                const now = Date.now();
+                // Check if there are any valid cached reserved coins left
+                const cachedReservedCoins = cache.getCachedKeys().filter((coinId) => {
+                    const reservation = cache.get(coinId);
+                    return reservation && reservation.expiry > now;
+                });
+                if (cachedReservedCoins.length > 0) {
+                    // Wait 10 seconds and try again
+                    console.log("No unspent coins available. Waiting 10 seconds...");
+                    await new Promise((resolve) => setTimeout(resolve, 10000));
+                }
+                else {
+                    // No unspent coins and no reserved coins
+                    throw new Error("No unspent coins available.");
+                }
             }
-        });
-        const ownerPuzzleHash = await this.getOwnerPuzzleHash();
-        const coinsResp = await peer.getAllUnspentCoins(ownerPuzzleHash, config_1.MIN_HEIGHT, buffer_1.Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex"));
-        const unspentCoins = coinsResp.coins.filter((coin) => !omitCoinIds.includes((0, datalayer_driver_1.getCoinId)(coin).toString("hex")));
-        const selectedCoins = (0, datalayer_driver_1.selectCoins)(unspentCoins, feeBigInt + coinAmount);
-        if (selectedCoins.length === 0) {
-            throw new Error("No unspent coins available.");
         }
+        // Reserve the selected coins
         selectedCoins.forEach((coin) => {
             const coinId = (0, datalayer_driver_1.getCoinId)(coin).toString("hex");
             cache.set(coinId, { coinId, expiry: Date.now() + CACHE_DURATION });

package/dist/blockchain/coins.d.ts

@@ -1,6 +1,5 @@
-import { Peer, Coin, CoinSpend } from "datalayer-driver";
+import { Peer, CoinSpend } from "@dignetwork/datalayer-driver";
 export declare const DEFAULT_FEE_COIN_COST = 64000000;
 export declare const calculateFeeForCoinSpends: (peer: Peer, coinSpends: CoinSpend[] | null) => Promise<bigint>;
-export declare const selectUnspentCoins: (peer: Peer, coinAmount: bigint, feeBigInt: bigint, omitCoins?: Coin[], walletName?: string) => Promise<Coin[]>;
 export declare const isCoinSpendable: (peer: Peer, coinId: Buffer) => Promise<boolean>;
 //# sourceMappingURL=coins.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"coins.d.ts","sourceRoot":"","sources":["../../src/blockchain/coins.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,IAAI,EACJ,IAAI,EAEJ,SAAS,EAEV,MAAM,kBAAkB,CAAC;AAK1B,eAAO,MAAM,qBAAqB,WAAa,CAAC;AAWhD,eAAO,MAAM,yBAAyB,SAC9B,IAAI,cACE,SAAS,EAAE,GAAG,IAAI,KAC7B,OAAO,CAAC,MAAM,CA4BhB,CAAC;AAEF,eAAO,MAAM,kBAAkB,SACvB,IAAI,cACE,MAAM,aACP,MAAM,cACN,IAAI,EAAE,eACL,MAAM,KACjB,OAAO,CAAC,IAAI,EAAE,CAoEhB,CAAC;AAGF,eAAO,MAAM,eAAe,SACpB,IAAI,UACF,MAAM,KACb,OAAO,CAAC,OAAO,CAWjB,CAAC"}
+{"version":3,"file":"coins.d.ts","sourceRoot":"","sources":["../../src/blockchain/coins.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,IAAI,EAGJ,SAAS,EAEV,MAAM,8BAA8B,CAAC;AAMtC,eAAO,MAAM,qBAAqB,WAAa,CAAC;AAWhD,eAAO,MAAM,yBAAyB,SAC9B,IAAI,cACE,SAAS,EAAE,GAAG,IAAI,KAC7B,OAAO,CAAC,MAAM,CA4BhB,CAAC;AAEF,eAAO,MAAM,eAAe,SACpB,IAAI,UACF,MAAM,KACb,OAAO,CAAC,OAAO,CAWjB,CAAC"}