@dignetwork/dig-sdk 0.0.1-alpha.51 → 0.0.1-alpha.54

package/dist/DigNetwork/PropagationServer.js

@@ -4,444 +4,343 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropagationServer = void 0;
+const axios_1 = __importDefault(require("axios"));
 const fs_1 = __importDefault(require("fs"));
-const https_1 = __importDefault(require("https"));
-const url_1 = require("url");
+const path_1 = __importDefault(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const blockchain_1 = require("../blockchain");
 const ssl_1 = require("../utils/ssl");
 const credentialsUtils_1 = require("../utils/credentialsUtils");
-const blockchain_1 = require("../blockchain");
+const https_1 = __importDefault(require("https"));
+const cli_progress_1 = __importDefault(require("cli-progress"));
+const chalk_1 = __importDefault(require("chalk")); // For colored output
+const ora_1 = __importDefault(require("ora")); // For spinners
+const config_1 = require("../utils/config");
+const hashUtils_1 = require("../utils/hashUtils");
 class PropagationServer {
-    constructor(ipAddress, storeId) {
-        this.ipAddress = ipAddress;
+    constructor(storeId, 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(fileLocation, dataPath) {
-        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}/${dataPath}`;
-        await this.retryOperation(() => this.uploadFileDirect(fileLocation, uploadUrl, username, password, keyOwnershipSig, publicKey.toString("hex"), nonce), `Upload failed for ${dataPath}`);
-    }
-    // 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);
-    }
-    // Method to check if a specific store exists (HEAD request)
-    async headStore(options) {
-        let url = `https://${this.ipAddress}:${PropagationServer.port}/${this.storeId}`;
-        if (options?.hasRootHash) {
-            url += `?hasRootHash=${options.hasRootHash}`;
-        }
-        return this.head(url);
-    }
-    // In PropagationServer.ts:
-    async isStoreSynced() {
-        const status = await this.getStatus();
-        return status.synced === true;
-    }
-    // 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 };
+        this.sessionId = ""; // Session ID will be set after starting the upload session
+        this.publicKey = ""; // Public key will be set after initializing the wallet
+        this.ipAddress = ipAddress;
+        // Get or create SSL certificates
+        const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+        this.certPath = certPath;
+        this.keyPath = keyPath;
     }
-    // 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",
-                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}`));
-                }
-            });
-            req.on("error", (err) => {
-                reject(err);
-            });
-            req.write(data);
-            req.end();
-        });
+    /**
+     * Initialize the Wallet instance.
+     */
+    async initializeWallet() {
+        this.wallet = await blockchain_1.Wallet.load("default");
+        this.publicKey = await this.wallet.getPrivateSyntheticKey();
     }
-    // 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 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}`));
-                }
-            });
-            req.on("error", (err) => {
-                console.error(err.message);
-                resolve(false); // Resolve to false if there is an error
-            });
-            req.end();
+    /**
+     * 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, // Allow self-signed certificates
         });
     }
-    // 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",
-                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,
-                },
-                key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                rejectUnauthorized: false,
+    /**
+     * Check if the store and optional root hash exist by making a HEAD request.
+     *
+     * @param {string} [rootHash] - Optional root hash to check for existence.
+     * @returns {Promise<{ storeExists: boolean, rootHashExists: boolean }>} - An object indicating if the store and root hash exist.
+     */
+    async checkStoreExists(rootHash) {
+        const spinner = (0, ora_1.default)(`Checking if store ${this.storeId} exists...`).start();
+        try {
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
             };
-            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}`));
-                }
-            });
-            req.on("error", (err) => {
-                reject(err);
-            });
-            fileStream.pipe(req);
-            fileStream.on("error", (err) => {
-                reject(err);
-            });
-            req.on("end", () => {
-                resolve();
-            });
-        });
-    }
-    // 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();
+            let url = `https://${this.ipAddress}:${PropagationServer.port}/stores/${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.succeed(chalk_1.default.green(`Store ${this.storeId} exists!`));
             }
-            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 {
+                spinner.fail(chalk_1.default.red(`Store ${this.storeId} does not exist.`));
+            }
+            if (rootHash) {
+                if (rootHashExists) {
+                    console.log(chalk_1.default.green(`Root hash ${rootHash} exists in the store.`));
                 }
                 else {
-                    console.error(`${errorMessage}. Aborting.`);
-                    throw error;
+                    console.log(chalk_1.default.red(`Root hash ${rootHash} does not exist in the store.`));
                 }
             }
-            attempt++;
+            return { storeExists, rootHashExists };
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red("Error checking if store exists:"));
+            console.error(chalk_1.default.red(error));
+            throw error;
         }
-        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,
+    /**
+     * Start an upload session by sending a POST request to the server.
+     */
+    async startUploadSession() {
+        const spinner = (0, ora_1.default)(`Starting upload session for store ${this.storeId}...`).start();
+        try {
+            const config = {
+                httpsAgent: this.createHttpsAgent(),
             };
-            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"));
-                    }
-                }
-                else {
-                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
-                }
-            });
-            request.on("error", (error) => {
-                console.error(`GET Request error for ${url}:`, error);
-                reject(error);
-            });
-            request.end();
-        });
-    }
-    // Helper method to perform HEAD requests
-    async head(url, maxRedirects = 5) {
-        return new Promise((resolve, reject) => {
-            try {
-                // Parse the input URL
-                const urlObj = new url_1.URL(url);
-                const requestOptions = {
-                    hostname: urlObj.hostname,
-                    port: urlObj.port || (urlObj.protocol === "https:" ? 443 : undefined),
-                    path: urlObj.pathname + urlObj.search,
-                    method: "HEAD",
-                    key: fs_1.default.readFileSync(PropagationServer.keyPath),
-                    cert: fs_1.default.readFileSync(PropagationServer.certPath),
-                    rejectUnauthorized: false,
+            // Add Basic Auth headers if credentials are provided
+            if (this.username && this.password) {
+                config.auth = {
+                    username: this.username,
+                    password: this.password,
                 };
-                const request = https_1.default.request(requestOptions, (response) => {
-                    const { statusCode, headers } = response;
-                    // If status code is 2xx, return success
-                    if (statusCode && statusCode >= 200 && statusCode < 300) {
-                        resolve({ success: true, headers });
-                    }
-                    // Handle 3xx redirection
-                    else if (statusCode && statusCode >= 300 && statusCode < 400 && headers.location) {
-                        if (maxRedirects > 0) {
-                            let redirectUrl = headers.location;
-                            // Check if the redirect URL is relative
-                            if (!/^https?:\/\//i.test(redirectUrl)) {
-                                // Resolve the relative URL based on the original URL
-                                redirectUrl = new url_1.URL(redirectUrl, url).toString();
-                                console.log(`Resolved relative redirect to: ${redirectUrl}`);
-                            }
-                            else {
-                                console.log(`Redirecting to: ${redirectUrl}`);
-                            }
-                            // Recursively follow the redirection
-                            this.head(redirectUrl, maxRedirects - 1)
-                                .then(resolve)
-                                .catch(reject);
-                        }
-                        else {
-                            reject({ success: false, message: "Too many redirects" });
-                        }
-                    }
-                    else {
-                        // For other status codes, consider it a failure
-                        resolve({ success: false });
-                    }
-                });
-                request.on("error", (error) => {
-                    console.error(`HEAD ${url}:`, error.message);
-                    reject({ success: false });
-                });
-                request.end();
-            }
-            catch (err) {
-                console.error(`Invalid URL: ${url}`, err.message);
-                reject({ success: false, message: "Invalid URL" });
             }
+            const url = `https://${this.ipAddress}:${PropagationServer.port}/upload/${this.storeId}`;
+            const response = await axios_1.default.post(url, { publicKey: this.publicKey }, config);
+            this.sessionId = response.data.sessionId;
+            spinner.succeed(chalk_1.default.green(`Upload session started for DataStore ${this.storeId} with session ID ${this.sessionId}`));
+        }
+        catch (error) {
+            spinner.fail(chalk_1.default.red("Error starting upload session:"));
+            console.error(chalk_1.default.red(error));
+            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://${this.ipAddress}:${PropagationServer.port}/upload/${this.storeId}/${this.sessionId}/${filename}`;
+            const response = await axios_1.default.head(url, config);
+            const nonce = response.headers["x-nonce"];
+            console.log(chalk_1.default.blue(`Nonce received for file ${filename}: ${nonce}`));
+            return nonce;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Error generating nonce for file ${filename}:`), error);
+            throw error;
+        }
+    }
+    /**
+     * Upload a file to the server by sending a PUT request.
+     * Logs progress using cli-progress for each file.
+     */
+    async uploadFile(filePath) {
+        const filename = path_1.default.basename(filePath);
+        const nonce = await this.getFileNonce(filename);
+        const keyOwnershipSig = await this.wallet.createKeyOwnershipSignature(nonce);
+        const formData = new form_data_1.default();
+        formData.append("file", fs_1.default.createReadStream(filePath));
+        const fileSize = fs_1.default.statSync(filePath).size;
+        // Create a new progress bar for each file
+        const progressBar = PropagationServer.multiBar.create(fileSize, 0, {
+            filename: chalk_1.default.yellow(filename),
+            percentage: 0,
         });
+        let uploadedBytes = 0;
+        const config = {
+            headers: {
+                "Content-Type": "multipart/form-data",
+                "x-nonce": nonce,
+                "x-public-key": this.publicKey,
+                "x-key-ownership-sig": keyOwnershipSig,
+                ...formData.getHeaders(),
+            },
+            httpsAgent: this.createHttpsAgent(),
+            // Tracking upload progress and updating the progress bar
+            onUploadProgress: (progressEvent) => {
+                uploadedBytes += progressEvent.loaded;
+                const percentage = Math.round((uploadedBytes / fileSize) * 100);
+                progressBar.update(uploadedBytes, { percentage });
+            },
+        };
+        try {
+            const url = `https://${this.ipAddress}:${PropagationServer.port}/upload/${this.storeId}/${this.sessionId}/${filename}`;
+            const response = await axios_1.default.put(url, formData, config);
+            console.log(chalk_1.default.green(`✔ File ${filename} uploaded successfully.`));
+            // Complete the progress bar
+            progressBar.update(fileSize, { percentage: 100 });
+            progressBar.stop();
+            return response.data;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`✖ Error uploading file ${filename}:`), error);
+            progressBar.stop(); // Stop the progress bar in case of error
+            throw error;
+        }
     }
-    // Helper method to fetch JSON data from a URL
-    async fetchJson(url) {
-        const response = await this.fetch(url);
-        return JSON.parse(response);
+    /**
+     * Static function to handle the entire upload process for multiple files based on rootHash.
+     * @param {string} storeId - The ID of the DataStore.
+     * @param {string} rootHash - The root hash used to derive the file set.
+     * @param {string} publicKey - The public key of the user.
+     * @param {string} ipAddress - The IP address of the server.
+     */
+    static async uploadStore(storeId, rootHash, ipAddress) {
+        const propagationServer = new PropagationServer(storeId, ipAddress);
+        // Initialize wallet
+        await propagationServer.initializeWallet();
+        // Check if the store exists
+        const storeExists = await propagationServer.checkStoreExists();
+        // If the store does not exist, prompt for credentials
+        if (!storeExists) {
+            console.log(chalk_1.default.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;
+        }
+        // Start the upload session
+        await propagationServer.startUploadSession();
+        const dataStore = blockchain_1.DataStore.from(storeId);
+        const filePaths = await dataStore.getFileSetForRootHash(rootHash);
+        // Upload each file
+        for (const filePath of filePaths) {
+            await propagationServer.uploadFile(filePath);
+        }
+        // Stop all progress bars after the files are uploaded
+        PropagationServer.multiBar.stop();
+        console.log(chalk_1.default.green(`✔ All files have been uploaded to DataStore ${storeId}.`));
     }
-    // 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) {
+    /**
+     * Fetch a file from the server by sending a GET request and return its content in memory.
+     * Logs progress using cli-progress.
+     * @param {string} dataPath - The data path of the file to download.
+     * @returns {Promise<Buffer>} - The file content in memory as a Buffer.
+     */
+    async fetchFile(dataPath) {
+        const config = {
+            responseType: "arraybuffer", // To store the file content in memory
+            httpsAgent: this.createHttpsAgent(),
+        };
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/fetch/${this.storeId}/${dataPath}`;
         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}`);
-          }
+            const response = await axios_1.default.get(url, config);
+            const totalLength = parseInt(response.headers["content-length"], 10);
+            console.log(chalk_1.default.cyan(`Starting fetch for ${dataPath}...`));
+            // Create a progress bar for the download
+            const progressBar = PropagationServer.multiBar.create(totalLength, 0, {
+                dataPath: chalk_1.default.yellow(dataPath),
+                percentage: 0,
+            });
+            let downloadedBytes = 0;
+            // Track progress of downloading the file
+            response.data.on("data", (chunk) => {
+                downloadedBytes += chunk.length;
+                progressBar.update(downloadedBytes, {
+                    percentage: Math.round((downloadedBytes / totalLength) * 100),
+                });
+            });
+            // Complete the progress bar once done
+            progressBar.update(totalLength, { percentage: 100 });
+            progressBar.stop();
+            console.log(chalk_1.default.green(`✔ File ${dataPath} fetched successfully.`));
+            // Return the file contents as a Buffer
+            return Buffer.from(response.data);
         }
-        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
-            }
-            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}`);
-                }
-            }
-            attempt++;
+        catch (error) {
+            console.error(chalk_1.default.red(`✖ Error fetching file ${dataPath}:`), error);
+            throw error;
         }
-        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"));
-                    }
-                }
-                else {
-                    reject(new Error(`Failed to retrieve stream from ${url}. Status code: ${response.statusCode}`));
-                }
+    /**
+     * Download a file from the server by sending a GET request.
+     * Logs progress using cli-progress.
+     * @param {string} dataPath - The data path of the file to download.
+     */
+    async downloadFile(dataPath) {
+        const config = {
+            responseType: "stream", // Make sure the response is streamed
+            httpsAgent: this.createHttpsAgent(),
+        };
+        const url = `https://${this.ipAddress}:${PropagationServer.port}/fetch/${this.storeId}/${dataPath}`;
+        const downloadPath = path_1.default.join(config_1.STORE_PATH, this.storeId, dataPath); // Save to the correct store directory
+        // Ensure that the directory for the file exists
+        fs_1.default.mkdirSync(path_1.default.dirname(downloadPath), { recursive: true });
+        const fileWriteStream = fs_1.default.createWriteStream(downloadPath);
+        try {
+            const response = await axios_1.default.get(url, config);
+            const totalLength = parseInt(response.headers["content-length"], 10);
+            console.log(chalk_1.default.cyan(`Starting download for ${dataPath}...`));
+            // Create a progress bar for the download
+            const progressBar = PropagationServer.multiBar.create(totalLength, 0, {
+                dataPath: chalk_1.default.yellow(dataPath),
+                percentage: 0,
             });
-            request.on("error", (error) => {
-                console.error(`GET ${url}:`, error.message);
-                reject(error);
+            let downloadedBytes = 0;
+            // Pipe the response data to the file stream and track progress
+            response.data.on("data", (chunk) => {
+                downloadedBytes += chunk.length;
+                progressBar.update(downloadedBytes, {
+                    percentage: Math.round((downloadedBytes / totalLength) * 100),
+                });
             });
-            request.end();
-        });
+            // Pipe the data into the file and finalize
+            response.data.pipe(fileWriteStream);
+            return new Promise((resolve, reject) => {
+                fileWriteStream.on("finish", () => {
+                    progressBar.update(totalLength, { percentage: 100 });
+                    progressBar.stop();
+                    console.log(chalk_1.default.green(`✔ File ${dataPath} downloaded successfully to ${downloadPath}.`));
+                    resolve();
+                });
+                fileWriteStream.on("error", (error) => {
+                    progressBar.stop();
+                    console.error(chalk_1.default.red(`✖ Error downloading file ${dataPath}:`), error);
+                    reject(error);
+                });
+            });
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`✖ Error downloading file ${dataPath}:`), error);
+            throw error;
+        }
+    }
+    /**
+     * Static function to handle downloading multiple files from a DataStore based on file paths.
+     * @param {string} storeId - The ID of the DataStore.
+     * @param {string[]} dataPaths - The list of data paths to download.
+     * @param {string} ipAddress - The IP address of the server.
+     */
+    static async downloadStore(storeId, rootHash, ipAddress) {
+        const propagationServer = new PropagationServer(storeId, ipAddress);
+        // Initialize wallet
+        await propagationServer.initializeWallet();
+        // Check if the store exists
+        const storeExists = await propagationServer.checkStoreExists();
+        if (!storeExists) {
+            throw new Error(`Store ${storeId} does not exist.`);
+        }
+        await propagationServer.downloadFile("height.json");
+        const datFileContent = await propagationServer.fetchFile(`${rootHash}.dat`);
+        const root = JSON.parse(datFileContent.toString());
+        for (const [fileKey, fileData] of Object.entries(root.files)) {
+            const dataPath = (0, hashUtils_1.getFilePathFromSha256)(root.files[fileKey].sha256, "data");
+            await propagationServer.downloadFile(dataPath);
+        }
+        console.log(chalk_1.default.green(`✔ All files have been downloaded to ${storeId}.`));
     }
 }
 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
+// MultiBar for handling multiple progress bars
+PropagationServer.multiBar = new cli_progress_1.default.MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: chalk_1.default.green(" {bar} ") +
+        chalk_1.default.cyan(" | {filename} | {percentage}% | {value}/{total} bytes"),
+    barsize: 40,
+    stopOnComplete: true,
+    align: "center",
+}, cli_progress_1.default.Presets.shades_classic);