@dignetwork/dig-sdk 0.0.1-alpha.10 → 0.0.1-alpha.100

package/dist/DigNetwork/ContentServer.js

@@ -4,22 +4,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentServer = void 0;
-const http_1 = __importDefault(require("http"));
-const url_1 = require("url");
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const ssl_1 = require("../utils/ssl");
 class ContentServer {
     constructor(ipAddress, storeId) {
         this.ipAddress = ipAddress;
         this.storeId = storeId;
+        if (!ContentServer.certPath || !ContentServer.keyPath) {
+            const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+            ContentServer.certPath = certPath;
+            ContentServer.keyPath = keyPath;
+        }
     }
     // 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 = `http://${this.ipAddress}/chia.${this.storeId}.${rootHash}/${key}`;
-        // If a challenge is provided, append it as a query parameter
+        let url = `https://${this.ipAddress}:${ContentServer.port}/chia.${this.storeId}.${rootHash}/${key}`;
         if (challengeHex) {
             url += `?challenge=${challengeHex}`;
         }
-        return this.fetchWithRetries(url);
+        return this.fetch(url);
     }
     // Method to get the payment address from the peer
     async getPaymentAddress() {
@@ -30,214 +35,142 @@ 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
     async getWellKnown() {
-        const url = `http://${this.ipAddress}/.well-known`;
+        const url = `https://${this.ipAddress}:${ContentServer.port}/.well-known`;
         return this.fetchJson(url);
     }
     // Method to get the list of known stores
     async getKnownStores() {
-        const url = `http://${this.ipAddress}/.well-known/stores`;
+        const url = `https://${this.ipAddress}:${ContentServer.port}/.well-known/stores`;
         return this.fetchJson(url);
     }
     // Method to get the index of all stores
     async getStoresIndex() {
-        const url = `http://${this.ipAddress}/`;
+        const url = `https://${this.ipAddress}:${ContentServer.port}/`;
         return this.fetchJson(url);
     }
     // Method to get the index of keys in a store
-    async getKeysIndex() {
-        const url = `http://${this.ipAddress}/${this.storeId}`;
+    async getKeysIndex(rootHash) {
+        let udi = `chia.${this.storeId}`;
+        if (rootHash) {
+            udi += `.${rootHash}`;
+        }
+        const url = `https://${this.ipAddress}:${ContentServer.port}/${udi}`;
         return this.fetchJson(url);
     }
     // Method to check if a specific key exists (HEAD request)
-    async headKey(key) {
-        const url = `http://${this.ipAddress}/${this.storeId}/${key}`;
-        return this.head(url); // Return the object from head method
+    async headKey(key, rootHash) {
+        let udi = `chia.${this.storeId}`;
+        if (rootHash) {
+            udi += `.${rootHash}`;
+        }
+        const url = `https://${this.ipAddress}:${ContentServer.port}/${udi}/${key}`;
+        return this.head(url);
     }
     // Method to check if a specific store exists (HEAD request)
-    async headStore() {
-        const url = `http://${this.ipAddress}/${this.storeId}`;
-        console.log({ url });
-        return this.head(url); // Return the object from head method
+    async headStore(options) {
+        let url = `https://${this.ipAddress}:${ContentServer.port}/chia.${this.storeId}`;
+        if (options?.hasRootHash) {
+            url += `?hasRootHash=${options.hasRootHash}`;
+        }
+        return this.head(url);
     }
-    streamKey(key) {
-        return new Promise((resolve, reject) => {
-            const url = `http://${this.ipAddress}/${this.storeId}/${key}`;
-            const urlObj = new url_1.URL(url);
-            const requestOptions = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || ContentServer.port,
-                path: urlObj.pathname + urlObj.search,
-                method: "GET",
-            };
-            const request = http_1.default.request(requestOptions, (response) => {
-                if (response.statusCode === 200) {
-                    resolve(response); // Resolve with the readable stream
-                }
-                else if (response.statusCode === 301 || response.statusCode === 302) {
-                    // Handle redirects
-                    const redirectUrl = response.headers.location;
-                    if (redirectUrl) {
-                        this.streamKey(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(`Request error for ${url}:`, error);
-                reject(error);
-            });
-            request.end();
+    async hasRootHash(rootHash) {
+        const { success, headers } = await this.headStore({
+            hasRootHash: rootHash,
         });
+        if (success) {
+            return headers?.["x-has-root-hash"] === "true";
+        }
+        return false;
     }
-    // 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 === "http:" ? 80 : ContentServer.port),
-                    path: urlObj.pathname + urlObj.search,
-                    method: "HEAD",
-                };
-                const request = http_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(`Request error for ${url}:`, error);
-                    reject({ success: false });
-                });
-                request.end();
-            }
-            catch (err) {
-                console.error(`Invalid URL: ${url}`, err);
-                reject({ success: false, message: "Invalid URL" });
-            }
-        });
+    // Helper method to perform HEAD requests using axios
+    async head(url) {
+        try {
+            const config = this.getAxiosConfig();
+            const response = await axios_1.default.head(url, config);
+            return {
+                success: response.status >= 200 && response.status < 300,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            return { success: false };
+        }
     }
     // Helper method to fetch JSON data from a URL
     async fetchJson(url) {
-        const response = await this.fetchWithRetries(url);
+        const response = await this.fetch(url);
         return JSON.parse(response);
     }
-    // Helper method to fetch content with retries and redirection handling
-    async fetchWithRetries(url) {
-        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) {
-            try {
-                return await this.fetch(url);
-            }
-            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 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.`);
-    }
-    // Core method to fetch content from a URL
-    async fetch(url, maxRedirects = 5) {
+    // Core method to fetch content from a URL with a 5-second inactivity timeout, handling redirects
+    async fetch(url) {
+        const config = this.getAxiosConfig();
+        // Create a cancel token for the inactivity timeout
+        const source = axios_1.default.CancelToken.source();
         return new Promise((resolve, reject) => {
-            const urlObj = new url_1.URL(url);
-            const requestOptions = {
-                hostname: urlObj.hostname,
-                port: urlObj.port || ContentServer.port,
-                path: urlObj.pathname + urlObj.search, // Include query params
-                method: "GET",
+            let timeout = null;
+            const resetTimeout = () => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                timeout = setTimeout(() => {
+                    source.cancel(`Request timed out after ${ContentServer.inactivityTimeout / 1000} seconds of inactivity`);
+                }, ContentServer.inactivityTimeout);
             };
-            const request = http_1.default.request(requestOptions, (response) => {
+            axios_1.default
+                .get(url, {
+                ...config,
+                cancelToken: source.token,
+                responseType: "stream", // Use stream to track data transfer
+                maxRedirects: 5, // Axios follows up to 5 redirects by default
+            })
+                .then((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) &&
-                    response.headers.location) {
-                    // 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()}`);
-                        this.fetch(redirectUrl.toString(), maxRedirects - 1)
-                            .then(resolve)
-                            .catch(reject);
+                response.data.on("data", (chunk) => {
+                    data += chunk;
+                    resetTimeout(); // Reset the timeout when data is received
+                });
+                response.data.on("end", () => {
+                    if (timeout) {
+                        clearTimeout(timeout); // Clear timeout on stream end
                     }
-                    else {
-                        reject(new Error("Too many redirects"));
+                    resolve(data);
+                });
+                response.data.on("error", (error) => {
+                    if (timeout) {
+                        clearTimeout(timeout);
                     }
+                    reject(error);
+                });
+            })
+                .catch((error) => {
+                if (axios_1.default.isCancel(error)) {
+                    console.error("Request canceled:", error.message);
                 }
                 else {
-                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
+                    console.error(`Failed to retrieve data from ${url}:`, error.message);
                 }
-            });
-            request.on("error", (error) => {
-                console.error(`Request error for ${url}:`, error);
                 reject(error);
             });
-            request.end();
         });
     }
+    // Helper method to configure axios with HTTPS settings
+    getAxiosConfig() {
+        return {
+            httpsAgent: new https_1.default.Agent({
+                cert: fs_1.default.readFileSync(ContentServer.certPath),
+                key: fs_1.default.readFileSync(ContentServer.keyPath),
+                rejectUnauthorized: false,
+            }),
+            timeout: 0, // Disable axios timeout (we're using inactivity timeout)
+        };
+    }
 }
 exports.ContentServer = ContentServer;
-ContentServer.port = 80;
+ContentServer.port = 4161;
+ContentServer.inactivityTimeout = 5000; // Inactivity timeout in milliseconds (5 seconds)

package/dist/DigNetwork/DigNetwork.d.ts

@@ -5,16 +5,10 @@ export declare class DigNetwork {
     private storeDir;
     private peerBlacklist;
     constructor(storeId: string);
-    private uploadPreflight;
-    uploadStoreHead(digPeer: DigPeer): Promise<void>;
-    uploadStore(digPeer: DigPeer): Promise<void>;
     static subscribeToStore(storeId: string): Promise<void>;
+    static findPeerWithStoreKey(storeId: string, rootHash: string, key?: string, intialBlackList?: string[]): Promise<DigPeer | null>;
     static unsubscribeFromStore(storeId: string): void;
-    downloadFiles(forceDownload?: boolean, renderProgressBar?: boolean, skipData?: boolean): Promise<void>;
-    private fetchAvailablePeers;
-    private downloadHeightFile;
-    private downloadManifestFile;
-    private downloadFileFromPeers;
-    private runProgressBar;
+    syncStoreFromPeers(maxRootsToProcess?: number): Promise<void>;
+    fetchAvailablePeers(): Promise<DigPeer[]>;
 }
 //# sourceMappingURL=DigNetwork.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;YAOb,eAAe;IA8ChB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAsDhD,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;WA6BrC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQtD,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQ5C,aAAa,CACxB,aAAa,GAAE,OAAe,EAC9B,iBAAiB,GAAE,OAAc,EACjC,QAAQ,GAAE,OAAe,GACxB,OAAO,CAAC,IAAI,CAAC;YAqFF,mBAAmB;YAWnB,kBAAkB;YASlB,oBAAoB;YASpB,qBAAqB;YAuErB,cAAc;CAoB7B"}
+{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA2DZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO5C,kBAAkB,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiG7D,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}