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

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.127",
   "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;