@dignetwork/dig-sdk 0.0.1-alpha.18 → 0.0.1-alpha.181

package/dist/blockchain/ServerCoin.js

@@ -5,27 +5,30 @@ 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 utils_1 = require("../utils");
+const node_cache_1 = __importDefault(require("node-cache"));
 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 +36,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 +49,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 +57,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 +74,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 +98,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 = await 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 +115,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 (utils_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 host = await (0, utils_1.getPublicHost)();
+        if (host) {
+            blacklist.push(host);
+        }
+        const serverCoinPeers = await this.getAllEpochPeers(epoch, blacklist);
+        if (utils_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 +200,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 +215,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 +299,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/StoreMonitorRegistry.d.ts

@@ -0,0 +1,85 @@
+import { DataStoreSerializer } from "./DataStoreSerializer";
+/**
+ * Represents the structure of cached store information.
+ */
+interface StoreCacheEntry {
+    latestStore: ReturnType<DataStoreSerializer["serialize"]>;
+    latestHeight: number;
+    latestHash: string;
+}
+/**
+ * Callback type to be invoked when the store is updated.
+ */
+type StoreUpdateCallback = (storeId: string, updatedStore: StoreCacheEntry) => void;
+/**
+ * StoreMonitorRegistry manages monitoring of multiple storeIds.
+ * It encapsulates cache management and ensures only one monitor runs per storeId.
+ */
+export declare class StoreMonitorRegistry {
+    private static instance;
+    private activeMonitors;
+    private storeCoinCache;
+    private cachePopulationPromises;
+    /**
+     * Private constructor to enforce singleton pattern.
+     */
+    private constructor();
+    /**
+     * Retrieves the singleton instance of the registry.
+     * @returns {StoreMonitorRegistry} The singleton instance.
+     */
+    static getInstance(): StoreMonitorRegistry;
+    /**
+     * Registers a storeId with a callback to be invoked upon updates.
+     * Immediately updates the cache and invokes the callback before starting the monitor.
+     * @param {string} storeId - The store identifier to monitor.
+     * @param {StoreUpdateCallback} callback - The callback to execute when the store is updated.
+     */
+    registerStore(storeId: string, callback: StoreUpdateCallback): Promise<void>;
+    /**
+     * Retrieves the latest cached entry for a given storeId.
+     * If no cache exists, it fetches and caches the store info before returning.
+     * @param {string} storeId - The store identifier.
+     * @returns {Promise<StoreCacheEntry>} The latest cached entry.
+     */
+    getLatestCache(storeId: string): Promise<StoreCacheEntry>;
+    /**
+     * Starts the monitor for a specific storeId.
+     * Ensures that the monitor restarts upon any error.
+     * Implements an exponential backoff strategy for retries.
+     * @param {string} storeId - The store identifier to monitor.
+     * @param {StoreUpdateCallback} callback - The callback to invoke upon updates.
+     */
+    private startMonitor;
+    /**
+     * Monitors a single store indefinitely.
+     * Executes a single iteration of the monitoring logic.
+     * @param {string} storeId - The store identifier to monitor.
+     * @param {StoreUpdateCallback} callback - The callback to invoke upon updates.
+     */
+    private monitorStore;
+    /**
+     * Fetches the latest store information and updates the cache.
+     * @param {string} storeId - The store identifier.
+     * @returns {Promise<StoreCacheEntry>} The latest store information.
+     */
+    private fetchAndCacheStoreInfo;
+    /**
+     * Utility method to introduce a delay.
+     * @param {number} ms - The delay duration in milliseconds.
+     * @returns {Promise<void>} Resolves after the specified delay.
+     */
+    private delay;
+    /**
+     * Unregisters a storeId, stopping its monitor.
+     * @param {string} storeId - The store identifier to stop monitoring.
+     */
+    unregisterStore(storeId: string): void;
+    /**
+     * Stops all active monitors and clears the registry.
+     * Useful for graceful shutdowns.
+     */
+    stopAllMonitors(): void;
+}
+export {};
+//# sourceMappingURL=StoreMonitorRegistry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StoreMonitorRegistry.d.ts","sourceRoot":"","sources":["../../src/blockchain/StoreMonitorRegistry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAK5D;;GAEG;AACH,UAAU,eAAe;IACvB,WAAW,EAAE,UAAU,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC;IAC1D,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,KAAK,mBAAmB,GAAG,CACzB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,eAAe,KAC1B,IAAI,CAAC;AAEV;;;GAGG;AACH,qBAAa,oBAAoB;IAE/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAuB;IAG9C,OAAO,CAAC,cAAc,CAAmC;IAGzD,OAAO,CAAC,cAAc,CAA6B;IAGnD,OAAO,CAAC,uBAAuB,CAAwC;IAEvE;;OAEG;IACH,OAAO;IASP;;;OAGG;WACW,WAAW,IAAI,oBAAoB;IAOjD;;;;;OAKG;IACU,aAAa,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,IAAI,CAAC;IAgChB;;;;;OAKG;IACU,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkCtE;;;;;;OAMG;YACW,YAAY;IA4B1B;;;;;OAKG;YACW,YAAY;IAuG1B;;;;OAIG;YACW,sBAAsB;IA2CpC;;;;OAIG;YACW,KAAK;IAInB;;;OAGG;IACI,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAS7C;;;OAGG;IACI,eAAe,IAAI,IAAI;CAI/B"}

package/dist/blockchain/StoreMonitorRegistry.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreMonitorRegistry = void 0;
+const FullNodePeer_1 = require("./FullNodePeer");
+const utils_1 = require("../utils");
+const DataStoreSerializer_1 = require("./DataStoreSerializer");
+const DataStore_1 = require("./DataStore");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
+const utils_2 = require("../utils");
+/**
+ * StoreMonitorRegistry manages monitoring of multiple storeIds.
+ * It encapsulates cache management and ensures only one monitor runs per storeId.
+ */
+class StoreMonitorRegistry {
+    /**
+     * Private constructor to enforce singleton pattern.
+     */
+    constructor() {
+        this.activeMonitors = new Map();
+        this.storeCoinCache = new utils_1.FileCache("stores", utils_1.USER_DIR_PATH);
+        this.cachePopulationPromises = new Map();
+    }
+    /**
+     * Retrieves the singleton instance of the registry.
+     * @returns {StoreMonitorRegistry} The singleton instance.
+     */
+    static getInstance() {
+        if (!StoreMonitorRegistry.instance) {
+            StoreMonitorRegistry.instance = new StoreMonitorRegistry();
+        }
+        return StoreMonitorRegistry.instance;
+    }
+    /**
+     * Registers a storeId with a callback to be invoked upon updates.
+     * Immediately updates the cache and invokes the callback before starting the monitor.
+     * @param {string} storeId - The store identifier to monitor.
+     * @param {StoreUpdateCallback} callback - The callback to execute when the store is updated.
+     */
+    async registerStore(storeId, callback) {
+        if (this.activeMonitors.has(storeId)) {
+            return;
+        }
+        console.log(`Registry: Registering monitor for storeId: ${storeId}`);
+        this.activeMonitors.set(storeId, callback);
+        try {
+            // Immediately fetch and cache the latest store info
+            const initialStore = await this.fetchAndCacheStoreInfo(storeId);
+            // Invoke the callback with the initial store info
+            callback(storeId, initialStore);
+        }
+        catch (error) {
+            console.error(`Registry: Failed to perform initial cache update for storeId: ${storeId} - ${error.message}`);
+            // Decide whether to unregister the monitor or proceed
+            // For this example, we'll proceed to start the monitor
+        }
+        // No monitoring in cli mode
+        if (!utils_2.Environment.CLI_MODE) {
+            // Start monitoring asynchronously
+            this.startMonitor(storeId, callback).catch((error) => {
+                console.error(`Registry: Unexpected error in startMonitor for storeId: ${storeId} - ${error.message}`);
+            });
+        }
+    }
+    /**
+     * Retrieves the latest cached entry for a given storeId.
+     * If no cache exists, it fetches and caches the store info before returning.
+     * @param {string} storeId - The store identifier.
+     * @returns {Promise<StoreCacheEntry>} The latest cached entry.
+     */
+    async getLatestCache(storeId) {
+        // if in CLI mode, always fetch the latest store info directly
+        if (!utils_2.Environment.CLI_MODE) {
+            let cachedInfo = this.storeCoinCache.get(storeId);
+            if (cachedInfo) {
+                return cachedInfo;
+            }
+            // If cache is missing, fetch and cache it
+            console.log(`getLatestCache: No cache found for storeId: ${storeId}. Fetching...`);
+            // Prevent duplicate fetches for the same storeId
+            if (this.cachePopulationPromises.has(storeId)) {
+                return this.cachePopulationPromises.get(storeId);
+            }
+        }
+        const fetchPromise = this.fetchAndCacheStoreInfo(storeId)
+            .then((store) => {
+            this.cachePopulationPromises.delete(storeId);
+            return store;
+        })
+            .catch((error) => {
+            this.cachePopulationPromises.delete(storeId);
+            throw error;
+        });
+        this.cachePopulationPromises.set(storeId, fetchPromise);
+        return fetchPromise;
+    }
+    /**
+     * Starts the monitor for a specific storeId.
+     * Ensures that the monitor restarts upon any error.
+     * Implements an exponential backoff strategy for retries.
+     * @param {string} storeId - The store identifier to monitor.
+     * @param {StoreUpdateCallback} callback - The callback to invoke upon updates.
+     */
+    async startMonitor(storeId, callback) {
+        let retryCount = 0;
+        const maxRetryDelay = 1000; // 60 seconds
+        while (this.activeMonitors.has(storeId)) {
+            try {
+                await this.monitorStore(storeId, callback);
+                retryCount = 0; // Reset on success
+            }
+            catch (error) {
+                console.error(`Registry: Monitor for storeId: ${storeId} encountered an error: ${error.message}. Restarting monitor...`);
+                const delayTime = maxRetryDelay;
+                console.log(`Registry: Waiting for ${delayTime / 1000} seconds before retrying...`);
+                await this.delay(delayTime);
+                retryCount++;
+            }
+        }
+        console.log(`Registry: Monitor for storeId: ${storeId} has been stopped.`);
+    }
+    /**
+     * Monitors a single store indefinitely.
+     * Executes a single iteration of the monitoring logic.
+     * @param {string} storeId - The store identifier to monitor.
+     * @param {StoreUpdateCallback} callback - The callback to invoke upon updates.
+     */
+    async monitorStore(storeId, callback) {
+        console.log(`Monitor: Starting monitor iteration for storeId: ${storeId}`);
+        try {
+            console.log(`Monitor: Connecting to peer for storeId: ${storeId}`);
+            const peer = await FullNodePeer_1.FullNodePeer.connect();
+            const cachedInfo = this.storeCoinCache.get(storeId);
+            if (cachedInfo) {
+                // Log cached store info retrieval
+                console.log(`Monitor: Cached store info found for storeId: ${storeId}, syncing...`);
+                // Deserialize cached info and wait for the coin to be spent
+                const previousStore = DataStoreSerializer_1.DataStoreSerializer.deserialize({
+                    latestStore: cachedInfo.latestStore,
+                    latestHeight: cachedInfo.latestHeight.toString(),
+                    latestHash: cachedInfo.latestHash,
+                });
+                console.log(`Monitor: Waiting for coin to be spent for storeId: ${storeId}...`);
+                const dataStore = DataStore_1.DataStore.from(storeId);
+                const { createdAtHeight, createdAtHash } = await dataStore.getCreationHeight();
+                await peer.waitForCoinToBeSpent((0, datalayer_driver_1.getCoinId)(previousStore.latestStore.coin), createdAtHeight, createdAtHash);
+                // Sync store and get updated details
+                console.log(`Monitor: Syncing store for storeId: ${storeId}`);
+                const { latestStore, latestHeight } = await peer.syncStore(previousStore.latestStore, createdAtHeight, createdAtHash, false);
+                const latestHash = await peer.getHeaderHash(latestHeight);
+                console.log(`Monitor: Store synced for storeId: ${storeId}, coin id: ${(0, datalayer_driver_1.getCoinId)(latestStore.coin).toString("hex")}`);
+                // Serialize and cache the updated store info
+                const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(latestStore, latestHeight, latestHash).serialize();
+                console.log(`Monitor: Caching updated store info for storeId: ${storeId}`);
+                this.storeCoinCache.set(storeId, {
+                    latestStore: serializedLatestStore,
+                    latestHeight,
+                    latestHash: latestHash.toString("hex"),
+                });
+                // Invoke the callback with updated store info
+                const updatedStore = this.storeCoinCache.get(storeId);
+                if (updatedStore) {
+                    callback(storeId, updatedStore);
+                }
+                else {
+                    console.warn(`Monitor: Updated store info for storeId: ${storeId} is missing after caching.`);
+                }
+                return; // Successful iteration
+            }
+            // If no cached info exists, fetch initial store info
+            console.log(`Monitor: No cached info found for storeId: ${storeId}. Fetching initial store info.`);
+            // Fetch and cache the latest store info
+            const newStore = await this.fetchAndCacheStoreInfo(storeId);
+            // Invoke the callback with the new store info
+            callback(storeId, newStore);
+        }
+        catch (error) {
+            console.error(`Monitor: Error monitoring storeId: ${storeId} - ${error.message}`);
+            // Propagate the error to trigger a restart in startMonitor
+            throw error;
+        }
+    }
+    /**
+     * Fetches the latest store information and updates the cache.
+     * @param {string} storeId - The store identifier.
+     * @returns {Promise<StoreCacheEntry>} The latest store information.
+     */
+    async fetchAndCacheStoreInfo(storeId) {
+        const peer = await FullNodePeer_1.FullNodePeer.connect();
+        const dataStore = DataStore_1.DataStore.from(storeId);
+        const { createdAtHeight, createdAtHash } = await dataStore.getCreationHeight();
+        // Sync store from the peer using launcher ID
+        const { latestStore, latestHeight } = await peer.syncStoreFromLauncherId(Buffer.from(storeId, "hex"), createdAtHeight, createdAtHash, false);
+        const latestHash = await peer.getHeaderHash(latestHeight);
+        // Serialize and cache the new store info
+        const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(latestStore, latestHeight, latestHash).serialize();
+        this.storeCoinCache.set(storeId, {
+            latestStore: serializedLatestStore,
+            latestHeight,
+            latestHash: latestHash.toString("hex"),
+        });
+        // Return the cached store info
+        const newStore = this.storeCoinCache.get(storeId);
+        if (!newStore) {
+            throw new Error(`Failed to cache store info for storeId: ${storeId} after fetching.`);
+        }
+        return newStore;
+    }
+    /**
+     * Utility method to introduce a delay.
+     * @param {number} ms - The delay duration in milliseconds.
+     * @returns {Promise<void>} Resolves after the specified delay.
+     */
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Unregisters a storeId, stopping its monitor.
+     * @param {string} storeId - The store identifier to stop monitoring.
+     */
+    unregisterStore(storeId) {
+        if (this.activeMonitors.has(storeId)) {
+            this.activeMonitors.delete(storeId);
+            console.log(`Registry: Unregistered monitor for storeId: ${storeId}`);
+        }
+        else {
+            console.log(`Registry: No active monitor found for storeId: ${storeId}`);
+        }
+    }
+    /**
+     * Stops all active monitors and clears the registry.
+     * Useful for graceful shutdowns.
+     */
+    stopAllMonitors() {
+        this.activeMonitors.clear();
+        console.log(`Registry: All monitors have been stopped.`);
+    }
+}
+exports.StoreMonitorRegistry = StoreMonitorRegistry;

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"}