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

package/dist/DataIntegrityTree/DataIntegrityTree.d.ts

@@ -17,6 +17,7 @@ declare class DataIntegrityTree {
     files: Map<string, {
         hash: string;
         sha256: string;
+        bytes: string;
     }>;
     private tree;
     constructor(storeId: string, options?: DataIntegrityTreeOptions);
@@ -78,6 +79,9 @@ declare class DataIntegrityTree {
      * @returns The serialized Merkle tree.
      */
     serialize(rootHash?: string | null): object;
+    static getRootOfForeignTree(treeData: {
+        leaves: string[];
+    }): string;
     /**
      * Deserialize a JSON object to a Merkle tree.
      * @param rootHash - The root hash of the tree.
@@ -152,9 +156,14 @@ declare class DataIntegrityTree {
      * @param sha256 - The SHA-256 hash of the file.
      * @param serializedTree - The foreign serialized Merkle tree.
      * @param expectedRootHash - The expected root hash of the Merkle tree.
+     * @param dataDir - The directory where the data is stored.
+     * @param verifiedSha256 - A boolean indicating if the SHA-256 hash has already been verified.
      * @returns A boolean indicating if the SHA-256 is present in the foreign tree and the root hash matches.
      */
-    static validateKeyIntegrityWithForeignTree(key: string, sha256: string, serializedTree: object, expectedRootHash: string): boolean;
+    static validateKeyIntegrityWithForeignTree(hexkey: string, sha256: string, serializedTree: object, expectedRootHash: string, dataDir: string, verifiedSha256?: boolean): Promise<boolean>;
+    private static verifyFileHash;
+    private static deserializeAndVerifyTree;
+    private static checkHashInTree;
 }
 export { DataIntegrityTree };
 //# sourceMappingURL=DataIntegrityTree.d.ts.map

package/dist/DataIntegrityTree/DataIntegrityTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataIntegrityTree.d.ts","sourceRoot":"","sources":["../../src/DataIntegrityTree/DataIntegrityTree.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"DataIntegrityTree.d.ts","sourceRoot":"","sources":["../../src/DataIntegrityTree/DataIntegrityTree.ts"],"names":[],"mappings":"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"}

package/dist/DataIntegrityTree/DataIntegrityTree.js

@@ -94,8 +94,7 @@ class DataIntegrityTree {
         }
         this.files = new Map();
         if (options.rootHash) {
-            const manifest = this._loadManifest();
-            if (manifest.includes(options.rootHash)) {
+            if (fs.existsSync(path.join(this.storeDir, `${options.rootHash}.dat`))) {
                 this.tree = this.deserializeTree(options.rootHash);
             }
             else {
@@ -135,7 +134,10 @@ class DataIntegrityTree {
         const manifest = this._loadManifest();
         if (manifest.length > 0) {
             const latestRootHash = manifest[manifest.length - 1];
-            return this.deserializeTree(latestRootHash);
+            if (latestRootHash && isHexString(latestRootHash)) {
+                return this.deserializeTree(latestRootHash);
+            }
+            return new merkletreejs_1.MerkleTree([], crypto_js_1.SHA256, { sortPairs: true });
         }
         else {
             return new merkletreejs_1.MerkleTree([], crypto_js_1.SHA256, { sortPairs: true });
@@ -189,11 +191,16 @@ class DataIntegrityTree {
             fs.mkdirSync(tempDir, { recursive: true });
         }
         const tempFilePath = path.join(tempDir, `${crypto.randomUUID()}.gz`);
+        let totalBytes = 0;
         return new Promise((resolve, reject) => {
             const tempWriteStream = fs.createWriteStream(tempFilePath);
             readStream.on("data", (chunk) => {
                 uncompressedHash.update(chunk);
             });
+            // Now listen to the gzip stream for compressed data size
+            gzip.on("data", (chunk) => {
+                totalBytes += chunk.length; // This counts compressed bytes
+            });
             readStream.pipe(gzip).pipe(tempWriteStream);
             tempWriteStream.on("finish", async () => {
                 sha256 = uncompressedHash.digest("hex");
@@ -222,6 +229,7 @@ class DataIntegrityTree {
                     this.files.set(key, {
                         hash: combinedHash,
                         sha256: sha256,
+                        bytes: totalBytes.toString(),
                     });
                     await new Promise((resolve) => setTimeout(resolve, 100));
                     this._rebuildTree();
@@ -313,6 +321,11 @@ class DataIntegrityTree {
             files: Object.fromEntries(this.files),
         };
     }
+    static getRootOfForeignTree(treeData) {
+        const leaves = treeData.leaves.map((leaf) => Buffer.from(leaf, "hex"));
+        const tree = new merkletreejs_1.MerkleTree(leaves, crypto_js_1.SHA256, { sortPairs: true });
+        return tree.getRoot().toString("hex");
+    }
     /**
      * Deserialize a JSON object to a Merkle tree.
      * @param rootHash - The root hash of the tree.
@@ -603,14 +616,13 @@ class DataIntegrityTree {
             decompressStream.on("end", () => {
                 const uncompressedSha256 = hash.digest("hex");
                 const isValid = uncompressedSha256 === sha256;
-                console.log(`SHA-256 of uncompressed file: ${uncompressedSha256}`);
                 if (!isValid) {
                     return resolve(false);
                 }
                 const tree = this.deserializeTree(rootHash);
                 const combinedHash = crypto
                     .createHash("sha256")
-                    .update(`${toHex(sha256)}/${sha256}`)
+                    .update(sha256)
                     .digest("hex");
                 const leaf = Buffer.from(combinedHash, "hex");
                 const isInTree = tree.getLeafIndex(leaf) !== -1;
@@ -632,10 +644,12 @@ class DataIntegrityTree {
      * @param sha256 - The SHA-256 hash of the file.
      * @param serializedTree - The foreign serialized Merkle tree.
      * @param expectedRootHash - The expected root hash of the Merkle tree.
+     * @param dataDir - The directory where the data is stored.
+     * @param verifiedSha256 - A boolean indicating if the SHA-256 hash has already been verified.
      * @returns A boolean indicating if the SHA-256 is present in the foreign tree and the root hash matches.
      */
-    static validateKeyIntegrityWithForeignTree(key, sha256, serializedTree, expectedRootHash) {
-        if (!isHexString(key)) {
+    static async validateKeyIntegrityWithForeignTree(hexkey, sha256, serializedTree, expectedRootHash, dataDir, verifiedSha256 = false) {
+        if (!isHexString(hexkey)) {
             throw new Error("key must be a valid hex string");
         }
         if (!isHexString(sha256)) {
@@ -644,6 +658,56 @@ class DataIntegrityTree {
         if (!isHexString(expectedRootHash)) {
             throw new Error("expectedRootHash must be a valid hex string");
         }
+        if (!verifiedSha256) {
+            // Verify the file's SHA-256 hash
+            const isFileValid = await this.verifyFileHash(sha256, dataDir);
+            if (!isFileValid) {
+                return false;
+            }
+        }
+        // Deserialize and verify the tree
+        const tree = this.deserializeAndVerifyTree(serializedTree, expectedRootHash);
+        if (!tree) {
+            return false;
+        }
+        // Check if the combined hash exists in the foreign tree's leaves
+        const isInTree = this.checkHashInTree(tree, hexkey, sha256);
+        return isInTree;
+    }
+    // Function to verify the file's SHA-256 hash
+    static async verifyFileHash(sha256, dataDir) {
+        const filePath = path.join(dataDir, sha256.match(/.{1,2}/g).join("/"));
+        // Check if the file exists
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File at path ${filePath} does not exist`);
+        }
+        const compressedReadStream = fs.createReadStream(filePath);
+        const decompressStream = zlib.createGunzip();
+        const hash = crypto.createHash("sha256");
+        // Process file decompression and hash comparison
+        return new Promise((resolve, reject) => {
+            compressedReadStream.pipe(decompressStream);
+            decompressStream.on("data", (chunk) => {
+                hash.update(chunk);
+            });
+            decompressStream.on("end", () => {
+                const uncompressedSha256 = hash.digest("hex");
+                if (uncompressedSha256 !== sha256) {
+                    console.warn(`File hash mismatch. Expected: ${sha256}, got: ${uncompressedSha256}`);
+                    return resolve(false);
+                }
+                resolve(true);
+            });
+            decompressStream.on("error", (err) => {
+                reject(err);
+            });
+            compressedReadStream.on("error", (err) => {
+                reject(err);
+            });
+        });
+    }
+    // Function to deserialize and verify the tree
+    static deserializeAndVerifyTree(serializedTree, expectedRootHash) {
         // Deserialize the foreign tree
         const leaves = serializedTree.leaves.map((leaf) => Buffer.from(leaf, "hex"));
         const tree = new merkletreejs_1.MerkleTree(leaves, crypto_js_1.SHA256, { sortPairs: true });
@@ -651,7 +715,7 @@ class DataIntegrityTree {
         const treeRootHash = tree.getRoot().toString("hex");
         if (treeRootHash !== expectedRootHash) {
             console.warn(`Expected root hash ${expectedRootHash}, but got ${treeRootHash}`);
-            return false;
+            return null;
         }
         // Rebuild the files map from the serialized tree
         // @ts-ignore
@@ -659,10 +723,13 @@ class DataIntegrityTree {
             key,
             { hash: value.hash, sha256: value.sha256 },
         ]));
-        // Check if the SHA-256 exists in the foreign tree's files
+        return tree;
+    }
+    // Function to check if the combined hash exists in the tree
+    static checkHashInTree(tree, hexkey, sha256) {
         const combinedHash = crypto
             .createHash("sha256")
-            .update(`${toHex(key)}/${sha256}`)
+            .update(`${hexkey}/${sha256}`)
             .digest("hex");
         const leaf = Buffer.from(combinedHash, "hex");
         const isInTree = tree.getLeafIndex(leaf) !== -1;

package/dist/DigNetwork/ContentServer.d.ts

@@ -8,23 +8,40 @@ export declare class ContentServer {
     private static readonly port;
     constructor(ipAddress: string, storeId: string);
     getKey(key: string, rootHash: string, challengeHex?: string): Promise<string>;
-    getPaymentAddress(): Promise<string>;
+    getKeyChunk(key: string, rootHash: string): Promise<Buffer>;
+    getPaymentAddress(): Promise<string | null>;
+    /**
+     * Fetches and caches the .well-known information for the store's IP address.
+     *
+     * @returns A promise that resolves to the .well-known JSON data.
+     */
     getWellKnown(): Promise<any>;
     getKnownStores(): Promise<any>;
     getStoresIndex(): Promise<any>;
-    getKeysIndex(): Promise<any>;
-    headKey(key: string): Promise<{
+    getKeysIndex(rootHash?: string): Promise<any>;
+    headKey(key: string, rootHash?: string): Promise<{
         success: boolean;
         headers?: http.IncomingHttpHeaders;
     }>;
-    headStore(): Promise<{
+    headStore(options?: {
+        hasRootHash: string;
+    }): Promise<{
         success: boolean;
         headers?: http.IncomingHttpHeaders;
     }>;
-    streamKey(key: string): Promise<Readable>;
+    /**
+     * Checks if the store has the specified rootHash.
+     * Utilizes caching to improve performance.
+     *
+     * @param rootHash - The root hash to check.
+     * @returns A promise that resolves to true if the root hash exists, otherwise false.
+     */
+    hasRootHash(rootHash: string): Promise<boolean>;
+    streamKey(key: string, rootHash?: string): Promise<Readable>;
     private head;
     private fetchJson;
     private fetchWithRetries;
     private fetch;
+    private fetchFirstChunk;
 }
 //# sourceMappingURL=ContentServer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ContentServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/ContentServer.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;gBAExB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAYjC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAa7E,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAepC,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC;IAM5B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC;IAM5B,OAAO,CAClB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAA;KAAE,CAAC;IAMvD,SAAS,IAAI,OAAO,CAAC;QAChC,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAC;KACpC,CAAC;IAMK,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;YA0ClC,IAAI;YA0EJ,SAAS;YAMT,gBAAgB;YAiChB,KAAK;CA0DpB"}
+{"version":3,"file":"ContentServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/ContentServer.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAOlC,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;gBAExB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAYjC,MAAM,CACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC;IAeL,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAS3D,iBAAiB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcxD;;;;OAIG;IACU,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC;IA6B5B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAqB7C,OAAO,CAClB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAA;KAAE,CAAC;IAqBvD,SAAS,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACjE,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAC;KACpC,CAAC;IAmBF;;;;;;OAMG;IACU,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BrD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;YAmDrD,IAAI;YA0EJ,SAAS;YAMT,gBAAgB;YAiChB,KAAK;YA+GL,eAAe;CA4G9B"}

package/dist/DigNetwork/ContentServer.js

@@ -7,13 +7,16 @@ exports.ContentServer = void 0;
 const fs_1 = __importDefault(require("fs"));
 const http_1 = __importDefault(require("http"));
 const url_1 = require("url");
-const ssl_1 = require("../utils/ssl");
+const utils_1 = require("../utils");
+const node_cache_1 = __importDefault(require("node-cache"));
+const hasRootHashCache = new node_cache_1.default({ stdTTL: 86400 });
+const wellKnownCache = new node_cache_1.default({ stdTTL: 86400 });
 class ContentServer {
     constructor(ipAddress, storeId) {
         this.ipAddress = ipAddress;
         this.storeId = storeId;
         if (!ContentServer.certPath || !ContentServer.keyPath) {
-            const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+            const { certPath, keyPath } = (0, utils_1.getOrCreateSSLCerts)();
             ContentServer.certPath = certPath;
             ContentServer.keyPath = keyPath;
         }
@@ -21,13 +24,19 @@ class ContentServer {
     // Method to get the content of a specified key from the peer, with optional challenge query
     async getKey(key, rootHash, challengeHex) {
         // Construct the base URL
-        let url = `https://${this.ipAddress}/chia.${this.storeId}.${rootHash}/${key}`;
+        let url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/chia.${this.storeId}.${rootHash}/${key}`;
         // If a challenge is provided, append it as a query parameter
         if (challengeHex) {
             url += `?challenge=${challengeHex}`;
         }
         return this.fetchWithRetries(url);
     }
+    // New method to get only the first chunk of the content
+    async getKeyChunk(key, rootHash) {
+        // Construct the base URL
+        let url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/chia.${this.storeId}.${rootHash}/${key}`;
+        return this.fetchFirstChunk(url);
+    }
     // Method to get the payment address from the peer
     async getPaymentAddress() {
         console.log(`Fetching payment address from peer ${this.ipAddress}...`);
@@ -37,43 +46,128 @@ class ContentServer {
         }
         catch (error) {
             console.error(`Failed to fetch payment address from ${this.ipAddress}: ${error.message}`);
-            throw new Error(`Failed to fetch payment address: ${error.message}`);
+            return null;
         }
     }
-    // Method to get the .well-known information
+    /**
+     * Fetches and caches the .well-known information for the store's IP address.
+     *
+     * @returns A promise that resolves to the .well-known JSON data.
+     */
     async getWellKnown() {
-        const url = `https://${this.ipAddress}/.well-known`;
-        return this.fetchJson(url);
+        // Construct the cache key based on ipAddress
+        const cacheKey = `${this.ipAddress}-wellknown`;
+        // Check if the result is already cached
+        const cachedResult = wellKnownCache.get(cacheKey);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        // If not cached, proceed to fetch the .well-known information
+        const url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/.well-known`;
+        try {
+            const data = await this.fetchJson(url);
+            wellKnownCache.set(cacheKey, data);
+            return data;
+        }
+        catch (error) {
+            console.error(`Error fetching .well-known information for ${this.ipAddress}:`, error.message);
+            throw error; // Propagate the error after logging
+        }
     }
     // Method to get the list of known stores
     async getKnownStores() {
-        const url = `https://${this.ipAddress}/.well-known/stores`;
+        const url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/.well-known/stores`;
         return this.fetchJson(url);
     }
     // Method to get the index of all stores
     async getStoresIndex() {
-        const url = `https://${this.ipAddress}/`;
+        const url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/`;
         return this.fetchJson(url);
     }
     // Method to get the index of keys in a store
-    async getKeysIndex() {
-        const url = `https://${this.ipAddress}/${this.storeId}`;
-        return this.fetchJson(url);
+    async getKeysIndex(rootHash) {
+        try {
+            let udi = `chia.${this.storeId}`;
+            if (rootHash) {
+                udi += `.${rootHash}`;
+            }
+            const url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/${udi}`;
+            return this.fetchJson(url);
+        }
+        catch (error) {
+            if (rootHash) {
+                hasRootHashCache.del(`${this.storeId}-${rootHash}`);
+            }
+            throw error;
+        }
     }
     // Method to check if a specific key exists (HEAD request)
-    async headKey(key) {
-        const url = `https://${this.ipAddress}/${this.storeId}/${key}`;
-        return this.head(url); // Return the object from head method
+    async headKey(key, rootHash) {
+        try {
+            let udi = `chia.${this.storeId}`;
+            if (rootHash) {
+                udi += `.${rootHash}`;
+            }
+            const url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/${udi}/${key}`;
+            return this.head(url);
+        }
+        catch (error) {
+            if (rootHash) {
+                hasRootHashCache.del(`${this.storeId}-${rootHash}`);
+            }
+            throw error;
+        }
     }
     // Method to check if a specific store exists (HEAD request)
-    async headStore() {
-        const url = `https://${this.ipAddress}/${this.storeId}`;
-        console.log({ url });
-        return this.head(url); // Return the object from head method
+    async headStore(options) {
+        try {
+            let url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/chia.${this.storeId}`;
+            if (options?.hasRootHash) {
+                url += `?hasRootHash=${options.hasRootHash}`;
+            }
+            return this.head(url);
+        }
+        catch (error) {
+            if (options?.hasRootHash) {
+                hasRootHashCache.del(`${this.storeId}-${options.hasRootHash}`);
+            }
+            throw error;
+        }
     }
-    streamKey(key) {
+    /**
+     * Checks if the store has the specified rootHash.
+     * Utilizes caching to improve performance.
+     *
+     * @param rootHash - The root hash to check.
+     * @returns A promise that resolves to true if the root hash exists, otherwise false.
+     */
+    async hasRootHash(rootHash) {
+        // Construct the cache key using storeId and rootHash
+        const cacheKey = `${this.storeId}-${rootHash}`;
+        // Check if the result is already cached
+        const cachedResult = await hasRootHashCache.get(cacheKey);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        // If not cached, perform the headStore request
+        const { success, headers } = await this.headStore({
+            hasRootHash: rootHash,
+        });
+        // Determine if the store has the root hash
+        const hasHash = success && headers?.["x-has-root-hash"] === "true";
+        // Only cache the result if the store has the root hash
+        if (hasHash) {
+            hasRootHashCache.set(cacheKey, true);
+        }
+        return hasHash;
+    }
+    streamKey(key, rootHash) {
+        let udi = `chia.${this.storeId}`;
+        if (rootHash) {
+            udi += `.${rootHash}`;
+        }
         return new Promise((resolve, reject) => {
-            const url = `https://${this.ipAddress}/${this.storeId}/${key}`;
+            const url = `https://${(0, utils_1.formatHost)(this.ipAddress)}:${ContentServer.port}/${udi}/${key}`;
             const urlObj = new url_1.URL(url);
             const requestOptions = {
                 hostname: urlObj.hostname,
@@ -96,11 +190,12 @@ class ContentServer {
                     }
                 }
                 else {
+                    hasRootHashCache.del(`${this.storeId}-${rootHash}`);
                     reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
                 }
             });
             request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
+                console.error(`GET Request error for ${url}:`, error);
                 reject(error);
             });
             request.end();
@@ -159,7 +254,7 @@ class ContentServer {
                     }
                 });
                 request.on("error", (error) => {
-                    console.error(`Request error for ${url}:`, error);
+                    console.error(`HEAD ${url}:`, error.message);
                     reject({ success: false });
                 });
                 request.end();
@@ -178,7 +273,7 @@ class ContentServer {
     // Helper method to fetch content with retries and redirection handling
     async fetchWithRetries(url) {
         let attempt = 0;
-        const maxRetries = 5;
+        const maxRetries = 1;
         const initialDelay = 2000; // 2 seconds
         const maxDelay = 10000; // 10 seconds
         const delayMultiplier = 1.5;
@@ -202,10 +297,12 @@ class ContentServer {
         }
         throw new Error(`Failed to retrieve data from ${url} after ${maxRetries} attempts.`);
     }
-    // Core method to fetch content from a URL
+    // Core method to fetch content from a URL with a 5-second inactivity timeout
     async fetch(url, maxRedirects = 5) {
         return new Promise((resolve, reject) => {
             const urlObj = new url_1.URL(url);
+            const timeoutDuration = 5000; // 5 seconds
+            let timeout = null; // Initialize timeout
             const requestOptions = {
                 hostname: urlObj.hostname,
                 port: urlObj.port || ContentServer.port,
@@ -217,11 +314,31 @@ class ContentServer {
             };
             const request = http_1.default.request(requestOptions, (response) => {
                 let data = "";
+                // Set timeout for inactivity
+                timeout = setTimeout(() => {
+                    console.error(`Request timeout: No data received for ${timeoutDuration / 1000} seconds.`);
+                    request.destroy(); // Use destroy instead of abort
+                    reject(new Error(`Request timed out after ${timeoutDuration / 1000} seconds of inactivity`));
+                }, timeoutDuration);
+                const resetTimeout = () => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    timeout = setTimeout(() => {
+                        console.error(`Request timeout: No data received for ${timeoutDuration / 1000} seconds.`);
+                        request.destroy(); // Use destroy instead of abort
+                        reject(new Error(`Request timed out after ${timeoutDuration / 1000} seconds of inactivity`));
+                    }, timeoutDuration);
+                };
                 if (response.statusCode === 200) {
                     response.on("data", (chunk) => {
                         data += chunk;
+                        resetTimeout(); // Reset the timeout every time data is received
                     });
                     response.on("end", () => {
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
                         resolve(data);
                     });
                 }
@@ -230,8 +347,9 @@ class ContentServer {
                     // Handle redirects
                     if (maxRedirects > 0) {
                         const redirectUrl = new url_1.URL(response.headers.location, url); // Resolve relative URLs based on the original URL
-                        // Recursively follow the redirect, passing the same query params
-                        // console.log(`Redirecting to: ${redirectUrl.toString()}`);
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
                         this.fetch(redirectUrl.toString(), maxRedirects - 1)
                             .then(resolve)
                             .catch(reject);
@@ -241,11 +359,91 @@ class ContentServer {
                     }
                 }
                 else {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
+                }
+            });
+            request.on("error", (error) => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                console.error(`GET ${url}:`, error.message);
+                reject(error);
+            });
+            request.end();
+        });
+    }
+    // New core method to fetch only the first chunk without retries
+    async fetchFirstChunk(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const timeoutDuration = 5000; // 5 seconds
+            let timeout = null;
+            const requestOptions = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || ContentServer.port,
+                path: urlObj.pathname + urlObj.search, // Include query params
+                method: "GET",
+                key: fs_1.default.readFileSync(ContentServer.keyPath),
+                cert: fs_1.default.readFileSync(ContentServer.certPath),
+                rejectUnauthorized: false,
+            };
+            const request = http_1.default.request(requestOptions, (response) => {
+                // Set timeout for inactivity
+                timeout = setTimeout(() => {
+                    console.error(`Request timeout: No data received for ${timeoutDuration / 1000} seconds.`);
+                    request.destroy(); // Use destroy instead of abort
+                    reject(new Error(`Request timed out after ${timeoutDuration / 1000} seconds of inactivity`));
+                }, timeoutDuration);
+                const resetTimeout = () => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    timeout = setTimeout(() => {
+                        console.error(`Request timeout: No data received for ${timeoutDuration / 1000} seconds.`);
+                        request.destroy(); // Use destroy instead of abort
+                        reject(new Error(`Request timed out after ${timeoutDuration / 1000} seconds of inactivity`));
+                    }, timeoutDuration);
+                };
+                if (response.statusCode === 200) {
+                    response.once("data", (chunk) => {
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
+                        response.destroy(); // Close the connection after receiving the first chunk
+                        resolve(chunk);
+                    });
+                    response.on("end", () => {
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
+                        // In case the response ends before any data is received
+                        reject(new Error("No data received"));
+                    });
+                }
+                else if ((response.statusCode === 301 || response.statusCode === 302) &&
+                    response.headers.location) {
+                    // Handle redirects
+                    const redirectUrl = new url_1.URL(response.headers.location, url).toString(); // Resolve relative URLs
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    this.fetchFirstChunk(redirectUrl).then(resolve).catch(reject);
+                }
+                else {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
                     reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
                 }
             });
             request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                console.error(`GET ${url}:`, error.message);
                 reject(error);
             });
             request.end();