@dignetwork/dig-sdk 0.0.1-alpha.125 → 0.0.1-alpha.126

package/dist/DigNetwork/DigNetwork.d.ts

@@ -6,6 +6,7 @@ export declare class DigNetwork {
     private peerBlacklist;
     constructor(storeId: string);
     static subscribeToStore(storeId: string): Promise<void>;
+    static getUdiContent(udi: string): Promise<void>;
     static findPeerWithStoreKey(storeId: string, rootHash: string, key?: string, intialBlackList?: string[]): Promise<DigPeer | null>;
     static unsubscribeFromStore(storeId: string): void;
     syncStoreFromPeers(maxRootsToProcess?: number): Promise<void>;

package/dist/DigNetwork/DigNetwork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA2DZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO5C,kBAAkB,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiG7D,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}
+{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,aAAa,CAAC,GAAG,EAAE,MAAM;WAIzB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA2DZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO5C,kBAAkB,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiG7D,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}

package/dist/DigNetwork/DigNetwork.js

@@ -46,6 +46,9 @@ class DigNetwork {
         const digNetwork = new DigNetwork(storeId);
         await digNetwork.syncStoreFromPeers();
     }
+    static async getUdiContent(udi) {
+        // TODO: Implement this method
+    }
     static async findPeerWithStoreKey(storeId, rootHash, key, intialBlackList = []) {
         const peerBlackList = intialBlackList;
         const serverCoin = new blockchain_1.ServerCoin(storeId);

package/dist/blockchain/DataStore.d.ts

@@ -35,13 +35,11 @@ export declare class DataStore {
     private static calculateFolderSize;
     static getAllStores(): DataStore[];
     /**
-    * Monitors the store indefinitely by syncing it with a peer.
-    * Logs store retrieval and caching operations. If an error occurs, logs the error and restarts the process after a short delay.
-    * Only one monitor can be active per storeId.
-    * @param {string} storeId - The store identifier to monitor.
-    * @returns {Promise<void>} Never resolves; runs indefinitely.
-    */
-    static monitorStoreIndefinitely(storeId: string): Promise<void>;
+     * Fetches the latest coin information using the StoreMonitorRegistry.
+     * Registers the storeId if it's not already registered, retrieves the cached value, and returns it.
+     *
+     * @returns {Promise<{ latestStore: DataStoreDriver; latestHeight: number; latestHash: Buffer }>}
+     */
     fetchCoinInfo(): Promise<{
         latestStore: DataStoreDriver;
         latestHeight: number;

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

@@ -1 +1 @@
-{"version":3,"file":"DataStore.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,SAAS,IAAI,eAAe,EAE5B,iBAAiB,EAIlB,MAAM,8BAA8B,CAAC;AAYtC,OAAO,EAAE,eAAe,EAAW,MAAM,UAAU,CAAC;AAGpD,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAgBjD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;gBAEpD,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAqB/D,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,IAAI,IAAI,iBAAiB,CAEnC;IAEM,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;WAMN,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;WAOtD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;WAK1C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS;WAiBtD,MAAM,CACxB,MAAM,GAAE,qBAA0B,GACjC,OAAO,CAAC,SAAS,CAAC;mBAyCA,IAAI;IA4FzB;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5C;;;OAGG;WACiB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIxD;;;;OAIG;mBACkB,mBAAmB;WAqB1B,YAAY,IAAI,SAAS,EAAE;IAWxC;;;;;;MAME;WACkB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA4HhE,aAAa,IAAI,OAAO,CAAC;QACpC,WAAW,EAAE,eAAe,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IAyGW,wBAAwB,IAAI,OAAO,CAAC;QAC/C,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IAiBW,iBAAiB,IAAI,OAAO,CAAC;QACxC,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;YA0BY,iBAAiB;IAYlB,cAAc,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA4C/D,oBAAoB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAexD,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAM5B,uBAAuB,CAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC;IAkBN,cAAc,CACzB,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,eAAe,CAAC;IAgD3B;;;;;OAKG;IACU,qBAAqB,CAChC,QAAQ,EAAE,MAAM,EAChB,kBAAkB,GAAE,OAAe,GAClC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CA6C7C"}
+{"version":3,"file":"DataStore.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,SAAS,IAAI,eAAe,EAE5B,iBAAiB,EAIlB,MAAM,8BAA8B,CAAC;AAWtC,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAG3C,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAcjD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;gBAEpD,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAiB/D,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,IAAI,IAAI,iBAAiB,CAEnC;IAEM,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAIlB,SAAS,IAAI,MAAM;WAMN,cAAc,IAAI,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;WAOtD,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;WAK1C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS;WAiBtD,MAAM,CACxB,MAAM,GAAE,qBAA0B,GACjC,OAAO,CAAC,SAAS,CAAC;mBAyCA,IAAI;IA4FzB;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5C;;;OAGG;WACiB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAIxD;;;;OAIG;mBACkB,mBAAmB;WAqB1B,YAAY,IAAI,SAAS,EAAE;IAWzC;;;;;OAKG;IACU,aAAa,IAAI,OAAO,CAAC;QACpC,WAAW,EAAE,eAAe,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IAkCW,wBAAwB,IAAI,OAAO,CAAC;QAC/C,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IAiBW,iBAAiB,IAAI,OAAO,CAAC;QACxC,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;YA0BY,iBAAiB;IAYlB,cAAc,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA4C/D,oBAAoB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAexD,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAM5B,uBAAuB,CAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC;IAkBN,cAAc,CACzB,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,eAAe,CAAC;IAgD3B;;;;;OAKG;IACU,qBAAqB,CAChC,QAAQ,EAAE,MAAM,EAChB,kBAAkB,GAAE,OAAe,GAClC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CA6C7C"}

package/dist/blockchain/DataStore.js

@@ -20,7 +20,7 @@ const FileCache_1 = require("../utils/FileCache");
 const DataStoreSerializer_1 = require("./DataStoreSerializer");
 const node_cache_1 = __importDefault(require("node-cache"));
 const config_2 = require("../utils/config");
-const utils_1 = require("../utils");
+const StoreMonitorRegistry_1 = require("./StoreMonitorRegistry");
 // Initialize the cache with a TTL of 180 seconds (3 minutes)
 const rootHistoryCache = new node_cache_1.default({ stdTTL: 180 });
 const stat = (0, util_1.promisify)(fs_1.default.stat);
@@ -39,9 +39,6 @@ class DataStore {
             };
         }
         this.tree = new DataIntegrityTree_1.DataIntegrityTree(storeId, _options);
-        if (!utils_1.Environment.CLI_MODE) {
-            DataStore.monitorStoreIndefinitely(this.storeId);
-        }
     }
     get StoreId() {
         return this.storeId;
@@ -205,143 +202,36 @@ class DataStore {
         return storIds.map((storeId) => DataStore.from(storeId));
     }
     /**
-    * Monitors the store indefinitely by syncing it with a peer.
-    * Logs store retrieval and caching operations. If an error occurs, logs the error and restarts the process after a short delay.
-    * Only one monitor can be active per storeId.
-    * @param {string} storeId - The store identifier to monitor.
-    * @returns {Promise<void>} Never resolves; runs indefinitely.
-    */
-    static async monitorStoreIndefinitely(storeId) {
-        // Check if a monitor is already running for this storeId
-        if (this.activeMonitors.get(storeId)) {
-            console.log("Monitor:", `Monitor already running for storeId: ${storeId}`);
-            return;
-        }
-        // Set the monitor as active
-        this.activeMonitors.set(storeId, true);
-        const storeCoinCache = new FileCache_1.FileCache(`stores`);
-        // Clear the cache at the start
-        console.log("Monitor:", `Clearing cache for storeId: ${storeId}`);
-        storeCoinCache.delete(storeId);
-        while (true) {
-            try {
-                console.log("Monitor:", `Connecting to peer for storeId: ${storeId}`);
-                const peer = await FullNodePeer_1.FullNodePeer.connect();
-                const cachedInfo = 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.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}`);
-                    storeCoinCache.set(storeId, {
-                        latestStore: serializedLatestStore,
-                        latestHeight,
-                        latestHash: latestHash.toString("hex"),
-                    });
-                    continue; // Continue monitoring
-                }
-                // If no cached info exists, log and sync from the creation height
-                console.log("Monitor:", `No cached info found for storeId: ${storeId}. Retrieving creation height.`);
-                const dataStore = DataStore.from(storeId);
-                const { createdAtHeight, createdAtHash } = await dataStore.getCreationHeight();
-                // Sync store from the peer using launcher ID
-                console.log("Monitor:", `Syncing store from launcher ID for storeId: ${storeId}`);
-                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();
-                console.log("Monitor:", `Caching new store info for storeId: ${storeId}`);
-                storeCoinCache.set(storeId, {
-                    latestStore: serializedLatestStore,
-                    latestHeight,
-                    latestHash: latestHash.toString("hex"),
-                });
-            }
-            catch (error) {
-                console.error("Monitor:", `Error in monitorStoreIndefinitely for storeId: ${storeId} - ${error.message}`);
-                // Delay before restarting to avoid rapid retries
-                await new Promise((resolve) => setTimeout(resolve, 5000));
-            }
-        }
-    }
+     * Fetches the latest coin information using the StoreMonitorRegistry.
+     * Registers the storeId if it's not already registered, retrieves the cached value, and returns it.
+     *
+     * @returns {Promise<{ latestStore: DataStoreDriver; latestHeight: number; latestHash: Buffer }>}
+     */
     async fetchCoinInfo() {
+        const storeMonitor = StoreMonitorRegistry_1.StoreMonitorRegistry.getInstance();
         try {
-            // Initialize the cache for the current storeId's coin info
-            const storeCoinCache = new FileCache_1.FileCache(`stores`);
-            // Try to get cached store info
-            const cachedInfo = storeCoinCache.get(this.storeId);
-            if (cachedInfo) {
-                try {
-                    const { latestStore: serializedStore, latestHeight: previousHeight, latestHash: previousHash, } = cachedInfo;
-                    // Deserialize the stored data using DataStoreSerializer
-                    const { latestStore: previousInfo } = DataStoreSerializer_1.DataStoreSerializer.deserialize({
-                        latestStore: serializedStore,
-                        latestHeight: previousHeight.toString(),
-                        latestHash: previousHash,
-                    });
-                    // Sync with peer if necessary
-                    const peer = await FullNodePeer_1.FullNodePeer.connect();
-                    const { latestStore, latestHeight } = await peer.syncStore(previousInfo, previousHeight, Buffer.from(previousHash, "hex"), false);
-                    const latestHash = await peer.getHeaderHash(latestHeight);
-                    // Serialize the store data for caching
-                    const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(latestStore, latestHeight, latestHash).serialize();
-                    // Cache updated store info
-                    storeCoinCache.set(this.storeId, {
-                        latestStore: serializedLatestStore,
-                        latestHeight,
-                        latestHash: latestHash.toString("hex"),
-                    });
-                    return { latestStore, latestHeight, latestHash };
-                }
-                catch {
-                    // Return cached info if sync fails
-                    const { latestStore, latestHeight, latestHash } = DataStoreSerializer_1.DataStoreSerializer.deserialize({
-                        latestStore: cachedInfo.latestStore,
-                        latestHeight: cachedInfo.latestHeight.toString(),
-                        latestHash: cachedInfo.latestHash,
-                    });
-                    return {
-                        latestStore,
-                        latestHeight,
-                        latestHash: latestHash,
-                    };
-                }
+            // Register the storeId with a no-op callback. If already registered, the registry will handle it.
+            await storeMonitor.registerStore(this.storeId, () => {
+                // No operation callback since we're fetching the cache directly
+            });
+            // Retrieve the latest cached store information
+            const cachedInfo = await storeMonitor.getLatestCache(this.storeId);
+            if (!cachedInfo) {
+                throw new Error(`No cached info found for storeId: ${this.storeId}`);
             }
-            // Use getCreationHeight to retrieve height and hash information
-            const { createdAtHeight, createdAtHash } = await this.getCreationHeight();
-            // Sync store from peer
-            const peer = await FullNodePeer_1.FullNodePeer.connect();
-            const { latestStore, latestHeight } = await peer.syncStoreFromLauncherId(Buffer.from(this.storeId, "hex"), createdAtHeight, createdAtHash, false);
-            const latestHash = await peer.getHeaderHash(latestHeight);
-            // Serialize the latest store info for caching
-            const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(latestStore, latestHeight, latestHash).serialize();
-            // Cache the latest store info
-            storeCoinCache.set(this.storeId, {
-                latestStore: serializedLatestStore,
-                latestHeight,
-                latestHash: latestHash.toString("hex"),
+            const deserializedStore = DataStoreSerializer_1.DataStoreSerializer.deserialize({
+                latestStore: cachedInfo.latestStore,
+                latestHeight: cachedInfo.latestHeight.toString(),
+                latestHash: cachedInfo.latestHash
             });
-            return { latestStore, latestHeight, latestHash };
+            return {
+                latestStore: deserializedStore.latestStore,
+                latestHeight: deserializedStore.latestHeight,
+                latestHash: deserializedStore.latestHash,
+            };
         }
         catch (error) {
-            console.trace("Failed to fetch coin info", error);
-            throw error;
+            throw new Error(`Failed to fetch coin info for storeId ${this.storeId}: ${error.message}`);
         }
     }
     async cacheStoreCreationHeight() {

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;IAiChB;;;;;OAKG;IACU,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAkCtE;;;;;;OAMG;YACW,YAAY;IA4B1B;;;;;OAKG;YACW,YAAY;IAuG1B;;;;OAIG;YACW,sBAAsB;IAkDpC;;;;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,242 @@
+"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)) {
+            console.log(`Registry: Monitor already running for storeId: ${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 = 60000; // 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) {
+        console.log(`Monitor: Fetching and caching latest store info for storeId: ${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
+        console.log(`Monitor: Syncing store from launcher ID for storeId: ${storeId}`);
+        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();
+        console.log(`Monitor: Caching new store info for storeId: ${storeId}`);
+        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/index.d.ts

@@ -5,4 +5,5 @@ export * from './FullNodePeer';
 export * from './DataStoreSerializer';
 export * from './ServerCoin';
 export * from "./Wallet";
+export * from './StoreMonitorRegistry';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/blockchain/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAa,gBAAgB,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/blockchain/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAa,gBAAgB,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,wBAAwB,CAAC"}

package/dist/blockchain/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./FullNodePeer"), exports);
 __exportStar(require("./DataStoreSerializer"), exports);
 __exportStar(require("./ServerCoin"), exports);
 __exportStar(require("./Wallet"), exports);
+__exportStar(require("./StoreMonitorRegistry"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/dig-sdk",
-  "version": "0.0.1-alpha.125",
+  "version": "0.0.1-alpha.126",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",

package/dist/blockchain/StoreInfoCacheUpdater.d.ts

@@ -1,16 +0,0 @@
-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

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

@@ -1,242 +0,0 @@
-"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;