dequanto 0.2.38 → 0.2.41

package/src/blocks/BlockDateResolver.ts

@@ -102,7 +102,7 @@ export class BlockDateResolver {
     }
 
     /**
-     * Returns index of the first known block, which is most near to specified block (it can be before or after the specified date).
+     * Returns the index of the known block nearest to the specified date. It can be before or after the specified date
      */
     private getClosest (date: Date) {
         let entry = alot(this._known).map(x => [
@@ -120,7 +120,7 @@ export class BlockDateResolver {
         }
         let blockNumber = anchor.blockNumber + diffCount;
         if (blockNumber < 0) {
-            throw new Error(`Date Out of range: ${ this._requestedDate.toISOString() }. Based on the AVG block time, the blockchain was not active on that date`);
+            throw new Error(`Date out of range: ${ this._requestedDate.toISOString() }. Based on the average block time, the blockchain was not active on that date`);
         }
         let date = await this.getBlockDate(blockNumber);
         let info = {
@@ -132,7 +132,7 @@ export class BlockDateResolver {
         return info;
     }
 
-    /** Add a know block to set */
+    /** Adds a known block to the set */
     private push(info: IKnownBlock) {
         for (let i = 0; i < this._known.length; i++) {
             let x = this._known[i];
@@ -143,29 +143,29 @@ export class BlockDateResolver {
         }
         this._known.push(info);
     }
-    /** Loads the block and gets the Date of the block */
+    /** Loads the block and returns its date */
     private async getBlockDate (blockNumber: number) {
         let block = await this.getBlock(blockNumber);
         if (block == null) {
-            throw new Error(`Block not loaded: ${blockNumber}`);
+            throw new Error(`Block was not loaded: ${blockNumber}`);
         }
         let date = $block.getDate(block);
         return date;
     }
-    /** Returns SIGNED time in milliseconds between two dates. Negative values when t2 < t1 */
+    /** Returns the signed time in milliseconds between two dates. Values are negative when t2 < t1 */
     private diffTime (t1: Date, t2: Date) {
         return (t2.getTime() - t1.getTime());
     }
-    /** Returns ABSOLUTE time in milliseconds between two dates.  */
+    /** Returns the absolute time in milliseconds between two dates */
     private diffTimeAbs (t1: Date, t2: Date) {
         return Math.abs(this.diffTime(t1, t2));
     }
-    /** Returns AVG block count between two dates */
+    /** Returns the average block count between two dates */
     private getAvgBlockCountBetween (b1: IKnownBlock, b2: IKnownBlock) {
         let diff = this.diffTimeAbs(b1.date, b2.date);
         return Math.round(diff / Math.abs(b2.blockNumber - b1.blockNumber));
     }
-    /** With N>1 blocks we can better find out the AVG block time */
+    /** With N > 1 blocks, we can better estimate the average block time */
     private refineAvg () {
         for (let i = 1; i < this._known.length; i++) {
             let info = this._known[i];

package/src/bridges/hop/HopBridge.ts

@@ -140,7 +140,7 @@ export class HopBridge implements IBridge {
         const url = await chainFrom.client.getNodeURL({ ws: false });
         const provider = new providers.JsonRpcProvider(url, Utils.getChainId(fromPlatform));
 
-        // WORKAROUND: make hop sdk to use our RPC.
+        // WORKAROUND: make the Hop SDK use our RPC
         networks[fromPlatform].publicRpcUrl = url;
 
         const signer = new Wallet(account.key, provider);

package/src/class/PackedRanges.ts

@@ -3,7 +3,7 @@ import alot from 'alot';
 /**
  * Defines a RANGE: [FROM_NUMBER, TO_NUMBER | Infinity)
  *
- * - Walking/Iterating/Visiting through the range marks the visited number as ADD.
+ * - Walking/Iterating/Visiting through the range marks the visited number as ADD
  *
  * - Possible to ADD the number manually, for example for persistence/restore properties
  *
@@ -49,8 +49,8 @@ export class PackedRanges {
     }
 
     /**
-     * Calculates the number of elements remaining to be visited/added in the range.
-     * This is the difference between the total capacity and the number of elements already tracked.
+     * Calculates the number of elements remaining to be visited/added in the range
+     * This is the difference between the total capacity and the number of elements already tracked
      */
     totalLeft() {
         return this.total() - this.totalAdded();
@@ -58,11 +58,11 @@ export class PackedRanges {
 
 
     /**
-     * Gets the next unvisited number in the range and marks it as visited.
+     * Gets the next unvisited number in the range and marks it as visited
      *
      * This method finds the next number that hasn't been added to the tracked ranges yet,
      * automatically adds it to the ranges, and returns it. It respects the boundaries
-     * defined by `from` and `to` properties.
+     * defined by `from` and `to` properties
      *
      * The method works by:
      * - Starting from `this.from` if no ranges exist
@@ -112,10 +112,10 @@ export class PackedRanges {
     }
 
     /**
-     * Gets the maximum (upper bound) value from all tracked ranges.
+     * Gets the maximum (upper bound) value from all tracked ranges
      *
-     * This method returns the highest number that has been visited/added to the ranges.
-     * It retrieves the upper bound of the last range in the sorted ranges array.
+     * This method returns the highest number that has been visited/added to the ranges
+     * It retrieves the upper bound of the last range in the sorted ranges array
      *
      * @returns The maximum value in the tracked ranges, or `null` if no ranges have been added yet
      */
@@ -128,11 +128,11 @@ export class PackedRanges {
     }
 
     /**
-     * Checks if a specific number has been visited/added to the tracked ranges.
+     * Checks if a specific number has been visited/added to the tracked ranges
      *
      * This method searches through all tracked ranges to determine if the given number
      * falls within any of them. It performs a linear search through the ranges array,
-     * checking if the number is within the bounds (inclusive) of any range.
+     * checking if the number is within the bounds (inclusive) of any range
      *
      * @param nr - The number to check for inclusion in the tracked ranges
      * @returns `true` if the number exists within any of the tracked ranges, `false` otherwise
@@ -148,7 +148,7 @@ export class PackedRanges {
     }
 
     /**
-     * Adds a number to the tracked ranges, marking it as visited.
+     * Adds a number to the tracked ranges, marking it as visited
      *
      * This method intelligently adds a number to the ranges by either:
      * - Extending an existing range if the number is adjacent to it
@@ -156,7 +156,7 @@ export class PackedRanges {
      * - Doing nothing if the number is already included in an existing range
      *
      * The method maintains the sorted order of ranges and automatically merges
-     * adjacent numbers into contiguous ranges for efficient storage.
+     * adjacent numbers into contiguous ranges for efficient storage
      *
      * @param nr - The number to add to the tracked ranges
      * @returns `true` if the number was successfully added (new or extended a range),
@@ -200,16 +200,16 @@ export class PackedRanges {
     }
 
     /**
-     * Adds a complete range to the tracked ranges and compacts the result.
+     * Adds a complete range to the tracked ranges and compacts the result
      *
      * This method adds an entire range [min, max] to the tracked ranges array,
      * then automatically compacts the ranges to merge any overlapping or adjacent
      * ranges. This is useful for bulk operations where you want to mark multiple
-     * consecutive numbers as visited at once.
+     * consecutive numbers as visited at once
      *
      * Unlike the `add()` method which adds individual numbers, this method adds
      * a complete range tuple and ensures the internal ranges array remains optimized
-     * by calling `compact()` after insertion.
+     * by calling `compact()` after insertion
      *
      * @param range - A tuple [min, max] representing the range to add, where both bounds are inclusive
      */
@@ -219,7 +219,7 @@ export class PackedRanges {
     }
 
     /**
-     * Removes a specific number from the tracked ranges, marking it as unvisited.
+     * Removes a specific number from the tracked ranges, marking it as unvisited
      *
      * This method searches for the number within the tracked ranges and removes it by either:
      * - Removing the entire range if it contains only the target number
@@ -228,7 +228,7 @@ export class PackedRanges {
      * - Splitting the range into two separate ranges if the number is in the middle
      *
      * The method maintains the sorted order of ranges and ensures efficient storage
-     * by handling all edge cases appropriately.
+     * by handling all edge cases appropriately
      *
      * @param nr - The number to remove from the tracked ranges
      * @returns `true` if the number was found and successfully removed from the ranges,
@@ -262,14 +262,14 @@ export class PackedRanges {
     }
 
     /**
-     * Removes a range of numbers from the tracked ranges, marking them as unvisited.
+     * Removes a range of numbers from the tracked ranges, marking them as unvisited
      *
      * This method subtracts the specified range from all tracked ranges, effectively
      * removing all numbers within the given range from the visited/added set. It handles
-     * overlapping ranges by splitting or trimming existing ranges as needed.
+     * overlapping ranges by splitting or trimming existing ranges as needed
      *
      * The method maintains the sorted order of ranges and ensures efficient storage
-     * by delegating to the `Ranges.subtract()` utility function.
+     * by delegating to the `Ranges.subtract()` utility function
      *
      * @param range - A tuple [min, max] representing the range to remove, where both bounds are inclusive
      * @returns The current `PackedRanges` instance for method chaining
@@ -280,15 +280,15 @@ export class PackedRanges {
     }
 
     /**
-     * Removes multiple ranges of numbers from the tracked ranges, marking them as unvisited.
+     * Removes multiple ranges of numbers from the tracked ranges, marking them as unvisited
      *
      * This method subtracts all specified ranges from the tracked ranges, effectively
      * removing all numbers within the given ranges from the visited/added set. It handles
      * overlapping ranges by splitting or trimming existing ranges as needed for each
-     * range in the input array.
+     * range in the input array
      *
      * The method maintains the sorted order of ranges and ensures efficient storage
-     * by delegating to the `Ranges.subtractMany()` utility function.
+     * by delegating to the `Ranges.subtractMany()` utility function
      *
      * @param ranges - An array of tuples [min, max] representing the ranges to remove, where both bounds are inclusive
      * @returns The current `PackedRanges` instance for method chaining
@@ -299,7 +299,7 @@ export class PackedRanges {
     }
 
     /**
-     * Compacts the tracked ranges by merging overlapping and adjacent ranges.
+     * Compacts the tracked ranges by merging overlapping and adjacent ranges
      *
      * This method optimizes the internal ranges array by:
      * - Merging overlapping ranges into single contiguous ranges
@@ -308,21 +308,21 @@ export class PackedRanges {
      * - Removing redundant range entries
      *
      * This operation is useful after bulk modifications to ensure the ranges
-     * array remains in its most efficient form for storage and querying.
+     * array remains in its most efficient form for storage and querying
      */
     compact() {
         this.ranges = Ranges.compact(this.ranges);
     }
 
     /**
-     * Sets the tracked ranges to a new array of ranges and compacts them.
+     * Sets the tracked ranges to a new array of ranges and compacts them
      *
      * This method replaces the entire internal ranges array with the provided ranges,
-     * then automatically compacts them to merge any overlapping or adjacent ranges.
-     * This is useful for bulk initialization or restoration of ranges from a saved state.
+     * then automatically compacts them to merge any overlapping or adjacent ranges
+     * This is useful for bulk initialization or restoration of ranges from a saved state
      *
      * After setting the ranges, the method ensures the internal ranges array is optimized
-     * by calling `compact()`, which merges overlapping ranges and joins adjacent ones.
+     * by calling `compact()`, which merges overlapping ranges and joins adjacent ones
      *
      * @param ranges - An array of tuples [min, max] representing the ranges to set, where both bounds are inclusive
      */
@@ -332,12 +332,12 @@ export class PackedRanges {
     }
 
     /**
-     * Serializes the tracked ranges to a JSON string representation.
+     * Serializes the tracked ranges to a JSON string representation
      *
      * This method converts the internal ranges array into a JSON string format,
-     * which can be used for persistence, transmission, or storage purposes.
+     * which can be used for persistence, transmission, or storage purposes
      * The serialized string can later be parsed and used to restore the ranges
-     * via the constructor's `ranges` option.
+     * via the constructor's `ranges` option
      *
      * @returns A JSON string representation of the tracked ranges array
      */
@@ -346,14 +346,14 @@ export class PackedRanges {
     }
 
     /**
-     * Creates a new PackedRanges instance containing only the ranges starting from a specified number.
+     * Creates a new PackedRanges instance containing only the ranges starting from a specified number
      *
      * This method filters the tracked ranges to include only those that contain or come after
      * the specified `from` value. If a range overlaps with the `from` value, it is trimmed
-     * to start at `from`. All ranges before `from` are excluded from the result.
+     * to start at `from`. All ranges before `from` are excluded from the result
      *
      * The original PackedRanges instance remains unchanged; a new instance is returned with
-     * the filtered ranges.
+     * the filtered ranges
      *
      * @param from - The starting number from which to pick ranges (inclusive)
      * @returns A new PackedRanges instance containing only the ranges from the specified number onwards
@@ -364,14 +364,14 @@ export class PackedRanges {
     }
 
     /**
-     * Creates a new PackedRanges instance containing only the ranges up to a specified number.
+     * Creates a new PackedRanges instance containing only the ranges up to a specified number
      *
      * This method filters the tracked ranges to include only those that contain or come before
      * the specified `to` value. If a range overlaps with the `to` value, it is trimmed
-     * to end at `to`. All ranges after `to` are excluded from the result.
+     * to end at `to`. All ranges after `to` are excluded from the result
      *
      * The original PackedRanges instance remains unchanged; a new instance is returned with
-     * the filtered ranges.
+     * the filtered ranges
      *
      * @param to - The ending number up to which to pick ranges (inclusive)
      * @returns A new PackedRanges instance containing only the ranges up to the specified number
@@ -383,11 +383,11 @@ export class PackedRanges {
 
 
     /**
-     * Computes the intersection of multiple range arrays, returning only the ranges that are common to all inputs.
+     * Computes the intersection of multiple range arrays, returning only the ranges that are common to all inputs
      *
      * This method performs a set intersection operation across multiple arrays of ranges,
      * finding only those number ranges that appear in every input array. The result is
-     * compacted to merge any overlapping or adjacent ranges for efficient storage.
+     * compacted to merge any overlapping or adjacent ranges for efficient storage
      *
      * For example:
      * - Input: [[[1,5], [10,15]], [[3,7], [12,20]]]
@@ -408,11 +408,11 @@ export class PackedRanges {
     }
 
     /**
-     * Computes the union of multiple range arrays, returning all ranges that appear in any of the inputs.
+     * Computes the union of multiple range arrays, returning all ranges that appear in any of the inputs
      *
      * This method performs a set union operation across multiple arrays of ranges,
      * combining all number ranges from every input array. The result is compacted to
-     * merge any overlapping or adjacent ranges for efficient storage.
+     * merge any overlapping or adjacent ranges for efficient storage
      *
      * For example:
      * - Input: [[[1,5], [10,15]], [[3,7], [12,20]]]
@@ -429,12 +429,12 @@ export class PackedRanges {
     }
 
     /**
-     * Computes the difference between two range arrays, removing all ranges in B from ranges in A.
+     * Computes the difference between two range arrays, removing all ranges in B from ranges in A
      *
      * This method performs a set difference operation (A − B), subtracting all number ranges
      * in `rangesB` from `rangesA`. The result contains only those portions of `rangesA` that
      * do not overlap with any range in `rangesB`. The result is compacted to merge any
-     * overlapping or adjacent ranges for efficient storage.
+     * overlapping or adjacent ranges for efficient storage
      *
      * For example:
      * - Input: rangesA = [[1,10], [20,30]], rangesB = [[5,15], [25,35]]
@@ -533,7 +533,7 @@ namespace Ranges {
             .sortBy(([x]) => x)
             .toArray();
 
-        // Join non overlapping ranges: [1,4],[5, 6] -> [1,6]
+        // Join non-overlapping ranges: [1,4],[5, 6] -> [1,6]
         for (let i = 0; i < ranges.length - 1; i++) {
             let A = ranges[i];
             let B = ranges[i + 1];
@@ -624,7 +624,7 @@ namespace Ranges {
                 // No overlapping, pick full range
                 arr.push([aFirst, aLast]);
             } else {
-                // Overlapps
+                // Overlaps
                 arr.push([aFirst, to]);
             }
         }

package/src/clients/ClientEventsStream.ts

@@ -75,7 +75,7 @@ export class ClientEventsStream<T extends TClientEventsStreamData<unknown[]> = a
         let eventTopic = event.topics[0];
         let abi = eventsAbi.find(x => $abiUtils.getMethodHash(x) === eventTopic);
         if (abi == null) {
-            stream.error(new Error(`ABI for the topic ${eventTopic} not found. Supports: ${ eventsAbi.map(x => x.name).join(', ') }`));
+            stream.error(new Error(`ABI for topic ${eventTopic} was not found. Supported events: ${ eventsAbi.map(x => x.name).join(', ') }`));
             return;
         }
 

package/src/clients/ClientPool.ts

@@ -32,7 +32,7 @@ export interface IRpcConfig {
     url?: string
     options?: TTransport.Options.Http | TTransport.Options.Ws
 
-    /** Will be a preferred node for submitting transactions */
+    /** Preferred node for submitting transactions */
     safe?: boolean
     distinct?: boolean
     wallet?: boolean
@@ -40,25 +40,25 @@ export interface IRpcConfig {
     web3?: TTransport.Transport | Promise<TTransport.Transport>
 
     name?: string
-    /** Will be used only if manually requested with .getWeb3, or .getNodeUrl */
+    /** Used only when manually requested with .getWeb3 or .getNodeUrl */
     manual?: boolean
 
-    /** max block range per request when getting for example the past logs*/
+    /** Max block range per request, for example when fetching past logs */
     fetchableBlockRange?: number
 
     /** True if the node supports traceTransaction calls */
     traceable?: boolean
 
-    // requestCount/timeSpan: e.g. 100/1min
+    // requestCount/timeSpan, e.g. 100/1min
     rateLimit?: string
 
-    // the max block range to fetch per single request when getting Logs
+    // Max block range to fetch per single request when getting logs
     blockRangeLimit?: string | number
 
-    // maximum of requests to be batched, otherwise batches will be paginated
+    // Maximum number of requests to batch; otherwise, batches will be paginated
     batchLimit?: number
 
-    // Will be used only for the specified methods
+    // Used only for the specified methods
     methods?: {
         exclude?: string[]
         only?: string[]
@@ -68,7 +68,7 @@ export interface IPoolWeb3Request {
     ws?: boolean
     preferSafe?: boolean
 
-    /** Request wallet node to submit unsigned transactions */
+    /** Request a wallet node to submit unsigned transactions */
     wallet?: boolean
     distinct?: boolean
     name?: string
@@ -78,20 +78,20 @@ export interface IPoolWeb3Request {
 
     /** Supported node features */
     node?: {
-        // For specific url
+        // For a specific URL
         url?: string
 
         /** Supports traceTransaction */
         traceable?: boolean
     }
 
-    /** RPC method - will find the node that has the configuration */
+    /** RPC method; finds the node that has the configuration */
     method?: string
 
-    // Amount of batch requests to be performed, sothat we can choose the appropriate wClient and handle the rate limits correctly
+    // Number of batch requests to perform, so we can choose the appropriate wClient and handle rate limits correctly
     batchRequestCount?: number
 
-    // By fetching logs, specifies the desired block range to query
+    // When fetching logs, specifies the desired block range to query
     blockRangeCount?: number
 }
 
@@ -113,7 +113,7 @@ export class ClientPool {
             this.clients = [new WClient({ web3: config.web3 ?? config.provider })];
         } else {
             console.dir(config, { depth: null });
-            throw new Error(`Neither Node endpoints nor Web3 instance`)
+            throw new Error(`Neither node endpoints nor a Web3 instance were provided`)
         }
         if (this.clients.length < 2) {
             this.discoveredPartial = true;
@@ -145,7 +145,7 @@ export class ClientPool {
             ...(opts ?? {}),
 
             /**
-             * web3@1.6.0 has a bug with batch request via websockets, as the callback can stuck if a single response contains multiple IDs, as only the first one will be taken
+             * web3@1.6.0 has a bug with batch requests via WebSockets, as the callback can get stuck if a single response contains multiple IDs because only the first one is taken
              * https://github.com/web3/web3.js/blob/9238e106294784b4a6a20af020765973f0437022/packages/web3-providers-ws/src/index.js#L128
             */
             ws: false
@@ -167,7 +167,7 @@ export class ClientPool {
                         .map(x => `    ${x.config.url}`)
                         .join('\n');
 
-                    error = new Error(`Live clients not found in \n${urls}`);
+                    error = new Error(`Live clients were not found in \n${urls}`);
                 }
                 throw ClientPoolTraceError.create(error, opts?.trace, ErrorCode.NO_LIVE_CLIENT);
             }
@@ -184,10 +184,10 @@ export class ClientPool {
 
 
             if (wClientUsage == null) {
-                // per default NO_RETRIES
+                // By default, NO_RETRIES
                 used.set(wClient, 0);
             } else {
-                // decrease retry count
+                // Decrease the retry count
                 used.set(wClient, wClientUsage - 1);
             }
 
@@ -208,7 +208,7 @@ export class ClientPool {
                 return result;
             }
 
-            // if not the CallError, process the while loop to check another NodeProvider
+            // If this is not a CallError, continue the loop to check another NodeProvider
         }
     }
     async getRpc(options?: IPoolWeb3Request) {
@@ -218,7 +218,7 @@ export class ClientPool {
     async getWrappedWeb3(options?: IPoolWeb3Request) {
         let wClient = await this.next(null, options, { manual: true });
         if (wClient == null) {
-            throw new Error(`No client found in ${this.clients.length} Clients with options: ${JSON.stringify(options)}`);
+            throw new Error(`No client was found in ${this.clients.length} clients with options: ${JSON.stringify(options)}`);
         }
         return wClient;
     }
@@ -228,7 +228,7 @@ export class ClientPool {
             let stats = await this.getNodeStats();
             let info = stats.map(x => `    ${x.url}. ERR: ${x.fail}; OK: ${x.success}; Ping: ${x.ping}`).join('\n');
             let requirements = JSON.stringify(options);
-            throw new Error(`No alive node for ${requirements} found. \n ${info}`);
+            throw new Error(`No live node was found for ${requirements}. \n ${info}`);
         }
         return wClient?.config.url;
     }
@@ -291,7 +291,7 @@ export class ClientPool {
                         .map(x => `    ${x.config.url}`)
                         .join('\n');
 
-                    let error = new Error(`Live clients not found in \n${urls}`);
+                    let error = new Error(`Live clients were not found in \n${urls}`);
                     root.emit('error', error);
                     root.reject(error);
                 });
@@ -371,7 +371,7 @@ export class ClientPool {
     }): Promise<IWeb3ClientStatus[]> {
         const Calls = {
             async net_peerCount(wClient: WClient) {
-                /** @TODO Public nodes smt. do not allow net_peerCount methods. Allow to switch this on/off on node-url-config level */
+                /** @TODO Public nodes sometimes do not allow net_peerCount methods. Allow this to be switched on/off at the node URL config level */
                 try {
                     return await wClient.rpc.net_peerCount();
                 } catch (error) {
@@ -476,7 +476,7 @@ export class ClientPool {
                 return true;
             });
             if (clientsWithSupportedMethod.length > 0) {
-                // if there are no clients with manually specified method, use all clients
+                // If there are no clients with the manually specified method, use all clients
                 clients = clientsWithSupportedMethod;
             }
         } else {
@@ -495,7 +495,7 @@ export class ClientPool {
         }
 
         if (opts?.ws === false) {
-            // filter out all WS providers (important for batched requests, as web3js has issues submitting multiple batch requests and handle response IDs)
+            // Filter out all WS providers. This is important for batched requests, as web3.js has issues submitting multiple batch requests and handling response IDs
             clients = clients.filter(x => x.config.url?.startsWith('http') || x.config.url == null);
         }
         if (opts?.node?.traceable === true) {
@@ -510,10 +510,10 @@ export class ClientPool {
             this.discoveredPartial = true;
         }
 
-        // we check OK clients first
+        // Check OK clients first
         let okClients = clients.filter(x => x.status === 'ok');
         if (okClients.length === 0) {
-            // then switch to at least not off
+            // Then switch to clients that are at least not off
             let notOffClients = clients.filter(x => x.status !== 'off');
             if (notOffClients) {
                 clients = notOffClients;
@@ -562,14 +562,14 @@ export class ClientPool {
             arr = arr.filter(x => {
                 let blocks = x.blockRangeLimits.blocks;
                 if (blocks == null) {
-                    // Block limit is unknown yet
+                    // The block limit is not known yet
                     return true;
                 }
                 if (blocks < this.MINIMUM_BLOCK_RANGE) {
-                    // Was not possible to load a minimum amount of blocks
+                    // Could not load the minimum number of blocks
                     return false;
                 }
-                // Get if higher than 50% of max supported limit
+                // Use clients higher than 50% of the max supported limit
                 return x.blockRangeLimits.blocks >= upperThreshold
             });
         }
@@ -600,16 +600,16 @@ export class ClientPool {
 
         const MAX_WAIT = 60_000;
         if (minWait > MAX_WAIT) {
-            throw new Error(`rate limit overflows. Waiting ${minWait}ms`);
+            throw new Error(`Rate limit overflow. Waiting ${minWait}ms`);
         }
         return minClient;
     }
 
     /**
-     * We may have tens of Nodes to communicate with. Discover LIVE and operating nodes.
-     * Resolves when first 3 active nodes are discovered, to prevent waiting for all of them.
+     * We may have tens of nodes to communicate with. Discover live and operating nodes
+     * Resolves when the first 3 active nodes are discovered to avoid waiting for all of them
      * @returns
-     * - Ready Promise - in case 3 clients look good
+     * - Ready Promise - when 3 clients look good
      * - Complete Promise - when all clients are resolved
      */
     @memd.deco.memoize({ perInstance: true })
@@ -749,13 +749,13 @@ export class WClient {
     config: IRpcConfig
     rateLimitGuard: RateLimitGuard
 
-    /** For getLogs method, as some providers limit the range request or page result value */
+    /** For the getLogs method, as some providers limit the range request or paged result size */
     blockRangeLimits: {
         blocks?: number
         results?: number
     }
 
-    // Max requests per single Web3 Batch request
+    // Max requests per single Web3 batch request
     batchLimit?: number
 
     healthy() {
@@ -929,7 +929,7 @@ export class WClient {
                 let batch = new Web3BatchRequests.BatchRequest(client.rpc, page);
                 let results = await batch.execute(options);
                 return results;
-            });
+            }, { batchRequestCount: total });
             if (status === ClientStatus.Ok) {
                 output.push(...pageResult);
                 continue;
@@ -947,7 +947,7 @@ export class WClient {
     }
 
     async call<TResult extends PromiseLike<any>>(fn: (wClient: WClient) => TResult, options?: {
-        // For the rate limit guard, to make sure we wait enough time to proceed with batch request for example
+        // For the rate limit guard, to make sure we wait long enough to proceed with a batch request, for example
         batchRequestCount?: number
     }): Promise<{ status: ClientStatus, error?, result?: Awaited<TResult>, time: number }> {
         let now = Date.now();
@@ -1091,7 +1091,7 @@ export class WClient {
     }
 
     /**
-     * Checks the rate limit wait time, so that the POOL can select the wClient with shortest wait time
+     * Checks the rate limit wait time so the pool can select the wClient with the shortest wait time
      **/
     getRateLimitGuardTime() {
         return this.rateLimitGuard?.checkWaitTime() ?? 0;