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

package/dist/DigNetwork/ContentServer.d.ts

@@ -1,10 +1,11 @@
+import http from "http";
+import { Readable } from "stream";
 export declare class ContentServer {
     private ipAddress;
     private storeId;
     private static certPath;
     private static keyPath;
     private static readonly port;
-    private static readonly inactivityTimeout;
     constructor(ipAddress: string, storeId: string);
     getKey(key: string, rootHash: string, challengeHex?: string): Promise<string>;
     getPaymentAddress(): Promise<string | null>;
@@ -14,18 +15,19 @@ export declare class ContentServer {
     getKeysIndex(rootHash?: string): Promise<any>;
     headKey(key: string, rootHash?: string): Promise<{
         success: boolean;
-        headers?: any;
+        headers?: http.IncomingHttpHeaders;
     }>;
     headStore(options?: {
         hasRootHash: string;
     }): Promise<{
         success: boolean;
-        headers?: any;
+        headers?: http.IncomingHttpHeaders;
     }>;
     hasRootHash(rootHash: string): Promise<boolean>;
+    streamKey(key: string, rootHash?: string): Promise<Readable>;
     private head;
     private fetchJson;
+    private fetchWithRetries;
     private fetch;
-    private getAxiosConfig;
 }
 //# sourceMappingURL=ContentServer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ContentServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/ContentServer.ts"],"names":[],"mappings":"AAMA,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;gBAErC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAYjC,MAAM,CACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC;IAWL,iBAAiB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAc3C,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC;IAM5B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAU7C,OAAO,CAClB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,GAAG,CAAA;KAAE,CAAC;IAUlC,SAAS,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACjE,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,GAAG,CAAC;KACf,CAAC;IAQW,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;YAW9C,IAAI;YAcJ,SAAS;YAMT,KAAK;IA+DnB,OAAO,CAAC,cAAc;CAUvB"}
+{"version":3,"file":"ContentServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/ContentServer.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAGlC,qBAAa,aAAa;IACxB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;gBAExB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAYjC,MAAM,CACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC;IAaL,iBAAiB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAe3C,YAAY,IAAI,OAAO,CAAC,GAAG,CAAC;IAM5B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAM9B,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAY7C,OAAO,CAClB,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAA;KAAE,CAAC;IAYvD,SAAS,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACjE,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,CAAC;KACpC,CAAC;IAUW,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAUrD,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;YAgDrD,IAAI;YA0EJ,SAAS;YAMT,gBAAgB;YAiChB,KAAK;CA6GpB"}

package/dist/DigNetwork/ContentServer.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentServer = void 0;
-const axios_1 = __importDefault(require("axios"));
 const fs_1 = __importDefault(require("fs"));
-const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
 const ssl_1 = require("../utils/ssl");
 class ContentServer {
     constructor(ipAddress, storeId) {
@@ -20,11 +20,13 @@ class ContentServer {
     }
     // Method to get the content of a specified key from the peer, with optional challenge query
     async getKey(key, rootHash, challengeHex) {
+        // Construct the base URL
         let url = `https://${this.ipAddress}:${ContentServer.port}/chia.${this.storeId}.${rootHash}/${key}`;
+        // If a challenge is provided, append it as a query parameter
         if (challengeHex) {
             url += `?challenge=${challengeHex}`;
         }
-        return this.fetch(url);
+        return this.fetchWithRetries(url);
     }
     // Method to get the payment address from the peer
     async getPaymentAddress() {
@@ -88,89 +90,219 @@ class ContentServer {
         }
         return false;
     }
-    // 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 };
+    streamKey(key, rootHash) {
+        let udi = `chia.${this.storeId}`;
+        if (rootHash) {
+            udi += `.${rootHash}`;
         }
+        return new Promise((resolve, reject) => {
+            const url = `https://${this.ipAddress}:${ContentServer.port}/${udi}/${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(`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 === "http:" ? 80 : ContentServer.port),
+                    path: urlObj.pathname + urlObj.search,
+                    method: "HEAD",
+                    key: fs_1.default.readFileSync(ContentServer.keyPath),
+                    cert: fs_1.default.readFileSync(ContentServer.certPath),
+                    rejectUnauthorized: false,
+                };
+                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(`HEAD ${url}:`, error.message);
+                    reject({ success: false });
+                });
+                request.end();
+            }
+            catch (err) {
+                console.error(`Invalid URL: ${url}`, err);
+                reject({ success: false, message: "Invalid URL" });
+            }
+        });
     }
     // Helper method to fetch JSON data from a URL
     async fetchJson(url) {
-        const response = await this.fetch(url);
+        const response = await this.fetchWithRetries(url);
         return JSON.parse(response);
     }
-    // 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) => {
-            let timeout = null;
-            const resetTimeout = () => {
-                if (timeout) {
-                    clearTimeout(timeout);
+    // Helper method to fetch content with retries and redirection handling
+    async fetchWithRetries(url) {
+        let attempt = 0;
+        const maxRetries = 1;
+        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);
                 }
-                timeout = setTimeout(() => {
-                    source.cancel(`Request timed out after ${ContentServer.inactivityTimeout / 1000} seconds of inactivity`);
-                }, ContentServer.inactivityTimeout);
+                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 with a 5-second inactivity timeout
+    async fetch(url, maxRedirects = 5) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const timeoutDuration = 5000; // 5 seconds
+            let timeout = null; // Initialize timeout
+            const requestOptions = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || ContentServer.port,
+                path: urlObj.pathname + urlObj.search, // Include query params
+                method: "GET",
+                key: fs_1.default.readFileSync(ContentServer.keyPath),
+                cert: fs_1.default.readFileSync(ContentServer.certPath),
+                rejectUnauthorized: false,
             };
-            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) => {
+            const request = http_1.default.request(requestOptions, (response) => {
                 let data = "";
-                response.data.on("data", (chunk) => {
-                    data += chunk;
-                    resetTimeout(); // Reset the timeout when data is received
-                });
-                response.data.on("end", () => {
+                // Set timeout for inactivity
+                timeout = setTimeout(() => {
+                    console.error(`Request timeout: No data received for ${timeoutDuration / 1000} seconds.`);
+                    request.destroy(); // Use destroy instead of abort
+                    reject(new Error(`Request timed out after ${timeoutDuration / 1000} seconds of inactivity`));
+                }, timeoutDuration);
+                const resetTimeout = () => {
                     if (timeout) {
-                        clearTimeout(timeout); // Clear timeout on stream end
+                        clearTimeout(timeout);
                     }
-                    resolve(data);
-                });
-                response.data.on("error", (error) => {
+                    timeout = setTimeout(() => {
+                        console.error(`Request timeout: No data received for ${timeoutDuration / 1000} seconds.`);
+                        request.destroy(); // Use destroy instead of abort
+                        reject(new Error(`Request timed out after ${timeoutDuration / 1000} seconds of inactivity`));
+                    }, timeoutDuration);
+                };
+                if (response.statusCode === 200) {
+                    response.on("data", (chunk) => {
+                        data += chunk;
+                        resetTimeout(); // Reset the timeout every time data is received
+                    });
+                    response.on("end", () => {
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
+                        resolve(data);
+                    });
+                }
+                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
+                        if (timeout) {
+                            clearTimeout(timeout);
+                        }
+                        this.fetch(redirectUrl.toString(), maxRedirects - 1)
+                            .then(resolve)
+                            .catch(reject);
+                    }
+                    else {
+                        reject(new Error("Too many redirects"));
+                    }
+                }
+                else {
                     if (timeout) {
                         clearTimeout(timeout);
                     }
-                    reject(error);
-                });
-            })
-                .catch((error) => {
-                if (axios_1.default.isCancel(error)) {
-                    console.error("Request canceled:", error.message);
+                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${response.statusCode}`));
                 }
-                else {
-                    console.error(`Failed to retrieve data from ${url}:`, error.message);
+            });
+            request.on("error", (error) => {
+                if (timeout) {
+                    clearTimeout(timeout);
                 }
+                console.error(`GET ${url}:`, error.message);
                 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 = 4161;
-ContentServer.inactivityTimeout = 5000; // Inactivity timeout in milliseconds (5 seconds)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/dig-sdk",
-  "version": "0.0.1-alpha.100",
+  "version": "0.0.1-alpha.101",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",