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

package/dist/DigNetwork/ContentServer.js

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

package/dist/DigNetwork/DigNetwork.d.ts

@@ -4,17 +4,23 @@ export declare class DigNetwork {
     private serverCoin;
     private storeDir;
     private peerBlacklist;
+    private static networkSyncMap;
     constructor(storeId: string);
-    private uploadPreflight;
-    uploadStoreHead(digPeer: DigPeer): Promise<void>;
-    uploadStore(digPeer: DigPeer): Promise<void>;
     static subscribeToStore(storeId: string): Promise<void>;
+    static getAllNetworkDataStoreIds(): string[];
+    static getUdiContent(udi: string): Promise<void>;
+    /**
+     * Find a peer that has the store key and root hash, using ranked peers first and searching in groups of 5.
+     *
+     * @param {string} storeId - The ID of the store.
+     * @param {string} rootHash - The root hash of the store.
+     * @param {string} [key] - Optional key to check for in the store.
+     * @returns {Promise<DigPeer | null>} - A valid peer or null if none found.
+     */
+    static findPeerWithStoreKey(storeId: string, rootHash: string, key?: 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;
+    static pingNetworkOfUpdate(storeId: string, rootHash: string): Promise<void>;
+    syncStoreFromPeers(prioritizedPeer?: DigPeer, 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;AAKpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;IAChD,OAAO,CAAC,MAAM,CAAC,cAAc,CAAmC;gBAEpD,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQtD,yBAAyB,IAAI,MAAM,EAAE;WAI/B,aAAa,CAAC,GAAG,EAAE,MAAM;IAI7C;;;;;;;OAOG;WACiB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WAsFZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;WAOrC,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAcH,kBAAkB,CAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC;IAqFH,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}