@dignetwork/dig-sdk 0.0.1-alpha.16 → 0.0.1-alpha.161

package/dist/DigNetwork/PropagationServer.js

@@ -1,415 +1,694 @@
 "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.PropagationServer = void 0;
+const axios_1 = __importDefault(require("axios"));
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const form_data_1 = __importDefault(require("form-data"));
 const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const https_1 = __importDefault(require("https"));
-const url_1 = require("url");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const progress_stream_1 = __importDefault(require("progress-stream"));
+const zlib = __importStar(require("zlib"));
+const promiseUtils_1 = require("../utils/promiseUtils");
+const nanospinner_1 = require("nanospinner");
+const hashUtils_1 = require("../utils/hashUtils");
 const ssl_1 = require("../utils/ssl");
+const colorette_1 = require("colorette");
+const merkle_1 = require("../utils/merkle");
+const stream_1 = require("stream");
 const credentialsUtils_1 = require("../utils/credentialsUtils");
-const spinnerUtils_1 = require("../utils/spinnerUtils");
+const config_1 = require("../utils/config");
 const blockchain_1 = require("../blockchain");
+const network_1 = require("../utils/network");
+const node_cache_1 = __importDefault(require("node-cache"));
+// Initialize cache with a TTL of 1 week (604800 seconds)
+const storeExistsCache = new node_cache_1.default({ stdTTL: 86400 });
+const pingUpdatecache = new node_cache_1.default({ stdTTL: 86400 });
+// Helper function to trim long filenames with ellipsis and ensure consistent padding
+function formatFilename(filename, maxLength = 30) {
+    if (!filename) {
+        return "Unknown File".padEnd(maxLength, " ");
+    }
+    if (filename.length > maxLength) {
+        return `...${filename.slice(-(maxLength - 3))}`.padEnd(maxLength, " ");
+    }
+    return filename.padEnd(maxLength, " ");
+}
 class PropagationServer {
     constructor(ipAddress, storeId) {
-        this.ipAddress = ipAddress;
         this.storeId = storeId;
-        if (!PropagationServer.certPath || !PropagationServer.keyPath) {
-            const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
-            PropagationServer.certPath = certPath;
-            PropagationServer.keyPath = keyPath;
-        }
-    }
-    // Method to upload a file to the propagation server
-    async pushFile(filePath, relativePath) {
-        const { nonce, username, password } = await this.getUploadDetails();
-        const wallet = await blockchain_1.Wallet.load("default");
-        const keyOwnershipSig = await wallet.createKeyOwnershipSignature(nonce);
-        const publicKey = await wallet.getPublicSyntheticKey();
-        const uploadUrl = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${relativePath}`;
-        await this.retryOperation(() => this.uploadFileDirect(filePath, uploadUrl, username, password, keyOwnershipSig, publicKey.toString("hex"), nonce), `Upload failed for ${relativePath}`);
-    }
-    // Method to subscribe to a store on the propagation server
-    async subscribeToStore() {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/subscribe`;
-        const data = JSON.stringify({ storeId: this.storeId });
-        await this.postRequest(url, data);
-    }
-    // Method to unsubscribe from a store on the propagation server
-    async unsubscribeFromStore() {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/unsubscribe`;
-        const data = JSON.stringify({ storeId: this.storeId });
-        await this.postRequest(url, data);
-    }
-    // Method to check the status of a store on the propagation server
-    async getStoreStatus() {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/status/${this.storeId}`;
-        return this.fetchJson(url);
-    }
-    async streamStoreData(dataPath) {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${dataPath}`;
-        return this.createReadStreamWithRetries(url);
-    }
-    // Method to retrieve a store's key
-    async getStoreData(dataPath) {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}/${dataPath}`;
-        return this.fetch(url);
-    }
-    async getStatus() {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/status/${this.storeId}`;
-        const statusJson = await this.fetch(url);
-        return JSON.parse(statusJson);
+        this.sessionId = "";
+        this.publicKey = "";
+        this.ipAddress = ipAddress;
+        // Get or create SSL certificates
+        const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+        this.certPath = certPath;
+        this.keyPath = keyPath;
     }
-    // Method to check if a specific store exists (HEAD request)
-    async headStore() {
-        const url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}`;
-        return this.head(url);
+    /**
+     * Initialize the Wallet instance.
+     */
+    async initializeWallet() {
+        this.wallet = await blockchain_1.Wallet.load("default");
+        this.publicKey = (await this.wallet.getPublicSyntheticKey()).toString("hex");
     }
-    // In PropagationServer.ts:
-    async isStoreSynced() {
-        const status = await this.getStatus();
-        return status.synced === true;
+    /**
+     * Create an Axios HTTPS Agent with self-signed certificate allowance.
+     */
+    createHttpsAgent() {
+        return new https_1.default.Agent({
+            cert: fs_1.default.readFileSync(this.certPath),
+            key: fs_1.default.readFileSync(this.keyPath),
+            rejectUnauthorized: false,
+        });
     }
-    // Method to handle upload details including nonce
-    async getUploadDetails() {
-        let username;
-        let password;
-        if (!username || !password) {
-            const credentials = await (0, credentialsUtils_1.promptCredentials)(this.ipAddress);
-            username = credentials.username;
-            password = credentials.password;
-        }
-        const uploadDetails = await this.fetchUploadDetails(username, password);
-        if (!uploadDetails) {
-            throw new Error("Failed to retrieve upload details.");
-        }
-        return { ...uploadDetails, username, password };
+    /**
+     * Ping the current peer about an update to the store, passing rootHash.
+     * @param rootHash - The root hash for the store update.
+     */
+    async getMyPublicIp(rootHash) {
+        try {
+            const httpsAgent = this.createHttpsAgent();
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/peer`;
+            const config = {
+                httpsAgent,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            };
+            try {
+                const response = await axios_1.default.get(url, config);
+                return response.data;
+            }
+            catch (error) {
+                console.error((0, colorette_1.red)(error.message));
+                throw error;
+            }
+        }
+        catch (error) {
+            console.error((0, colorette_1.red)(error.message));
+        }
     }
-    // Method to send a POST request
-    async postRequest(url, data) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new url_1.URL(url);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || PropagationServer.port,
-                path: urlObj.pathname,
-                method: "POST",
+    /**
+     * Ping the current peer about an update to the store, passing rootHash.
+     * If the combination of ipAddress-storeId-rootHash is cached as "successfully synced", skip the request.
+     * @param rootHash - The root hash for the store update.
+     */
+    async pingUpdate(rootHash) {
+        const cacheKey = `${this.ipAddress}-${this.storeId}-${rootHash}`;
+        // Check if response for this combination is already cached
+        if (pingUpdatecache.get(cacheKey) === "successfully synced") {
+            return;
+        }
+        try {
+            const httpsAgent = this.createHttpsAgent();
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/update`;
+            const config = {
+                httpsAgent,
                 headers: {
                     "Content-Type": "application/json",
-                    "Content-Length": Buffer.byteLength(data),
                 },
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
             };
-            const req = https_1.default.request(options, (res) => {
-                if (res.statusCode === 200) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`POST request failed with status ${res.statusCode}: ${res.statusMessage}`));
+            const data = {
+                storeId: this.storeId,
+                rootHash: rootHash,
+                updateTime: new Date().toISOString(),
+            };
+            try {
+                const response = await axios_1.default.post(url, data, config);
+                console.log((0, colorette_1.green)(`✔ Successfully pinged peer: ${this.ipAddress}`), response.data);
+                if (response.data.message === "Already Synced") {
+                    // Cache the response as "successfully synced" to avoid redundant requests
+                    pingUpdatecache.set(cacheKey, "successfully synced");
                 }
-            });
-            req.on("error", (err) => {
-                reject(err);
-            });
-            req.write(data);
-            req.end();
-        });
+                return response.data;
+            }
+            catch (error) {
+                console.error((0, colorette_1.red)(`✖ Failed to ping peer: ${this.ipAddress}`), error.message);
+                console.error((0, colorette_1.red)(error.message));
+                throw error;
+            }
+        }
+        catch (error) {
+            console.error((0, colorette_1.red)(error.message));
+        }
     }
-    // Method to fetch upload details from the server
-    // Method to fetch upload details from the server
-    async fetchUploadDetails(username, password) {
-        const remote = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}`;
-        return (0, spinnerUtils_1.waitForPromise)(() => {
-            return new Promise((resolve, reject) => {
-                const url = new url_1.URL(remote);
-                const options = {
-                    hostname: url.hostname,
-                    port: url.port,
-                    path: url.pathname,
-                    method: "HEAD",
-                    headers: {
-                        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
-                    },
-                    key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                    cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                    rejectUnauthorized: false, // Allow self-signed certificates
-                };
-                const req = https_1.default.request(options, (res) => {
-                    if (res.statusCode === 200) {
-                        // Check if the headers are present and valid
-                        const nonce = res.headers["x-nonce"];
-                        const lastUploadedHash = res.headers?.["x-last-uploaded-hash"] ||
-                            "0000000000000000000000000000000000000000000000000000000000000000";
-                        const generationIndex = res.headers?.["x-generation-index"] || 0;
-                        console.log({ nonce, lastUploadedHash, generationIndex });
-                        if (nonce) {
-                            resolve({
-                                nonce: nonce,
-                                lastUploadedHash: lastUploadedHash,
-                                generationIndex: Number(generationIndex),
-                            });
-                        }
-                        else {
-                            reject(new Error("Missing required headers in the response."));
-                        }
-                    }
-                    else {
-                        reject(new Error(`Failed to perform preflight check: ${res.statusCode} ${res.statusMessage}`));
-                    }
+    /**
+     * Adds a custom inactivity timeout for large file transfers.
+     */
+    addInactivityTimeout(stream, timeoutMs) {
+        let timeoutId;
+        const resetTimeout = () => {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                stream.destroy(new Error(`Inactivity timeout after ${timeoutMs / 1000} seconds`));
+            }, timeoutMs);
+        };
+        // Reset timeout every time data is received
+        stream.on("data", resetTimeout);
+        // Set the initial timeout
+        resetTimeout();
+        // Clear the timeout when the stream ends
+        stream.on("end", () => clearTimeout(timeoutId));
+        stream.on("error", () => clearTimeout(timeoutId)); // Handle errors
+        return stream;
+    }
+    /**
+     * Checks if the store exists and optionally if a specific rootHash exists.
+     * Utilizes caching to improve performance.
+     *
+     * @param rootHash - (Optional) The root hash to check.
+     * @returns A promise that resolves to an object containing store existence and root hash existence.
+     */
+    async checkStoreExists(rootHash) {
+        // Construct the cache key
+        const cacheKey = rootHash
+            ? `${this.storeId}-${rootHash}`
+            : `${this.storeId}-nohash`;
+        // Check if the result is already cached
+        const cachedResult = storeExistsCache.get(cacheKey);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        // If not cached, proceed with the HTTP request
+        const spinner = (0, nanospinner_1.createSpinner)(`Checking if store ${this.storeId} exists...`).start();
+        try {
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
+            };
+            let url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/${this.storeId}`;
+            if (rootHash) {
+                url += `?hasRootHash=${rootHash}`;
+            }
+            const response = await axios_1.default.head(url, config);
+            // Extract store existence and root hash existence from headers
+            const storeExists = response.headers["x-store-exists"] === "true";
+            const rootHashExists = response.headers["x-has-root-hash"] === "true";
+            if (storeExists) {
+                spinner.success({
+                    text: (0, colorette_1.green)(`Store ${this.storeId} exists on peer: ${this.ipAddress}`),
                 });
-                req.on("error", (err) => {
-                    console.error(err.message);
-                    resolve(false); // Resolve to false if there is an error
+            }
+            else {
+                spinner.error({
+                    text: (0, colorette_1.yellow)(`Store ${this.storeId} does not exist on ${this.ipAddress}. Credentials will be required to push.`),
                 });
-                req.end();
-            });
-        }, "Performing remote preflight", "Preflight succeeded.", "Error on preflight.");
+            }
+            const result = { storeExists, rootHashExists };
+            storeExistsCache.set(cacheKey, result);
+            return result;
+        }
+        catch (error) {
+            spinner.error({ text: (0, colorette_1.red)("Error checking if store exists:") });
+            console.error((0, colorette_1.red)(error.message));
+            throw error;
+        }
     }
-    // Core method to upload a file directly to the server using a stream
-    async uploadFileDirect(filePath, uploadUrl, username, password, keyOwnershipSig, publicKey, nonce) {
-        const fileStream = fs_1.default.createReadStream(filePath);
-        const fileSize = fs_1.default.statSync(filePath).size;
-        return new Promise((resolve, reject) => {
-            const url = new url_1.URL(uploadUrl);
-            const options = {
-                hostname: url.hostname,
-                port: url.port,
-                path: url.pathname,
-                method: "PUT",
+    /**
+     * Start an upload session by sending a POST request with the rootHash.dat file.
+     */
+    async startUploadSession(rootHash) {
+        const spinner = (0, nanospinner_1.createSpinner)(`Starting upload session for store ${this.storeId}...`).start();
+        try {
+            const formData = new form_data_1.default();
+            const datFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash}.dat`);
+            // Ensure the rootHash.dat file exists
+            if (!fs_1.default.existsSync(datFilePath)) {
+                throw new Error(`File not found: ${datFilePath}`);
+            }
+            formData.append("file", fs_1.default.createReadStream(datFilePath), {
+                filename: `${rootHash}.dat`,
+            });
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
                 headers: {
-                    "Content-Type": "application/octet-stream",
-                    "Content-Length": fileSize,
-                    Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
-                    "x-key-ownership-sig": keyOwnershipSig,
-                    "x-public-key": publicKey,
-                    "x-nonce": nonce,
+                    ...formData.getHeaders(),
                 },
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
             };
-            const req = https_1.default.request(options, (res) => {
-                if (res.statusCode === 200) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Upload failed with status ${res.statusCode}: ${res.statusMessage}`));
-                }
+            // Add Basic Auth if username and password are present
+            if (this.username && this.password) {
+                config.auth = {
+                    username: this.username,
+                    password: this.password,
+                };
+            }
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/upload/${this.storeId}?roothash=${rootHash}`;
+            const response = await axios_1.default.post(url, formData, config);
+            this.sessionId = response.data.sessionId;
+            spinner.success({
+                text: (0, colorette_1.green)(`Upload session started for Root Hash: ${(0, colorette_1.cyan)(rootHash)} with session ID ${this.sessionId}`),
             });
-            req.on("error", (err) => {
-                reject(err);
+        }
+        catch (error) {
+            spinner.error({ text: (0, colorette_1.red)("Error starting upload session:") });
+            console.error((0, colorette_1.red)(error.message));
+            throw error;
+        }
+    }
+    /**
+     * Request a nonce for a file by sending a HEAD request to the server.
+     */
+    async getFileNonce(filename) {
+        try {
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
+            };
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/upload/${this.storeId}/${this.sessionId}/${filename}`;
+            const response = await axios_1.default.head(url, config);
+            // Check for 'x-file-exists' header
+            const fileExists = response.headers["x-file-exists"] === "true";
+            // If file exists, no need to generate a nonce
+            const nonce = response.headers["x-nonce"];
+            return { nonce, fileExists };
+        }
+        catch (error) {
+            console.error((0, colorette_1.red)(`Error generating nonce for file ${filename}:`), error.message);
+            throw error;
+        }
+    }
+    /**
+     * Upload a file to the server by sending a PUT request.
+     * Logs progress using a local cli-progress bar.
+     */
+    async uploadFile(label, dataPath, uncompress = false) {
+        const filePath = path_1.default.join(config_1.STORE_PATH, this.storeId, dataPath);
+        const { nonce, fileExists } = await this.getFileNonce(dataPath);
+        if (fileExists) {
+            console.log((0, colorette_1.blue)(`File ${label} already exists. Skipping upload.`));
+            return;
+        }
+        const wallet = await blockchain_1.Wallet.load("default");
+        const keyOwnershipSig = await wallet.createKeyOwnershipSignature(nonce);
+        const publicKey = await wallet.getPublicSyntheticKey();
+        // Get the file size
+        const fileSize = fs_1.default.statSync(filePath).size;
+        let progressBar;
+        try {
+            // Create a new progress bar for the file
+            progressBar = new cli_progress_1.default.SingleBar({
+                format: `${(0, colorette_1.blue)("[{bar}]")} | ${(0, colorette_1.yellow)("{filename}")} | {percentage}% | {value}/{total} bytes`,
+                hideCursor: true,
+                barsize: 30,
+                align: "left",
+                autopadding: true,
+                noTTYOutput: false,
+                stopOnComplete: true,
+                clearOnComplete: false,
+            }, cli_progress_1.default.Presets.legacy);
+            progressBar.start(fileSize, 0, {
+                filename: formatFilename(label),
             });
-            fileStream.pipe(req);
-            fileStream.on("error", (err) => {
-                reject(err);
+            // Create the read stream
+            const fileReadStream = fs_1.default.createReadStream(filePath);
+            // Create a progress stream
+            const progressStream = (0, progress_stream_1.default)({
+                length: fileSize,
+                time: 500, // Adjust as needed
             });
-            req.on("end", () => {
-                resolve();
+            progressStream.on("progress", (progress) => {
+                progressBar.update(progress.transferred);
             });
-        });
-    }
-    // Generic retry operation handler to reduce redundancy
-    async retryOperation(operation, errorMessage) {
-        let attempt = 0;
-        let delay = PropagationServer.initialDelay;
-        while (attempt < PropagationServer.maxRetries) {
-            try {
-                return await operation();
+            // Add inactivity timeout to the progress stream
+            const passThroughStream = this.addInactivityTimeout(new stream_1.PassThrough(), PropagationServer.inactivityTimeout);
+            // Decide whether to uncompress the file during upload
+            if (uncompress) {
+                // Create a gunzip (uncompression) stream
+                const gunzip = zlib.createGunzip();
+                // Pipe the streams: fileReadStream -> gunzip -> progressStream -> passThroughStream
+                fileReadStream
+                    .pipe(gunzip)
+                    .pipe(progressStream)
+                    .pipe(passThroughStream);
             }
-            catch (error) {
-                if (attempt < PropagationServer.maxRetries - 1) {
-                    console.warn(`Attempt ${attempt + 1} failed: ${error.message}. Retrying in ${delay / 1000} seconds...`);
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                    delay = Math.min(PropagationServer.maxDelay, delay * PropagationServer.delayMultiplier);
-                }
-                else {
-                    console.error(`${errorMessage}. Aborting.`);
-                    throw error;
-                }
+            else {
+                // Pipe the streams: fileReadStream -> progressStream -> passThroughStream
+                fileReadStream.pipe(progressStream).pipe(passThroughStream);
+            }
+            // Use form-data to construct the request body
+            const formData = new form_data_1.default();
+            formData.append("file", passThroughStream);
+            const headers = {
+                ...formData.getHeaders(),
+                "x-nonce": nonce,
+                "x-public-key": publicKey.toString("hex"),
+                "x-key-ownership-sig": keyOwnershipSig,
+            };
+            const config = {
+                headers: headers,
+                httpsAgent: this.createHttpsAgent(),
+                maxContentLength: Infinity,
+                maxBodyLength: Infinity,
+            };
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/upload/${this.storeId}/${this.sessionId}/${dataPath}`;
+            // Create a promise that resolves when the progress stream ends
+            const progressPromise = new Promise((resolve, reject) => {
+                progressStream.on("end", resolve);
+                progressStream.on("error", reject);
+            });
+            // Start the upload request
+            const uploadPromise = axios_1.default.put(url, formData, config);
+            // Wait for both the upload and the progress stream to finish
+            await Promise.all([uploadPromise, progressPromise]);
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            if (progressBar) {
+                progressBar.stop();
             }
-            attempt++;
         }
-        throw new Error(errorMessage);
     }
-    // Core method to fetch content from a URL
-    async fetch(url) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new url_1.URL(url);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port,
-                path: urlObj.pathname + urlObj.search,
-                method: "GET",
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
-            };
-            const request = https_1.default.request(options, (response) => {
-                let data = "";
-                if (response.statusCode === 200) {
-                    response.on("data", (chunk) => {
-                        data += chunk;
-                    });
-                    response.on("end", () => {
-                        resolve(data);
-                    });
-                }
-                else if (response.statusCode === 301 || response.statusCode === 302) {
-                    const redirectUrl = response.headers.location;
-                    if (redirectUrl) {
-                        this.fetch(redirectUrl).then(resolve).catch(reject);
-                    }
-                    else {
-                        reject(new Error("Redirected without a location header"));
+    /**
+     * Commit the upload session by sending a POST request to the server.
+     */
+    async commitUploadSession() {
+        const spinner = (0, nanospinner_1.createSpinner)(`Committing upload session for store ${this.storeId}...`).start();
+        try {
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
+                auth: this.username && this.password
+                    ? {
+                        username: this.username,
+                        password: this.password,
                     }
-                }
-                else {
-                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
-                }
-            });
-            request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
-                reject(error);
+                    : undefined,
+            };
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/commit/${this.storeId}/${this.sessionId}`;
+            const response = await axios_1.default.post(url, {}, config);
+            spinner.success({
+                text: (0, colorette_1.green)(`Upload session ${this.sessionId} successfully committed.`),
             });
-            request.end();
+            return response.data;
+        }
+        catch (error) {
+            spinner.error({ text: (0, colorette_1.red)("Error committing upload session:") });
+            console.error((0, colorette_1.red)(error.message));
+            throw error;
+        }
+    }
+    /**
+     * Static function to handle the entire upload process for multiple files based on rootHash.
+     */
+    static async uploadStore(storeId, rootHash, ipAddress) {
+        const propagationServer = new PropagationServer(ipAddress, storeId);
+        // Initialize wallet
+        await propagationServer.initializeWallet();
+        // Check if the store exists
+        const { storeExists, rootHashExists } = await propagationServer.checkStoreExists(rootHash);
+        // If the store does not exist, prompt for credentials
+        if (!storeExists) {
+            console.log((0, colorette_1.red)(`Store ${storeId} does not exist. Prompting for credentials...`));
+            const credentials = await (0, credentialsUtils_1.promptCredentials)(propagationServer.ipAddress);
+            propagationServer.username = credentials.username;
+            propagationServer.password = credentials.password;
+        }
+        if (rootHashExists) {
+            console.log((0, colorette_1.blue)(`Root hash ${rootHash} already exists in the store. Skipping upload.`));
+            return;
+        }
+        // Start the upload session
+        await propagationServer.startUploadSession(rootHash);
+        const dataStore = blockchain_1.DataStore.from(storeId);
+        const files = await dataStore.getFileSetForRootHash(rootHash, true);
+        // Prepare upload tasks
+        const uploadTasks = files.map((file) => ({
+            label: file.name,
+            dataPath: file.path,
+        }));
+        // Limit the number of concurrent uploads
+        const concurrencyLimit = 10; // Adjust this number as needed
+        await (0, promiseUtils_1.asyncPool)(concurrencyLimit, uploadTasks, async (task) => {
+            await propagationServer.uploadFile(task.label, task.dataPath, true);
         });
+        // Commit the session after all files have been uploaded
+        await propagationServer.commitUploadSession();
+        console.log((0, colorette_1.green)(`✔ All files have been uploaded to for Root Hash: ${(0, colorette_1.cyan)(rootHash)}.`));
     }
-    // Helper method to perform HEAD requests
-    async head(url) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new url_1.URL(url);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || PropagationServer.port,
-                path: urlObj.pathname + urlObj.search,
-                method: "HEAD",
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
-            };
-            const request = https_1.default.request(options, (response) => {
-                if (response.statusCode === 200) {
-                    resolve(true);
-                }
-                else {
-                    resolve(false);
-                }
+    /**
+     * Fetch a file from the server by sending a GET request and return its content in memory.
+     * Logs progress using a local cli-progress bar.
+     */
+    async fetchFile(dataPath) {
+        const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/fetch/${this.storeId}/${dataPath}`;
+        const config = {
+            responseType: "stream",
+            httpsAgent: this.createHttpsAgent(),
+        };
+        let progressBar;
+        try {
+            const response = await axios_1.default.get(url, config);
+            const totalLengthHeader = response.headers["content-length"];
+            const totalLength = totalLengthHeader
+                ? parseInt(totalLengthHeader, 10)
+                : null;
+            if (!totalLength) {
+                throw new Error("Content-Length header is missing");
+            }
+            // Create a new progress bar for the file
+            progressBar = new cli_progress_1.default.SingleBar({
+                format: `${(0, colorette_1.blue)("[{bar}]")} | ${(0, colorette_1.yellow)("{filename}")} | {percentage}% | {value}/{total} bytes`,
+                hideCursor: true,
+                barsize: 30,
+                align: "left",
+                autopadding: true,
+                noTTYOutput: false,
+                stopOnComplete: true,
+                clearOnComplete: false,
+            }, cli_progress_1.default.Presets.legacy);
+            progressBar.start(totalLength, 0, {
+                filename: formatFilename(dataPath),
             });
-            request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
-                reject(false);
+            let dataBuffers = [];
+            const progressStream = (0, progress_stream_1.default)({
+                length: totalLength,
+                time: 500, // Adjust as needed
             });
-            request.end();
-        });
+            progressStream.on("progress", (progress) => {
+                progressBar.update(progress.transferred);
+            });
+            // Add inactivity timeout to the progress stream
+            const passThroughStream = this.addInactivityTimeout(new stream_1.PassThrough(), PropagationServer.inactivityTimeout);
+            response.data.pipe(progressStream).pipe(passThroughStream);
+            progressStream.on("data", (chunk) => {
+                dataBuffers.push(chunk);
+            });
+            // Wait for the progress stream to finish
+            await new Promise((resolve, reject) => {
+                progressStream.on("end", resolve);
+                progressStream.on("error", reject);
+            });
+            return Buffer.concat(dataBuffers);
+        }
+        catch (error) {
+            storeExistsCache.del(`${this.storeId}-nohash`);
+            throw error;
+        }
+        finally {
+            if (progressBar) {
+                progressBar.stop();
+            }
+        }
     }
-    // Helper method to fetch JSON data from a URL
-    async fetchJson(url) {
-        const response = await this.fetch(url);
-        return JSON.parse(response);
+    /**
+     * Get details of a file, including whether it exists and its size.
+     */
+    async getFileDetails(dataPath, rootHash) {
+        try {
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
+            };
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/store/${this.storeId}/${rootHash}/${dataPath}`;
+            const response = await axios_1.default.head(url, config);
+            // Check the headers for file existence and size
+            const fileExists = response.headers["x-file-exists"] === "true";
+            const fileSize = parseInt(response.headers["x-file-size"], 10);
+            return {
+                exists: fileExists,
+                size: fileExists ? fileSize : 0,
+            };
+        }
+        catch (error) {
+            console.error((0, colorette_1.red)(`✖ Error checking file details for ${dataPath}:`), error.message);
+            throw error;
+        }
     }
-    // Helper method to fetch content with retries and redirection handling
-    /*private async fetchWithRetries(url: string): Promise<string> {
-      let attempt = 0;
-      const maxRetries = 5;
-      const initialDelay = 2000; // 2 seconds
-      const maxDelay = 10000; // 10 seconds
-      const delayMultiplier = 1.5;
-      let delay = initialDelay;
-  
-      while (attempt < maxRetries) {
+    /**
+     * Download a file from the server by sending a GET request.
+     * Logs progress using a local cli-progress bar.
+     */
+    async downloadFile(label, dataPath, rootHash, baseDir) {
+        const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/fetch/${this.storeId}/${dataPath}`;
+        let downloadPath = path_1.default.join(baseDir, dataPath);
+        // Ensure that the directory for the file exists
+        fs_1.default.mkdirSync(path_1.default.dirname(downloadPath), { recursive: true });
+        const config = {
+            responseType: "stream",
+            httpsAgent: this.createHttpsAgent(),
+        };
+        let progressBar;
         try {
-          return await this.fetch(url);
-        } catch (error: any) {
-          if (attempt < maxRetries - 1) {
-            console.warn(
-              `Attempt ${attempt + 1} failed: ${error.message}. Retrying in ${
-                delay / 1000
-              } seconds...`
-            );
-            await new Promise((resolve) => setTimeout(resolve, delay));
-            delay = Math.min(maxDelay, delay * delayMultiplier);
-          } else {
-            console.error(`Failed to retrieve data from ${url}. Aborting.`);
-            throw new Error(`Failed to retrieve data: ${error.message}`);
-          }
-        }
-        attempt++;
-      }
-      throw new Error(
-        `Failed to retrieve data from ${url} after ${maxRetries} attempts.`
-      );
-    }*/
-    // Helper method to create a stream with retry logic
-    async createReadStreamWithRetries(url) {
-        let attempt = 0;
-        const maxRetries = 1;
-        const initialDelay = PropagationServer.initialDelay;
-        const maxDelay = PropagationServer.maxDelay;
-        const delayMultiplier = PropagationServer.delayMultiplier;
-        let delay = initialDelay;
-        while (attempt < maxRetries) {
-            try {
-                return await this.createReadStream(url); // Stream data chunk by chunk
+            const response = await axios_1.default.get(url, config);
+            const totalLengthHeader = response.headers["content-length"];
+            const totalLength = totalLengthHeader
+                ? parseInt(totalLengthHeader, 10)
+                : null;
+            if (!totalLength) {
+                throw new Error("Content-Length header is missing");
             }
-            catch (error) {
-                if (attempt < maxRetries - 1) {
-                    console.warn(`Attempt ${attempt + 1} failed: ${error.message}. Retrying in ${delay / 1000} seconds...`);
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                    delay = Math.min(maxDelay, delay * delayMultiplier);
-                }
-                else {
-                    console.error(`Failed to create stream from ${url}. Aborting.`);
-                    throw new Error(`Failed to create stream: ${error.message}`);
+            // Create a new progress bar for the file
+            progressBar = new cli_progress_1.default.SingleBar({
+                format: `${(0, colorette_1.blue)("[{bar}]")} | ${(0, colorette_1.yellow)("{filename}")} | {percentage}% | {value}/{total} bytes`,
+                hideCursor: true,
+                barsize: 30,
+                align: "left",
+                autopadding: true,
+                noTTYOutput: false,
+                stopOnComplete: true,
+                clearOnComplete: false,
+            }, cli_progress_1.default.Presets.legacy);
+            progressBar.start(totalLength, 0, {
+                filename: formatFilename(label),
+            });
+            const fileWriteStream = fs_1.default.createWriteStream(downloadPath);
+            const progressStream = (0, progress_stream_1.default)({
+                length: totalLength,
+                time: 500, // Adjust as needed
+            });
+            progressStream.on("progress", (progress) => {
+                progressBar.update(progress.transferred);
+            });
+            // Add inactivity timeout to the progress stream
+            const passThroughStream = this.addInactivityTimeout(new stream_1.PassThrough(), PropagationServer.inactivityTimeout);
+            response.data
+                .pipe(progressStream)
+                .pipe(passThroughStream)
+                .pipe(fileWriteStream);
+            // Wait for both the file write stream and the progress stream to finish
+            await Promise.all([
+                new Promise((resolve, reject) => {
+                    fileWriteStream.on("finish", resolve);
+                    fileWriteStream.on("error", reject);
+                }),
+                new Promise((resolve, reject) => {
+                    progressStream.on("end", resolve);
+                    progressStream.on("error", reject);
+                }),
+            ]);
+            if (dataPath.includes("/data")) {
+                const integrity = await (0, merkle_1.merkleIntegrityCheck)(path_1.default.join(baseDir, `${rootHash}.dat`), baseDir, dataPath, rootHash);
+                if (!integrity) {
+                    throw new Error(`Integrity check failed for file: ${dataPath}`);
                 }
+                console.log("integrity check");
+            }
+        }
+        catch (error) {
+            storeExistsCache.del(`${this.storeId}-nohash`);
+            storeExistsCache.del(`${this.storeId}-${rootHash}`);
+            throw error;
+        }
+        finally {
+            if (progressBar) {
+                progressBar.stop();
             }
-            attempt++;
         }
-        throw new Error(`Failed to create stream from ${url} after ${maxRetries} attempts.`);
     }
-    // Helper method to fetch a readable stream from a URL
-    async createReadStream(url) {
-        return new Promise((resolve, reject) => {
-            const urlObj = new url_1.URL(url);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || PropagationServer.port,
-                path: urlObj.pathname + urlObj.search,
-                method: "GET",
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
-            };
-            const request = https_1.default.request(options, (response) => {
-                if (response.statusCode === 200) {
-                    resolve(response); // Return the response stream chunk by chunk
-                }
-                else if (response.statusCode === 301 || response.statusCode === 302) {
-                    const redirectUrl = response.headers.location;
-                    if (redirectUrl) {
-                        this.createReadStream(redirectUrl).then(resolve).catch(reject);
-                    }
-                    else {
-                        reject(new Error("Redirected without a location header"));
+    /**
+     * Static function to handle downloading multiple files from a DataStore based on file paths.
+     */
+    static async downloadStore(storeId, rootHash, ipAddress) {
+        const propagationServer = new PropagationServer(ipAddress, storeId);
+        // Initialize wallet
+        await propagationServer.initializeWallet();
+        // Check if the store exists
+        const { storeExists, rootHashExists } = await propagationServer.checkStoreExists(rootHash);
+        if (!storeExists || !rootHashExists) {
+            throw new Error(`Store ${storeId} does not exist.`);
+        }
+        // Fetch the rootHash.dat file
+        const datFileContent = await propagationServer.fetchFile(`${rootHash}.dat`);
+        const root = JSON.parse(datFileContent.toString());
+        // Prepare download tasks
+        const downloadTasks = [];
+        for (const [fileKey, fileData] of Object.entries(root.files)) {
+            const dataPath = (0, hashUtils_1.getFilePathFromSha256)(root.files[fileKey].sha256, "data");
+            const label = Buffer.from(fileKey, "hex").toString("utf-8");
+            downloadTasks.push({ label, dataPath });
+        }
+        // Limit the number of concurrent downloads
+        const concurrencyLimit = 10; // Adjust this number as needed
+        // Create a temporary directory
+        const tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "downloadStore-"));
+        try {
+            // Download files to the temporary directory
+            await (0, promiseUtils_1.asyncPool)(concurrencyLimit, downloadTasks, async (task) => {
+                await propagationServer.downloadFile(task.label, task.dataPath, rootHash, tempDir);
+            });
+            // Save the rootHash.dat file to the temporary directory
+            if (!fs_1.default.existsSync(tempDir)) {
+                fs_1.default.mkdirSync(tempDir, { recursive: true });
+            }
+            fs_1.default.writeFileSync(path_1.default.join(tempDir, `${rootHash}.dat`), datFileContent);
+            // Integrity check for the downloaded files was done during the download
+            // Here we want to make sure we got all the files or we reject the download session
+            for (const [fileKey, fileData] of Object.entries(root.files)) {
+                const dataPath = (0, hashUtils_1.getFilePathFromSha256)(root.files[fileKey].sha256, "data");
+                if (!fs_1.default.existsSync(path_1.default.join(tempDir, dataPath))) {
+                    if (!fs_1.default.existsSync(path_1.default.join(config_1.STORE_PATH, storeId, dataPath))) {
+                        throw new Error(`Missing file: ${Buffer.from(fileKey, "hex")}, aborting session.`);
                     }
                 }
-                else {
-                    reject(new Error(`Failed to retrieve stream from ${url}. Status code: ${response.statusCode}`));
-                }
-            });
-            request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
-                reject(error);
+            }
+            // After all downloads are complete, copy from temp directory to the main directory
+            const destinationDir = path_1.default.join(config_1.STORE_PATH, storeId);
+            fs_extra_1.default.copySync(tempDir, destinationDir, {
+                overwrite: false, // Prevents overwriting existing files
+                errorOnExist: false, // No error if file already exists
             });
-            request.end();
-        });
+            // Generate the manifest file in the main directory
+            const dataStore = blockchain_1.DataStore.from(storeId);
+            await dataStore.cacheStoreCreationHeight();
+            await dataStore.generateManifestFile();
+            console.log((0, colorette_1.green)(`✔ All files have been downloaded to ${storeId}.`));
+        }
+        catch (error) {
+            console.log((0, colorette_1.red)("✖ Error downloading files:"), error);
+        }
+        finally {
+            // Clean up the temporary directory
+            fs_extra_1.default.removeSync(tempDir);
+        }
     }
 }
 exports.PropagationServer = PropagationServer;
-PropagationServer.port = 4159;
-PropagationServer.maxRetries = 5;
-PropagationServer.initialDelay = 2000; // 2 seconds
-PropagationServer.maxDelay = 10000; // 10 seconds
-PropagationServer.delayMultiplier = 1.5;
+PropagationServer.port = 4159; // Static port used for all requests
+PropagationServer.inactivityTimeout = 5000; // Inactivity timeout in milliseconds (5 seconds)