@dignetwork/dig-sdk 0.0.1-alpha.144 → 0.0.1-alpha.147

package/dist/utils/PeerRanker.d.ts

@@ -7,53 +7,41 @@ export interface PeerMetrics {
     bandwidth: number;
 }
 /**
- * Configuration options for the PeerRanker.
- */
-interface PeerRankerOptions {
-    clientCertPath: string;
-    clientKeyPath: string;
-    bandwidthTestPath: string;
-    pingPath?: string;
-    timeout?: number;
-    bandwidthTestSize?: number;
-}
-/**
- * Utility class to rank peers based on latency and bandwidth using HTTPS with mTLS.
+ * Utility class to rank peers based on latency and upload bandwidth using HTTPS with mTLS.
  */
 export declare class PeerRanker {
     private ipAddresses;
     private static certPath;
     private static keyPath;
-    private bandwidthTestPath;
-    private pingPath;
     private timeout;
-    private bandwidthTestSize;
+    private uploadTestSize;
     private sortedPeers;
     private currentIndex;
     /**
      * Constructs a PeerRanker instance.
      * @param ipAddresses - Array of IP addresses to rank.
-     * @param options - Configuration options including paths to client certificates.
      */
-    constructor(ipAddresses: string[], options: PeerRankerOptions);
+    constructor(ipAddresses: string[], timeout?: number, uploadTestSize?: number);
     /**
      * Measures the latency of a given IP address using an HTTPS request.
      * Tries HEAD first, then falls back to GET if HEAD is not supported.
      * @param ip - The IP address of the peer.
-     * @returns Promise resolving to the latency in milliseconds.
+     * @returns Promise resolving to the latency in milliseconds or rejecting if the peer fails.
      */
     private measureLatency;
     /**
-     * Measures the bandwidth of a given IP address by downloading a file and calculating throughput.
+     * Measures the upload bandwidth of a given IP address by sending random data.
      * @param ip - The IP address of the peer.
-     * @returns Promise resolving to the bandwidth in bytes per second.
+     * @returns Promise resolving to the upload bandwidth in bytes per second or rejecting if the peer fails.
      */
     private measureBandwidth;
     /**
-     * Ranks the peers based on measured latency and bandwidth.
+     * Ranks the peers based on measured latency and upload bandwidth.
+     * Unresponsive peers are excluded from the final ranking.
+     * @param cooldown - Cooldown time in milliseconds between batches.
      * @returns Promise resolving to an array of PeerMetrics sorted by latency and bandwidth.
      */
-    rankPeers(): Promise<PeerMetrics[]>;
+    rankPeers(cooldown?: number): Promise<PeerMetrics[]>;
     /**
      * Returns the next best peer based on the ranking.
      * Cycles through the list, resetting to the beginning once the end is reached.
@@ -65,5 +53,4 @@ export declare class PeerRanker {
      */
     resetIterator(): void;
 }
-export {};
 //# sourceMappingURL=PeerRanker.d.ts.map

package/dist/utils/PeerRanker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PeerRanker.d.ts","sourceRoot":"","sources":["../../src/utils/PeerRanker.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,UAAU,iBAAiB;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,iBAAiB,CAAS;IAGlC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAa;IAEjC;;;;OAIG;gBACS,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,iBAAiB;IAY7D;;;;;OAKG;YACW,cAAc;IA8C5B;;;;OAIG;YACW,gBAAgB;IA2C9B;;;OAGG;IACU,SAAS,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IA4BhD;;;;OAIG;IACI,eAAe,IAAI,WAAW,GAAG,IAAI;IAW5C;;OAEG;IACI,aAAa,IAAI,IAAI;CAG7B"}
+{"version":3,"file":"PeerRanker.d.ts","sourceRoot":"","sources":["../../src/utils/PeerRanker.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAS;IAG/B,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAa;IAEjC;;;OAGG;gBACS,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAa,EAAE,cAAc,GAAE,MAAoB;IAW/F;;;;;OAKG;YACW,cAAc;IA2C5B;;;;OAIG;YACW,gBAAgB;IAmC9B;;;;;OAKG;IACU,SAAS,CAAC,QAAQ,GAAE,MAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAmCtE;;;;OAIG;IACI,eAAe,IAAI,WAAW,GAAG,IAAI;IAW5C;;OAEG;IACI,aAAa,IAAI,IAAI;CAG7B"}

package/dist/utils/PeerRanker.js

@@ -1,5 +1,4 @@
 "use strict";
-// src/PeerRanker.ts
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,24 +8,23 @@ const axios_1 = __importDefault(require("axios"));
 const fs_1 = __importDefault(require("fs"));
 const https_1 = __importDefault(require("https"));
 const ssl_1 = require("./ssl");
+const promiseUtils_1 = require("./promiseUtils");
 /**
- * Utility class to rank peers based on latency and bandwidth using HTTPS with mTLS.
+ * Utility class to rank peers based on latency and upload bandwidth using HTTPS with mTLS.
  */
 class PeerRanker {
     /**
      * Constructs a PeerRanker instance.
      * @param ipAddresses - Array of IP addresses to rank.
-     * @param options - Configuration options including paths to client certificates.
      */
-    constructor(ipAddresses, options) {
+    constructor(ipAddresses, timeout = 5000, uploadTestSize = 1024 * 1024) {
         // Internal properties for iteration
         this.sortedPeers = [];
         this.currentIndex = 0;
         this.ipAddresses = ipAddresses;
-        this.bandwidthTestPath = options.bandwidthTestPath;
-        this.pingPath = options.pingPath || '/'; // Default to root path if not provided
-        this.timeout = options.timeout || 5000; // Default timeout: 5 seconds
-        this.bandwidthTestSize = options.bandwidthTestSize || 1024 * 1024; // Default: 1MB
+        this.timeout = timeout; // Allow customizable timeout
+        this.uploadTestSize = uploadTestSize; // Default upload size: 1MB
+        // Fetch the SSL certificates used for mTLS.
         const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
         PeerRanker.certPath = certPath;
         PeerRanker.keyPath = keyPath;
@@ -35,39 +33,36 @@ class PeerRanker {
      * Measures the latency of a given IP address using an HTTPS request.
      * Tries HEAD first, then falls back to GET if HEAD is not supported.
      * @param ip - The IP address of the peer.
-     * @returns Promise resolving to the latency in milliseconds.
+     * @returns Promise resolving to the latency in milliseconds or rejecting if the peer fails.
      */
     async measureLatency(ip) {
-        const path = this.pingPath;
-        const url = `https://${ip}${path}`;
-        // Configuration for HEAD request
+        const url = `https://${ip}:4159/diagnostics/ping`;
         const configHead = {
             url: url,
             method: 'HEAD',
             httpsAgent: new https_1.default.Agent({
                 cert: fs_1.default.readFileSync(PeerRanker.certPath),
                 key: fs_1.default.readFileSync(PeerRanker.keyPath),
-                rejectUnauthorized: false, // Set to true in production
+                rejectUnauthorized: false,
             }),
             timeout: this.timeout,
-            validateStatus: (status) => status < 500, // Resolve only if status is less than 500
+            validateStatus: (status) => status < 500,
         };
         const startTime = Date.now();
         try {
             const response = await (0, axios_1.default)(configHead);
-            if (response.status === 405) { // Method Not Allowed
-                // Fallback to GET with Range header to minimize data transfer
+            if (response.status === 405) {
                 const configGet = {
                     url: url,
                     method: 'GET',
                     httpsAgent: new https_1.default.Agent({
                         cert: fs_1.default.readFileSync(PeerRanker.certPath),
                         key: fs_1.default.readFileSync(PeerRanker.keyPath),
-                        rejectUnauthorized: false, // Set to true in production
+                        rejectUnauthorized: false,
                     }),
                     timeout: this.timeout,
                     headers: {
-                        'Range': 'bytes=0-0', // Request only the first byte
+                        'Range': 'bytes=0-0',
                     },
                     validateStatus: (status) => status < 500,
                 };
@@ -78,64 +73,69 @@ class PeerRanker {
         }
         catch (error) {
             console.error(`Latency measurement failed for IP ${ip}:`, error.message);
-            return Infinity; // Indicate unreachable or unresponsive peer
+            throw new Error(`Latency measurement failed for IP ${ip}`);
         }
     }
     /**
-     * Measures the bandwidth of a given IP address by downloading a file and calculating throughput.
+     * Measures the upload bandwidth of a given IP address by sending random data.
      * @param ip - The IP address of the peer.
-     * @returns Promise resolving to the bandwidth in bytes per second.
+     * @returns Promise resolving to the upload bandwidth in bytes per second or rejecting if the peer fails.
      */
     async measureBandwidth(ip) {
-        const url = `https://${ip}${this.bandwidthTestPath}`;
+        const url = `https://${ip}:4159/diagnostics/bandwidth`;
+        const randomData = Buffer.alloc(this.uploadTestSize, 'a');
         const config = {
             url: url,
-            method: 'GET',
-            responseType: 'stream',
+            method: 'POST',
+            data: randomData,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': this.uploadTestSize,
+            },
             httpsAgent: new https_1.default.Agent({
                 cert: fs_1.default.readFileSync(PeerRanker.certPath),
                 key: fs_1.default.readFileSync(PeerRanker.keyPath),
-                rejectUnauthorized: false, // Set to true in production
+                rejectUnauthorized: false,
             }),
             timeout: this.timeout,
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity,
         };
-        return new Promise((resolve) => {
-            const startTime = Date.now();
-            let bytesReceived = 0;
-            (0, axios_1.default)(config)
-                .then((response) => {
-                response.data.on('data', (chunk) => {
-                    bytesReceived += chunk.length;
-                });
-                response.data.on('end', () => {
-                    const timeElapsed = (Date.now() - startTime) / 1000; // seconds
-                    const bandwidth = bytesReceived / timeElapsed; // bytes per second
-                    resolve(bandwidth);
-                });
-                response.data.on('error', (err) => {
-                    console.error(`Bandwidth measurement error for IP ${ip}:`, err.message);
-                    resolve(0); // Indicate failure in measuring bandwidth
-                });
-            })
-                .catch((error) => {
-                console.error(`Bandwidth measurement failed for IP ${ip}:`, error.message);
-                resolve(0); // Indicate failure in measuring bandwidth
-            });
-        });
+        const startTime = Date.now();
+        try {
+            await (0, axios_1.default)(config);
+            const timeElapsed = (Date.now() - startTime) / 1000;
+            const bandwidth = this.uploadTestSize / timeElapsed;
+            return bandwidth;
+        }
+        catch (error) {
+            console.error(`Bandwidth measurement failed for IP ${ip}:`, error.message);
+            throw new Error(`Bandwidth measurement failed for IP ${ip}`);
+        }
     }
     /**
-     * Ranks the peers based on measured latency and bandwidth.
+     * Ranks the peers based on measured latency and upload bandwidth.
+     * Unresponsive peers are excluded from the final ranking.
+     * @param cooldown - Cooldown time in milliseconds between batches.
      * @returns Promise resolving to an array of PeerMetrics sorted by latency and bandwidth.
      */
-    async rankPeers() {
-        const metricsPromises = this.ipAddresses.map(async (ip) => {
-            const [latency, bandwidth] = await Promise.all([
-                this.measureLatency(ip),
-                this.measureBandwidth(ip),
-            ]);
-            return { ip, latency, bandwidth };
-        });
-        const peerMetrics = await Promise.all(metricsPromises);
+    async rankPeers(cooldown = 500) {
+        const limit = 5; // Limit to 5 parallel requests at a time
+        const iteratorFn = async (ip) => {
+            try {
+                const [latency, bandwidth] = await Promise.all([
+                    this.measureLatency(ip),
+                    this.measureBandwidth(ip),
+                ]);
+                return { ip, latency, bandwidth };
+            }
+            catch (error) {
+                // Peer failed, skip it by returning null
+                return null;
+            }
+        };
+        // Process all peers with a concurrency limit and cooldown between batches
+        const peerMetrics = (await (0, promiseUtils_1.asyncPool)(limit, this.ipAddresses, iteratorFn, cooldown)).filter((metrics) => metrics !== null); // Use a type guard
         // Sort by lowest latency first, then by highest bandwidth
         peerMetrics.sort((a, b) => {
             if (a.latency === b.latency) {
@@ -143,9 +143,7 @@ class PeerRanker {
             }
             return a.latency - b.latency; // Lower latency is better
         });
-        // Update the internal sorted list
         this.sortedPeers = peerMetrics;
-        // Reset the iterator index
         this.currentIndex = 0;
         return peerMetrics;
     }

package/dist/utils/promiseUtils.d.ts

@@ -1,11 +1,13 @@
 /**
  * Processes items in sequential batches with a concurrency limit.
+ * Adds a cooldown between batches.
  * @param {number} limit - The maximum number of concurrent executions per batch.
  * @param {Array<T>} items - The array of items to process.
  * @param {(item: T) => Promise<R>} iteratorFn - The async function to apply to each item.
+ * @param {number} cooldownMs - The cooldown duration between batches in milliseconds.
  * @returns {Promise<Array<R>>} - A promise that resolves when all items have been processed.
  */
-export declare function asyncPool<T, R>(limit: number, items: T[], iteratorFn: (item: T) => Promise<R>): Promise<R[]>;
+export declare function asyncPool<T, R>(limit: number, items: T[], iteratorFn: (item: T) => Promise<R>, cooldownMs?: number): Promise<R[]>;
 /**
 * Helper function to add a timeout to a promise.
 * @param promise The original promise.

package/dist/utils/promiseUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"promiseUtils.d.ts","sourceRoot":"","sources":["../../src/utils/promiseUtils.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,CAAC,EAChC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,EAAE,EACV,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,CAAC,EAAE,CAAC,CAgBd;AAED;;;;;;EAMC;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,WAClB,OAAO,CAAC,CAAC,CAAC,MACf,MAAM,kBACM,MAAM,KACrB,OAAO,CAAC,CAAC,CAOX,CAAC"}
+{"version":3,"file":"promiseUtils.d.ts","sourceRoot":"","sources":["../../src/utils/promiseUtils.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,EAAE,EACV,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EACnC,UAAU,GAAE,MAAY,GACvB,OAAO,CAAC,CAAC,EAAE,CAAC,CAkBd;AACC;;;;;;EAMC;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,WAClB,OAAO,CAAC,CAAC,CAAC,MACf,MAAM,kBACM,MAAM,KACrB,OAAO,CAAC,CAAC,CAOX,CAAC"}

package/dist/utils/promiseUtils.js

@@ -4,12 +4,15 @@ exports.withTimeout = void 0;
 exports.asyncPool = asyncPool;
 /**
  * Processes items in sequential batches with a concurrency limit.
+ * Adds a cooldown between batches.
  * @param {number} limit - The maximum number of concurrent executions per batch.
  * @param {Array<T>} items - The array of items to process.
  * @param {(item: T) => Promise<R>} iteratorFn - The async function to apply to each item.
+ * @param {number} cooldownMs - The cooldown duration between batches in milliseconds.
  * @returns {Promise<Array<R>>} - A promise that resolves when all items have been processed.
  */
-async function asyncPool(limit, items, iteratorFn) {
+async function asyncPool(limit, items, iteratorFn, cooldownMs = 500 // Default cooldown of 500ms
+) {
     const ret = [];
     for (let i = 0; i < items.length; i += limit) {
         const batchItems = items.slice(i, i + limit);
@@ -17,8 +20,10 @@ async function asyncPool(limit, items, iteratorFn) {
         // Wait for the current batch to complete before starting the next one
         const batchResults = await Promise.all(batchPromises);
         ret.push(...batchResults);
-        // Optional: add a cooldown between batches
-        // await new Promise((resolve) => setTimeout(resolve, 500));
+        // Add a cooldown between batches, except after the last batch
+        if (i + limit < items.length) {
+            await new Promise((resolve) => setTimeout(resolve, cooldownMs));
+        }
     }
     return ret;
 }

package/package.json

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