@dignetwork/dig-sdk 0.0.1-alpha.11 → 0.0.1-alpha.110

package/dist/blockchain/DataStore.d.ts

@@ -1,4 +1,4 @@
-import { DataStore as DataStoreDriver, DataStoreMetadata } from "datalayer-driver";
+import { DataStore as DataStoreDriver, DataStoreMetadata } from "@dignetwork/datalayer-driver";
 import { RootHistoryItem } from "../types";
 import { DataIntegrityTree, DataIntegrityTreeOptions } from "../DataIntegrityTree";
 import { CreateStoreUserInputs } from "../types";
@@ -13,7 +13,7 @@ export declare class DataStore {
     serialize(): string;
     static getActiveStore(): Promise<DataStore | undefined>;
     static deserialize(serialized: string): DataStore;
-    static from(storeId: string | Buffer): DataStore;
+    static from(storeId: string | Buffer, rootHash?: string): DataStore;
     static create(inputs?: CreateStoreUserInputs): Promise<DataStore>;
     private static mint;
     /**
@@ -38,19 +38,30 @@ export declare class DataStore {
         latestHeight: number;
         latestHash: Buffer;
     }>;
+    cacheStoreCreationHeight(): Promise<{
+        createdAtHeight: number;
+        createdAtHash: Buffer;
+    }>;
     getCreationHeight(): Promise<{
         createdAtHeight: number;
         createdAtHash: Buffer;
     }>;
     private setCreationHeight;
-    getRootHistory(): Promise<RootHistoryItem[]>;
-    getLocalRootHistory(): Promise<RootHistoryItem[] | undefined>;
-    validate(): Promise<boolean>;
+    getRootHistory(bustCache?: boolean): Promise<RootHistoryItem[]>;
+    generateManifestFile(folderPath?: string): Promise<void>;
     getMetaData(): Promise<DataStoreMetadata>;
     isSynced(): Promise<boolean>;
     hasMetaWritePermissions(publicSyntheticKey?: Buffer): Promise<boolean>;
     updateMetadata(metadata: DataStoreMetadata): Promise<DataStoreDriver>;
-    getFileSetForRootHash(rootHash: string): Promise<string[]>;
-    getManifestHashes(): string[];
+    /**
+     * Retrieve the file set for a given root hash and validate file integrity.
+     *
+     * @param {string} rootHash - The root hash to fetch the file set.
+     * @returns {Promise<{ fileName: string, file: string }[]>} - An array of unique file objects.
+     */
+    getFileSetForRootHash(rootHash: string, skipIntegirtyCheck?: boolean): Promise<{
+        name: string;
+        path: string;
+    }[]>;
 }
 //# sourceMappingURL=DataStore.d.ts.map

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,kBAAkB,CAAC;AAY1B,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;AASjD,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,IAAI,CAAoB;gBAEpB,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,GAAG,SAAS;WAYnC,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;IAW5B,aAAa,IAAI,OAAO,CAAC;QACpC,WAAW,EAAE,eAAe,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IAyGW,iBAAiB,IAAI,OAAO,CAAC;QACxC,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;YA0BY,iBAAiB;IAYlB,cAAc,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAsB5C,mBAAmB,IAAI,OAAO,CAAC,eAAe,EAAE,GAAG,SAAS,CAAC;IAiB7D,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IA+E5B,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAKzC,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAgB5B,uBAAuB,CAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC;IAkBN,cAAc,CACzB,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,eAAe,CAAC;IA+Cd,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiChE,iBAAiB,IAAI,MAAM,EAAE;CAUrC"}
+{"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,EAAW,MAAM,UAAU,CAAC;AAGpD,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;gBAEpB,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;IAW5B,aAAa,IAAI,OAAO,CAAC;QACpC,WAAW,EAAE,eAAe,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IAmEW,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;IA+C3B;;;;;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

@@ -6,18 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStore = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const datalayer_driver_1 = require("datalayer-driver");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const util_1 = require("util");
 const FullNodePeer_1 = require("./FullNodePeer");
 const Wallet_1 = require("./Wallet");
 const config_1 = require("../utils/config");
 const coins_1 = require("./coins");
-const utils_1 = require("../utils");
+const colorette_1 = require("colorette");
 const hashUtils_1 = require("../utils/hashUtils");
 const DataIntegrityTree_1 = require("../DataIntegrityTree");
 const prompts_1 = require("../prompts");
 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 StoreInfoCacheUpdater_1 = require("./StoreInfoCacheUpdater");
+// 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);
 const readdir = (0, util_1.promisify)(fs_1.default.readdir);
 class DataStore {
@@ -62,12 +67,15 @@ class DataStore {
         const parsed = JSON.parse(serialized);
         return new DataStore(parsed.storeId);
     }
-    static from(storeId) {
+    static from(storeId, rootHash) {
         const existingTreeOptions = {
             storageMode: "local",
             storeDir: config_1.STORE_PATH,
             disableInitialize: true,
         };
+        if (rootHash) {
+            existingTreeOptions.rootHash = rootHash;
+        }
         if (storeId instanceof Buffer) {
             return new DataStore(storeId.toString("hex"), existingTreeOptions);
         }
@@ -195,47 +203,26 @@ class DataStore {
     }
     async fetchCoinInfo() {
         try {
+            // Kick off the updater instance in the backgounf if not already running
+            StoreInfoCacheUpdater_1.StoreInfoCacheUpdater.initInstance();
             // 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,
-                    };
-                }
+                // If we have cached info, return it directly
+                const { latestStore, latestHeight } = DataStoreSerializer_1.DataStoreSerializer.deserialize({
+                    latestStore: cachedInfo.latestStore,
+                    latestHeight: cachedInfo.latestHeight.toString(),
+                    latestHash: cachedInfo.latestHash,
+                });
+                return {
+                    latestStore,
+                    latestHeight: cachedInfo.latestHeight,
+                    latestHash: Buffer.from(cachedInfo.latestHash, "hex"),
+                };
             }
+            // If no cached info, proceed to fetch and cache it
             // Use getCreationHeight to retrieve height and hash information
             const { createdAtHeight, createdAtHash } = await this.getCreationHeight();
             // Sync store from peer
@@ -257,22 +244,31 @@ class DataStore {
             throw error;
         }
     }
+    async cacheStoreCreationHeight() {
+        const peer = await FullNodePeer_1.FullNodePeer.connect();
+        const createdAtHeight = await peer.getStoreCreationHeight(Buffer.from(this.storeId, "hex"), null, Buffer.from(config_2.MAIN_NET_GENISES_CHALLENGE, "hex"));
+        // Get just before created at height so we can find the coin
+        const justBeforeCreatedAtHeight = Number(createdAtHeight) - 1;
+        const createdAtHash = await peer.getHeaderHash(justBeforeCreatedAtHeight);
+        await this.setCreationHeight(justBeforeCreatedAtHeight, createdAtHash);
+        return { createdAtHeight: justBeforeCreatedAtHeight, createdAtHash };
+    }
     async getCreationHeight() {
-        const defaultHeight = config_1.MIN_HEIGHT;
-        const defaultHash = Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex");
         // Initialize the FileCache for the height file
         const fileCache = new FileCache_1.FileCache(`stores/${this.storeId}`);
         // Try to retrieve the cached height information
         const cachedHeightInfo = fileCache.get("height");
         if (!cachedHeightInfo) {
-            // If no cache, return the default values
-            return { createdAtHeight: defaultHeight, createdAtHash: defaultHash };
+            // If no cache, regenerate the cache
+            return this.cacheStoreCreationHeight();
         }
         // Parse the cached height and hash values
         const { height, hash } = cachedHeightInfo;
+        const defaultHeight = config_1.MIN_HEIGHT;
+        const defaultHash = Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex");
         return {
             createdAtHeight: height || defaultHeight,
-            createdAtHash: Buffer.from(hash || config_1.MIN_HEIGHT_HEADER_HASH, "hex"),
+            createdAtHash: hash ? Buffer.from(hash, "hex") : defaultHash,
         };
     }
     async setCreationHeight(height, hash) {
@@ -283,98 +279,53 @@ class DataStore {
             hash: hash.toString("hex"),
         });
     }
-    async getRootHistory() {
+    async getRootHistory(bustCache) {
+        if (bustCache) {
+            rootHistoryCache.del(this.storeId);
+        }
+        // Check if the root history is cached for this storeId
+        const cachedHistory = rootHistoryCache.get(this.storeId);
+        if (cachedHistory) {
+            return cachedHistory;
+        }
+        // Fetch root history from peer if not cached
         const peer = await FullNodePeer_1.FullNodePeer.connect();
         const { createdAtHeight, createdAtHash } = await this.getCreationHeight();
         const { rootHashes, rootHashesTimestamps } = await peer.syncStoreFromLauncherId(Buffer.from(this.storeId, "hex"), createdAtHeight, createdAtHash, true);
         if (!rootHashes) {
             return [];
         }
-        return rootHashes.map((rootHash, index) => ({
+        // Build the root history list
+        const rootHistory = rootHashes.map((rootHash, index) => ({
             root_hash: rootHash.toString("hex"),
             timestamp: Number(rootHashesTimestamps?.[index].toString()),
+            synced: fs_1.default.existsSync(path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash.toString("hex")}.dat`)),
         }));
+        // Store the root history in the cache
+        rootHistoryCache.set(this.storeId, rootHistory);
+        return rootHistory;
     }
-    async getLocalRootHistory() {
-        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
-        if (!fs_1.default.existsSync(manifestFilePath)) {
-            console.error("Manifest file not found", manifestFilePath);
-            return undefined;
+    // Generates a fresh manifest file based on the current root history
+    // and what is currently on disk
+    async generateManifestFile(folderPath) {
+        if (!folderPath) {
+            folderPath = path_1.default.join(config_1.STORE_PATH, this.storeId, "data");
         }
-        const manifestHashes = fs_1.default
-            .readFileSync(manifestFilePath, "utf-8")
-            .split("\n")
-            .filter(Boolean);
-        return manifestHashes.map((rootHash) => ({
-            root_hash: rootHash,
-            timestamp: 0, // Timestamps are not yet included in the manifest
-        }));
-    }
-    async validate() {
         const rootHistory = await this.getRootHistory();
-        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
-        if (!fs_1.default.existsSync(manifestFilePath)) {
-            console.error("Manifest file not found", manifestFilePath);
-            return false;
-        }
-        const manifestHashes = fs_1.default
-            .readFileSync(manifestFilePath, "utf-8")
-            .split("\n")
-            .filter(Boolean);
-        if (manifestHashes.length > rootHistory.length) {
-            console.error("The store is corrupted: Manifest file has more hashes than the root history.");
-            return false;
-        }
-        if (rootHistory.length > manifestHashes.length) {
-            console.error("The store is not synced: Root history has more hashes than the manifest file.");
-            return false;
-        }
-        for (let i = 0; i < manifestHashes.length; i++) {
-            if (manifestHashes[i] !== rootHistory[i]?.root_hash) {
-                console.error(`Root hash mismatch at position ${i}: expected ${manifestHashes[i]} but found ${rootHistory[i]?.root_hash}`);
-                return false;
-            }
-        }
-        let filesIntegrityIntact = true;
-        for (const rootHash of manifestHashes) {
-            const datFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash}.dat`);
-            if (!fs_1.default.existsSync(datFilePath)) {
-                console.error(`Data file for root hash ${rootHash} not found`);
-                return false;
-            }
-            const datFileContent = JSON.parse(fs_1.default.readFileSync(datFilePath, "utf-8"));
-            if (datFileContent.root !== rootHash) {
-                console.error(`Root hash in data file does not match: ${datFileContent.root} !== ${rootHash}`);
-                return false;
-            }
-            for (const [fileKey, fileData] of Object.entries(datFileContent.files)) {
-                const integrityCheck = (0, utils_1.validateFileSha256)(fileData.sha256, path_1.default.join(config_1.STORE_PATH, this.storeId, "data"));
-                if (!integrityCheck) {
-                    filesIntegrityIntact = false;
-                }
-            }
-        }
-        if (!filesIntegrityIntact) {
-            console.error("Store Corrupted: Data failed SHA256 validation.");
-            return false;
-        }
-        return true;
+        // Need this for the dataintegrity tree to work properly
+        fs_1.default.writeFileSync(path_1.default.join(folderPath, "manifest.dat"), rootHistory
+            .filter((root) => root.synced)
+            .map((root) => root.root_hash)
+            .join("\n"));
     }
     async getMetaData() {
         const { latestStore } = await this.fetchCoinInfo();
         return latestStore.metadata;
     }
     async isSynced() {
-        const rootHistory = await this.getRootHistory();
-        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
-        if (!fs_1.default.existsSync(manifestFilePath)) {
-            return false;
-        }
-        const manifestHashes = fs_1.default
-            .readFileSync(manifestFilePath, "utf-8")
-            .split("\n")
-            .filter(Boolean);
-        return rootHistory.length === manifestHashes.length;
+        const dataStore = await DataStore.from(this.storeId);
+        const rootHistory = await dataStore.getRootHistory();
+        return !rootHistory.some((root) => !root.synced);
     }
     async hasMetaWritePermissions(publicSyntheticKey) {
         const wallet = await Wallet_1.Wallet.load("default");
@@ -407,27 +358,40 @@ class DataStore {
         }
         return updateStoreResponse.newStore;
     }
-    async getFileSetForRootHash(rootHash) {
+    /**
+     * Retrieve the file set for a given root hash and validate file integrity.
+     *
+     * @param {string} rootHash - The root hash to fetch the file set.
+     * @returns {Promise<{ fileName: string, file: string }[]>} - An array of unique file objects.
+     */
+    async getFileSetForRootHash(rootHash, skipIntegirtyCheck = false) {
         const datFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash}.dat`);
         const datFileContent = JSON.parse(fs_1.default.readFileSync(datFilePath, "utf-8"));
-        const heightDatFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, "height.json");
-        const manifestFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, "manifest.dat");
-        const filesInvolved = [];
-        filesInvolved.push(manifestFilePath);
-        filesInvolved.push(datFilePath);
-        filesInvolved.push(heightDatFilePath);
+        // Use a Set to ensure uniqueness
+        const filesInvolved = new Set();
+        // Iterate over each file and perform an integrity check
         for (const [fileKey, fileData] of Object.entries(datFileContent.files)) {
-            const filepath = path_1.default.join(config_1.STORE_PATH, this.storeId, "data", fileKey);
-            const filePath = (0, hashUtils_1.getFilePathFromSha256)(datFileContent.files[fileKey].sha256, path_1.default.join(config_1.STORE_PATH, this.storeId, "data"));
-            filesInvolved.push(filePath);
+            const filePath = (0, hashUtils_1.getFilePathFromSha256)(datFileContent.files[fileKey].sha256, "data");
+            // Perform the integrity check
+            let integrityCheck;
+            if (!skipIntegirtyCheck) {
+                integrityCheck =
+                    await DataIntegrityTree_1.DataIntegrityTree.validateKeyIntegrityWithForeignTree(fileKey, datFileContent.files[fileKey].sha256, datFileContent, rootHash, path_1.default.join(config_1.STORE_PATH, this.storeId, "data"));
+            }
+            if (integrityCheck || skipIntegirtyCheck) {
+                // Add the file to the Set
+                filesInvolved.add({
+                    name: Buffer.from(fileKey, "hex").toString("utf-8"),
+                    path: filePath,
+                });
+            }
+            else {
+                console.error((0, colorette_1.red)(`File ${fileKey} failed the integrity check.`));
+                throw new Error(`Integrity check failed for file: ${fileKey}. Aborting.`);
+            }
         }
-        return filesInvolved;
-    }
-    getManifestHashes() {
-        const manifestFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, "manifest.dat");
-        return fs_1.default.existsSync(manifestFilePath)
-            ? fs_1.default.readFileSync(manifestFilePath, "utf-8").split("\n").filter(Boolean)
-            : [];
+        // Convert Set to Array and return
+        return Array.from(filesInvolved);
     }
 }
 exports.DataStore = DataStore;

package/dist/blockchain/DataStoreSerializer.d.ts

@@ -1,4 +1,4 @@
-import { DataStore } from "datalayer-driver";
+import { DataStore } from "@dignetwork/datalayer-driver";
 import { Buffer } from "buffer";
 export declare class DataStoreSerializer {
     private storeInfo;

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

@@ -1 +1 @@
-{"version":3,"file":"DataStoreSerializer.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStoreSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;gBAEf,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAOnE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgDF,WAAW,CACvB,IAAI,EAAE;QACJ,WAAW,EAAE,GAAG,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,GACA;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB;CAuEF"}
+{"version":3,"file":"DataStoreSerializer.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStoreSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;gBAEf,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAOnE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgDF,WAAW,CACvB,IAAI,EAAE;QACJ,WAAW,EAAE,GAAG,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,GACA;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB;CAuEF"}

package/dist/blockchain/FullNodePeer.d.ts

@@ -1,8 +1,9 @@
-import { Peer } from "datalayer-driver";
+import { Peer } from "@dignetwork/datalayer-driver";
 export declare class FullNodePeer {
     private static cachedPeer;
     private static memoizedFetchNewPeerIPs;
     private peer;
+    private static deprioritizedIps;
     private constructor();
     static connect(): Promise<Peer>;
     private static isPortReachable;

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

@@ -1 +1 @@
-{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAmBxC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAC3E,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA0B;IAChE,OAAO,CAAC,IAAI,CAAO;IAQnB,OAAO;WAIa,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;mBASZ,eAAe;mBAiDf,UAAU;IAyB/B,OAAO,CAAC,MAAM,CAAC,eAAe;mBAgDT,WAAW;IAgGzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAoBzD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAC3E,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA0B;IAChE,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAA0B;IAQzD,OAAO;WAIa,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;mBASZ,eAAe;mBA6Df,UAAU;IA2B/B,OAAO,CAAC,MAAM,CAAC,eAAe;mBAyDT,WAAW;IAsGzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}

package/dist/blockchain/FullNodePeer.js

@@ -7,15 +7,16 @@ exports.FullNodePeer = void 0;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
-const datalayer_driver_1 = require("datalayer-driver");
-const chia_server_coin_1 = require("chia-server-coin");
+const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const promises_1 = require("dns/promises");
 const net_1 = __importDefault(require("net"));
 const lodash_1 = require("lodash");
 const nanospinner_1 = require("nanospinner");
 const config_1 = require("../utils/config");
+const Environment_1 = require("../utils/Environment");
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
+const CHIA_NODES_HOST = "chia-nodes";
 const DNS_HOSTS = [
     "dns-introducer.chia.net",
     "chia.ctrlaltdel.ch",
@@ -55,7 +56,7 @@ class FullNodePeer {
      * @returns {string | null} The valid IP address or null if invalid
      */
     static getTrustedFullNode() {
-        const trustedNodeIp = process.env.TRUSTED_FULLNODE || null;
+        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
         if (trustedNodeIp && FullNodePeer.isValidIpAddress(trustedNodeIp)) {
             return trustedNodeIp;
         }
@@ -64,15 +65,22 @@ class FullNodePeer {
     static async fetchNewPeerIPs() {
         const trustedNodeIp = FullNodePeer.getTrustedFullNode();
         const priorityIps = [];
-        // Prioritize trustedNodeIp
+        // Prioritize trustedNodeIp unless it's deprioritized
         if (trustedNodeIp &&
+            !FullNodePeer.deprioritizedIps.has(trustedNodeIp) &&
             (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
-        // Prioritize LOCALHOST
-        if (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT)) {
+        // Prioritize LOCALHOST unless it's deprioritized
+        if (!FullNodePeer.deprioritizedIps.has(LOCALHOST) &&
+            (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
             priorityIps.push(LOCALHOST);
         }
+        // Prioritize CHIA_NODES_HOST unless it's deprioritized
+        if (!FullNodePeer.deprioritizedIps.has(CHIA_NODES_HOST) &&
+            (await FullNodePeer.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
+            priorityIps.push(CHIA_NODES_HOST);
+        }
         if (priorityIps.length > 0) {
             return priorityIps;
         }
@@ -114,6 +122,8 @@ class FullNodePeer {
         }
         // @ts-ignore
         if (FullNodePeer.memoizedFetchNewPeerIPs?.cache?.clear) {
+            // Clear cache and reset deprioritized IPs when cache is cleared
+            FullNodePeer.deprioritizedIps.clear();
             // @ts-ignore
             FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
         }
@@ -147,10 +157,13 @@ class FullNodePeer {
                         }
                         catch (error) {
                             // If the error is WebSocket-related or timeout, reset the peer
-                            if (error.message.includes("WebSocket") || error.message.includes("Operation timed out")) {
+                            if (error.message.includes("WebSocket") ||
+                                error.message.includes("Operation timed out")) {
                                 FullNodePeer.cachedPeer = null;
                                 // @ts-ignore
                                 FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
+                                FullNodePeer.deprioritizedIps.clear();
+                                console.info(`Fullnode Peer error, reconnecting to a new peer...`);
                                 const newPeer = await FullNodePeer.getBestPeer();
                                 return newPeer[prop](...args);
                             }
@@ -174,13 +187,21 @@ class FullNodePeer {
         if (!fs_1.default.existsSync(sslFolder)) {
             fs_1.default.mkdirSync(sslFolder, { recursive: true });
         }
-        new chia_server_coin_1.Tls(certFile, keyFile);
+        const tls = new datalayer_driver_1.Tls(certFile, keyFile);
         const peerIPs = await FullNodePeer.getPeerIPs();
-        const trustedNodeIp = process.env.TRUSTED_FULLNODE || null;
+        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
         const peers = await Promise.all(peerIPs.map(async (ip) => {
             if (ip) {
+                // Allow override of the trusted fullnode port if the override exists
+                let port = FULLNODE_PORT;
+                if (trustedNodeIp && ip === trustedNodeIp) {
+                    const trustedFullNodePort = Environment_1.Environment.TRUSTED_FULLNODE_PORT;
+                    if (trustedFullNodePort) {
+                        port = trustedFullNodePort;
+                    }
+                }
                 try {
-                    const peer = await datalayer_driver_1.Peer.new(`${ip}:${FULLNODE_PORT}`, false, certFile, keyFile);
+                    const peer = await datalayer_driver_1.Peer.new(`${ip}:${port}`, false, tls);
                     return FullNodePeer.createPeerProxy(peer);
                 }
                 catch (error) {
@@ -206,16 +227,19 @@ class FullNodePeer {
             throw new Error("No valid peak heights obtained from any peer.");
         }
         const highestPeak = Math.max(...validHeights);
-        // Prioritize LOCALHOST and TRUSTED_NODE_IP if they have the highest peak height
+        // Prioritize LOCALHOST, TRUSTED_NODE_IP, and CHIA_NODES_HOST if they have the highest peak height
         let bestPeerIndex = validHeights.findIndex((height, index) => height === highestPeak &&
-            (peerIPs[index] === LOCALHOST || peerIPs[index] === trustedNodeIp));
-        // If LOCALHOST or TRUSTED_NODE_IP don't have the highest peak, select any peer with the highest peak
+            !FullNodePeer.deprioritizedIps.has(peerIPs[index]) && // Exclude deprioritized IPs
+            (peerIPs[index] === LOCALHOST ||
+                peerIPs[index] === trustedNodeIp ||
+                peerIPs[index] === CHIA_NODES_HOST));
+        // If LOCALHOST, TRUSTED_NODE_IP, or CHIA_NODES_HOST don't have the highest peak, select any peer with the highest peak
         if (bestPeerIndex === -1) {
             bestPeerIndex = validHeights.findIndex((height) => height === highestPeak);
         }
         const bestPeer = peers[bestPeerIndex];
         FullNodePeer.cachedPeer = { peer: bestPeer, timestamp: now };
-        console.log(`Using Peer: ${peerIPs[bestPeerIndex]}`);
+        console.log(`Using Fullnode Peer: ${peerIPs[bestPeerIndex]}`);
         return bestPeer;
     }
     getPeer() {
@@ -242,6 +266,7 @@ class FullNodePeer {
 }
 exports.FullNodePeer = FullNodePeer;
 FullNodePeer.cachedPeer = null;
+FullNodePeer.deprioritizedIps = new Set(); // New set for deprioritized IPs
 (() => {
     FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
 })();

package/dist/blockchain/ServerCoin.d.ts

@@ -1,21 +1,29 @@
-import { ServerCoin as ServerCoinDriver } from "datalayer-driver";
+import { ServerCoin as ServerCoinDriver } from "@dignetwork/datalayer-driver";
 import { NconfManager } from "../utils/NconfManager";
 export declare class ServerCoin {
     private storeId;
     static readonly serverCoinManager: NconfManager;
     constructor(storeId: string);
-    createForEpoch(peerIp: string): Promise<ServerCoinDriver>;
-    saveServerCoinData(serverCoin: ServerCoinDriver, epoch: number, peerIp: string): Promise<void>;
+    createForEpoch(peerIp: string, rootHash: string): Promise<ServerCoinDriver>;
+    saveServerCoinData(serverCoin: ServerCoinDriver, epoch: number, peerIp: string, rootHash: string): Promise<void>;
     melt(epoch: number, peerIp: string): Promise<void>;
     private removeServerCoinData;
+    getAllEpochPeers(epoch: number, blacklist?: string[]): Promise<string[]>;
+    getActiveEpochPeers(blacklist?: string[]): Promise<string[]>;
     sampleCurrentEpoch(sampleSize?: number, blacklist?: string[]): Promise<string[]>;
     sampleServerCoinsByEpoch(epoch: number, sampleSize?: number, blacklist?: string[]): Promise<string[]>;
-    static getCurrentEpoch(): number;
+    static getCurrentEpoch(): {
+        epoch: number;
+        round: number;
+    };
     ensureServerCoinExists(peerIp: string): Promise<void>;
     meltOutdatedEpochs(peerIp: string): Promise<void>;
     static meltUntrackedStoreCoins(): Promise<void>;
     private getServerCoinsForStore;
     hasEpochCoinBeenCreated(currentEpoch: number, peerIp: string): Promise<boolean>;
-    static calculateEpoch(currentTimestampUTC: Date): number;
+    static calculateEpochAndRound(currentTimestampUTC: Date): {
+        epoch: number;
+        round: number;
+    };
 }
 //# sourceMappingURL=ServerCoin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ServerCoin.d.ts","sourceRoot":"","sources":["../../src/blockchain/ServerCoin.ts"],"names":[],"mappings":"AACA,OAAO,EAML,UAAU,IAAI,gBAAgB,EAE/B,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAMrD,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,gBAAuB,iBAAiB,eAAwC;gBAGpE,OAAO,EAAE,MAAM;IAKd,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA2DzD,kBAAkB,CAC7B,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAqBH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAoDjD,oBAAoB;IAgBrB,kBAAkB,CAC7B,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAMP,wBAAwB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;WAsCN,eAAe,IAAI,MAAM;IAK1B,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDrD,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WA+B1C,uBAAuB;YA4D7B,sBAAsB;IAWvB,uBAAuB,CAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC;WAuBL,cAAc,CAAC,mBAAmB,EAAE,IAAI,GAAG,MAAM;CAiBhE"}
+{"version":3,"file":"ServerCoin.d.ts","sourceRoot":"","sources":["../../src/blockchain/ServerCoin.ts"],"names":[],"mappings":"AACA,OAAO,EAML,UAAU,IAAI,gBAAgB,EAE/B,MAAM,8BAA8B,CAAC;AAItC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAYrD,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,gBAAuB,iBAAiB,eAEtC;gBAEU,OAAO,EAAE,MAAM;IAKd,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA4D3E,kBAAkB,CAC7B,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAsBH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAoDjD,oBAAoB;IAerB,gBAAgB,CAC3B,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAoDP,mBAAmB,CAC9B,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAMP,kBAAkB,CAC7B,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;IAMP,wBAAwB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,GAAE,MAAU,EACtB,SAAS,GAAE,MAAM,EAAO,GACvB,OAAO,CAAC,MAAM,EAAE,CAAC;WAeN,eAAe,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAKpD,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiFrD,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WA+B1C,uBAAuB;YAkE7B,sBAAsB;IAWvB,uBAAuB,CAClC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC;WAuBL,sBAAsB,CAAC,mBAAmB,EAAE,IAAI,GAAG;QAC/D,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACf;CA2BF"}