@dignetwork/dig-sdk 0.0.1-alpha.145 → 0.0.1-alpha.148

package/dist/blockchain/FullNodePeer.d.ts

@@ -85,7 +85,8 @@ export declare class FullNodePeer {
      * Connects to the best available peer based on weighted selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
-    private static getBestPeer;
+    private getBestPeer;
+    private createPeerProxy;
     /**
      * Handles peer disconnection by marking it in cooldown and updating internal states.
      * @param {string} peerIP - The IP address of the disconnected peer.

package/dist/blockchain/FullNodePeer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAmCzD;;GAEG;AACH,qBAAa,YAAY;IA0BH,OAAO,CAAC,IAAI;IAxBhC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAGpD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAG3E,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuD;IAGnF,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkC;IAG5D,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAgB;IAG/C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAoC;IAG5D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAoD;IAG9E,OAAO,CAAC,MAAM,CAAC,YAAY,CAAsC;IAGjE,OAAO;IAEP;;;OAGG;WACW,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC;;;;OAIG;WACiB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuB9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IASjC;;;;OAIG;mBACkB,eAAe;IAoFpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAgBpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAwBjC;;;OAGG;mBACkB,UAAU;IAK/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;OAGG;mBACkB,WAAW;IA+EhC;;;OAGG;IACI,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAqBpD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;;OAIG;WACiB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAkDpB"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAmCzD;;GAEG;AACH,qBAAa,YAAY;IA0BH,OAAO,CAAC,IAAI;IAxBhC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAGpD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAG3E,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuD;IAGnF,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkC;IAG5D,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAgB;IAG/C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAoC;IAG5D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAoD;IAG9E,OAAO,CAAC,MAAM,CAAC,YAAY,CAAsC;IAGjE,OAAO;IAEP;;;OAGG;WACW,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC;;;;OAIG;WACiB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuB9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IASjC;;;;OAIG;mBACkB,eAAe;IAoFpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAgBpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAwBjC;;;OAGG;mBACkB,UAAU;IAK/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;OAGG;YACW,WAAW;IAgFzB,OAAO,CAAC,eAAe;IA0DvB;;;OAGG;IACI,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAqBpD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS5B;;;;OAIG;WACiB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAkDpB"}

package/dist/blockchain/FullNodePeer.js

@@ -57,7 +57,7 @@ class FullNodePeer {
         if (this.peer)
             return; // Already initialized
         try {
-            const bestPeer = await FullNodePeer.getBestPeer();
+            const bestPeer = await this.getBestPeer();
             this.peer = bestPeer;
             FullNodePeer.instance = this; // Assign the initialized instance
         }
@@ -266,7 +266,7 @@ class FullNodePeer {
      * Connects to the best available peer based on weighted selection and reliability.
      * @returns {Promise<Peer>} The connected Peer instance.
      */
-    static async getBestPeer() {
+    async getBestPeer() {
         const now = Date.now();
         // Refresh cachedPeer if expired
         if (FullNodePeer.cachedPeer &&
@@ -324,10 +324,57 @@ class FullNodePeer {
         });
         // Initialize rate limiter for this peer
         FullNodePeer.peerLimiters.set(selectedPeerIP, limiter);
+        const proxiedPeer = this.createPeerProxy(peer, selectedPeerIP);
         // Cache the peer
         FullNodePeer.cachedPeer = { peer: peer, timestamp: now };
         console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
-        return peer;
+        return proxiedPeer;
+    }
+    createPeerProxy(peer, peerIP) {
+        return new Proxy(peer, {
+            get: (target, prop) => {
+                const originalMethod = target[prop];
+                if (typeof originalMethod === "function") {
+                    return async (...args) => {
+                        let timeoutId;
+                        // Start the timeout to forget the peer after 1 minute
+                        const timeoutPromise = new Promise((_, reject) => {
+                            timeoutId = setTimeout(() => {
+                                FullNodePeer.cachedPeer = null;
+                                reject(new Error("Operation timed out. Reconnecting to a new peer."));
+                            }, 60000); // 1 minute
+                        });
+                        try {
+                            // Run the original method and race it against the timeout
+                            const result = await Promise.race([
+                                originalMethod.apply(target, args),
+                                timeoutPromise,
+                            ]);
+                            // Clear the timeout if the operation succeeded
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
+                            return result;
+                        }
+                        catch (error) {
+                            // If the error is WebSocket-related or timeout, reset the peer
+                            if (error.message.includes("WebSocket") ||
+                                error.message.includes("Operation timed out")) {
+                                FullNodePeer.cachedPeer = null;
+                                // @ts-ignore
+                                FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
+                                console.info(`Fullnode Peer error, reconnecting to a new peer...`);
+                                this.handlePeerDisconnection(peerIP);
+                                const newPeer = await this.getBestPeer();
+                                return newPeer[prop](...args);
+                            }
+                            throw error;
+                        }
+                    };
+                }
+                return originalMethod;
+            },
+        });
     }
     /**
      * Handles peer disconnection by marking it in cooldown and updating internal states.

package/dist/utils/PeerRanker.d.ts

@@ -1,19 +1,8 @@
-/**
- * Interface representing the metrics of a peer.
- */
 export interface PeerMetrics {
     ip: string;
     latency: number;
     bandwidth: number;
 }
-/**
- * Configuration options for the PeerRanker.
- */
-interface PeerRankerOptions {
-    pingPath?: string;
-    timeout?: number;
-    uploadTestSize?: number;
-}
 /**
  * Utility class to rank peers based on latency and upload bandwidth using HTTPS with mTLS.
  */
@@ -21,7 +10,6 @@ export declare class PeerRanker {
     private ipAddresses;
     private static certPath;
     private static keyPath;
-    private pingPath;
     private timeout;
     private uploadTestSize;
     private sortedPeers;
@@ -29,27 +17,28 @@ export declare 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: 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 upload bandwidth of a given IP address by sending random data.
      * @param ip - The IP address of the peer.
-     * @returns Promise resolving to the upload 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 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.
@@ -61,5 +50,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,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;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,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAS;IAG/B,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAa;IAEjC;;;;OAIG;gBACS,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,iBAAiB;IAW7D;;;;;OAKG;YACW,cAAc;IA8C5B;;;;OAIG;YACW,gBAAgB;IAwC9B;;;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,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,6 +8,7 @@ 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 upload bandwidth using HTTPS with mTLS.
  */
@@ -16,16 +16,15 @@ 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.pingPath = options.pingPath || '/'; // Default to root path if not provided
-        this.timeout = options.timeout || 5000; // Default timeout: 5 seconds
-        this.uploadTestSize = options.uploadTestSize || 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;
@@ -34,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,
                 };
@@ -77,18 +73,17 @@ 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 upload bandwidth of a given IP address by sending random data.
      * @param ip - The IP address of the peer.
-     * @returns Promise resolving to the upload 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}/upload`; // Assume /upload as the endpoint for upload testing
-        // Generate random data
-        const randomData = Buffer.alloc(this.uploadTestSize, 'a'); // 1MB of 'a's
+        const url = `https://${ip}:4159/diagnostics/bandwidth`;
+        const randomData = Buffer.alloc(this.uploadTestSize, 'a');
         const config = {
             url: url,
             method: 'POST',
@@ -100,39 +95,47 @@ class PeerRanker {
             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();
-            (0, axios_1.default)(config)
-                .then(() => {
-                const timeElapsed = (Date.now() - startTime) / 1000; // seconds
-                const bandwidth = this.uploadTestSize / timeElapsed; // bytes per second
-                resolve(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 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) {
@@ -140,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.145",
+  "version": "0.0.1-alpha.148",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",