@rabbitio/ui-kit 1.0.0-beta.41 → 1.0.0-beta.42

package/dist/index.cjs

@@ -1,16 +1,16 @@
 var React = require('react');
 var bignumber_js = require('bignumber.js');
 var axios = require('axios');
-var uuid = require('uuid');
-var Hashes = require('jshashes');
 var EventBusInstance = require('eventbusjs');
+var Hashes = require('jshashes');
+var uuid = require('uuid');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-var Hashes__default = /*#__PURE__*/_interopDefaultLegacy(Hashes);
 var EventBusInstance__default = /*#__PURE__*/_interopDefaultLegacy(EventBusInstance);
+var Hashes__default = /*#__PURE__*/_interopDefaultLegacy(Hashes);
 
 function createCommonjsModule(fn) {
   var module = { exports: {} };
@@ -1630,7 +1630,7 @@ var Logger = /*#__PURE__*/function () {
   return Logger;
 }();
 
-function _catch$8(body, recover) {
+function _catch$9(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -1646,7 +1646,7 @@ function useCallHandlingErrors() {
     setState = _useState[1];
   return React.useCallback(function (functionToBeCalled, event) {
     try {
-      var _temp = _catch$8(function () {
+      var _temp = _catch$9(function () {
         return Promise.resolve(functionToBeCalled(event)).then(function () {});
       }, function (error) {
         Logger.logError(error, (functionToBeCalled == null ? void 0 : functionToBeCalled.name) || "errorBoundaryTrigger", "Caught by ErrorBoundary");
@@ -2684,7 +2684,7 @@ var Cache = /*#__PURE__*/function () {
   return Cache;
 }();
 
-function _catch$7(body, recover) {
+function _catch$8(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -2702,7 +2702,7 @@ function postponeExecution(execution, timeoutMS) {
   return new Promise(function (resolve, reject) {
     setTimeout(function () {
       try {
-        var _temp = _catch$7(function () {
+        var _temp = _catch$8(function () {
           return Promise.resolve(execution()).then(function (_execution) {
             resolve(_execution);
           });
@@ -2786,7 +2786,7 @@ var AxiosAdapter = /*#__PURE__*/function () {
   return AxiosAdapter;
 }();
 
-function _catch$6(body, recover) {
+function _catch$7(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -2802,7 +2802,7 @@ var EmailsApi = /*#__PURE__*/function () {
   EmailsApi.sendEmail = function sendEmail(subject, body) {
     try {
       var _this = this;
-      var _temp = _catch$6(function () {
+      var _temp = _catch$7(function () {
         var url = window.location.protocol + "//" + window.location.host + "/api/v1/" + _this.serverEndpointEntity;
         return Promise.resolve(axios__default["default"].post(url, {
           subject: subject,
@@ -2820,772 +2820,317 @@ var EmailsApi = /*#__PURE__*/function () {
 }();
 EmailsApi.serverEndpointEntity = "emails";
 
-/**
- * This util helps to avoid duplicated calls to a shared resource.
- * It tracks is there currently active calculation for the specific cache id and make all other requests
- * with the same cache id waiting for this active calculation to be finished. When the calculation ends
- * the resolver allows all the waiting requesters to get the data from cache and start their own calculations.
- *
- * This class should be instantiated inside some other service where you need to request some resource concurrently.
- * Rules:
- * 1. When you need to make a request inside your main service call 'getCachedOrWaitForCachedOrAcquireLock'
- *    on the instance of this class and await for the result. If the flag allowing to start calculation is true
- *    then you can request data inside your main service. Otherwise you should use the cached data as an another
- *    requester just finished the most resent requesting and there is actual data in the cache that
- *    is returned to you here.
- * 1.1 Also you can acquire a lock directly if you don't want to get cached data. Use the corresponding method 'acquireLock'.
- *
- * 2. If you start requesting (when you successfully acquired the lock) then after receiving the result of your
- *    requesting you should call the 'saveCachedData' so the retrieved data will appear in the cache.
- *
- * 3. If you successfully acquired the lock then you should after calling the 'saveCachedData' call
- *    the 'releaseLock' - this is mandatory to release the lock and allow other requesters to perform their requests.
- *    WARNING: If for any reason you forget to call this method then this class instance will wait perpetually for
- *    the lock releasing and all your attempts to request the data will constantly fail. So usually call it
- *    inside the 'finally' block.
- *
- * TODO: [tests, critical++] add unit tests - massively used logic and can produce sophisticated concurrency bugs
- */
-
-function _settle$2(pact, state, value) {
-  if (!pact.s) {
-    if (value instanceof _Pact$2) {
-      if (value.s) {
-        if (state & 1) {
-          state = value.s;
-        }
-        value = value.v;
-      } else {
-        value.o = _settle$2.bind(null, pact, state);
-        return;
-      }
-    }
-    if (value && value.then) {
-      value.then(_settle$2.bind(null, pact, state), _settle$2.bind(null, pact, 2));
-      return;
+var ExternalApiProvider = /*#__PURE__*/function () {
+  /**
+   * Creates an instance of external api provider.
+   *
+   * If you need sub-request then use 'subRequestIndex' to check current request index in functions below.
+   * Also use array for 'httpMethod'.
+   *
+   * If the endpoint of dedicated provider has pagination then you should customize the behavior using
+   * "changeQueryParametersForPageNumber", "checkWhetherResponseIsForLastPage".
+   *
+   * We perform RPS counting all over the App to avoid blocking our clients due to abuses of the providers.
+   *
+   * @param endpoint {string} URL to the provider's endpoint. Note: you can customize it using composeQueryString
+   * @param [httpMethod] {string|string[]} one of "get", "post", "put", "patch", "delete" or an array of these values
+   *        for request having sub-requests
+   * @param [timeout] {number} number of milliseconds to wait for the response
+   * @param [apiGroup] {ApiGroup} singleton object containing parameters of API group. Helpful when you use the same
+   *        api for different providers to avoid hardcoding RPS inside each provider what can cause mistakes
+   * @param [specificHeaders] {Object} contains specific keys (headers) and values (their content) if needed for this provider
+   * @param [maxPageLength] {number} optional number of items per page if the request supports pagination
+   */
+  function ExternalApiProvider(endpoint, httpMethod, timeout, apiGroup, specificHeaders, maxPageLength) {
+    var _maxPageLength, _specificHeaders;
+    if (specificHeaders === void 0) {
+      specificHeaders = {};
     }
-    pact.s = state;
-    pact.v = value;
-    const observer = pact.o;
-    if (observer) {
-      observer(pact);
+    if (maxPageLength === void 0) {
+      maxPageLength = Number.MAX_SAFE_INTEGER;
     }
+    this.endpoint = endpoint;
+    this.httpMethod = httpMethod != null ? httpMethod : "get";
+    // TODO: [refactoring, critical] We have two timeouts for robust data retrieval - here and inside the service method call, need to remain the only
+    this.timeout = timeout != null ? timeout : 10000;
+    // TODO: [refactoring, critical] We need single place for all RPSes as we use them as hardcoded constants now inside different services
+    this.apiGroup = apiGroup;
+    this.maxPageLength = (_maxPageLength = maxPageLength) != null ? _maxPageLength : Number.MAX_SAFE_INTEGER;
+    this.niceFactor = 1;
+    this.specificHeaders = (_specificHeaders = specificHeaders) != null ? _specificHeaders : {};
   }
-}
-
-/**
- * Util class to control access to a resource when it can be called in parallel for the same result.
- * (E.g. getting today coins-fiat rates from some API).
- */
-var _Pact$2 = /*#__PURE__*/function () {
-  function _Pact() {}
-  _Pact.prototype.then = function (onFulfilled, onRejected) {
-    var result = new _Pact();
-    var state = this.s;
-    if (state) {
-      var callback = state & 1 ? onFulfilled : onRejected;
-      if (callback) {
-        try {
-          _settle$2(result, 1, callback(this.v));
-        } catch (e) {
-          _settle$2(result, 2, e);
-        }
-        return result;
-      } else {
-        return this;
-      }
-    }
-    this.o = function (_this) {
-      try {
-        var value = _this.v;
-        if (_this.s & 1) {
-          _settle$2(result, 1, onFulfilled ? onFulfilled(value) : value);
-        } else if (onRejected) {
-          _settle$2(result, 1, onRejected(value));
-        } else {
-          _settle$2(result, 2, value);
-        }
-      } catch (e) {
-        _settle$2(result, 2, e);
-      }
-    };
-    return result;
+  var _proto = ExternalApiProvider.prototype;
+  _proto.getRps = function getRps() {
+    var _this$apiGroup$rps;
+    return (_this$apiGroup$rps = this.apiGroup.rps) != null ? _this$apiGroup$rps : 2;
   };
-  return _Pact;
-}();
-function _isSettledPact$2(thenable) {
-  return thenable instanceof _Pact$2 && thenable.s & 1;
-}
-function _for$1(test, update, body) {
-  var stage;
-  for (;;) {
-    var shouldContinue = test();
-    if (_isSettledPact$2(shouldContinue)) {
-      shouldContinue = shouldContinue.v;
-    }
-    if (!shouldContinue) {
-      return result;
-    }
-    if (shouldContinue.then) {
-      stage = 0;
-      break;
-    }
-    var result = body();
-    if (result && result.then) {
-      if (_isSettledPact$2(result)) {
-        result = result.s;
-      } else {
-        stage = 1;
-        break;
-      }
-    }
-    if (update) {
-      var updateValue = update();
-      if (updateValue && updateValue.then && !_isSettledPact$2(updateValue)) {
-        stage = 2;
-        break;
-      }
-    }
-  }
-  var pact = new _Pact$2();
-  var reject = _settle$2.bind(null, pact, 2);
-  (stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
-  return pact;
-  function _resumeAfterBody(value) {
-    result = value;
-    do {
-      if (update) {
-        updateValue = update();
-        if (updateValue && updateValue.then && !_isSettledPact$2(updateValue)) {
-          updateValue.then(_resumeAfterUpdate).then(void 0, reject);
-          return;
-        }
-      }
-      shouldContinue = test();
-      if (!shouldContinue || _isSettledPact$2(shouldContinue) && !shouldContinue.v) {
-        _settle$2(pact, 1, result);
-        return;
-      }
-      if (shouldContinue.then) {
-        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-        return;
-      }
-      result = body();
-      if (_isSettledPact$2(result)) {
-        result = result.v;
-      }
-    } while (!result || !result.then);
-    result.then(_resumeAfterBody).then(void 0, reject);
-  }
-  function _resumeAfterTest(shouldContinue) {
-    if (shouldContinue) {
-      result = body();
-      if (result && result.then) {
-        result.then(_resumeAfterBody).then(void 0, reject);
-      } else {
-        _resumeAfterBody(result);
-      }
-    } else {
-      _settle$2(pact, 1, result);
-    }
-  }
-  function _resumeAfterUpdate() {
-    if (shouldContinue = test()) {
-      if (shouldContinue.then) {
-        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-      } else {
-        _resumeAfterTest(shouldContinue);
-      }
-    } else {
-      _settle$2(pact, 1, result);
-    }
-  }
-}
-function _catch$5(body, recover) {
-  try {
-    var result = body();
-  } catch (e) {
-    return recover(e);
+  _proto.isRpsExceeded = function isRpsExceeded() {
+    return this.apiGroup.isRpsExceeded();
+  };
+  _proto.actualizeLastCalledTimestamp = function actualizeLastCalledTimestamp() {
+    this.apiGroup.actualizeLastCalledTimestamp();
+  };
+  _proto.getApiGroupId = function getApiGroupId() {
+    return this.apiGroup.id;
   }
-  if (result && result.then) {
-    return result.then(void 0, recover);
+
+  /**
+   * Some endpoint can require several sub requests. Example is one request to get confirmed transactions
+   * and another request for unconfirmed transactions. You should override this method to return true for such requests.
+   *
+   * @return {boolean} true if this provider requires several requests to retrieve the data
+   */;
+  _proto.doesRequireSubRequests = function doesRequireSubRequests() {
+    return false;
   }
-  return result;
-}
-var CacheAndConcurrentRequestsResolver = /*#__PURE__*/function () {
+
   /**
-   * @param bio {string} unique identifier for the exact service
-   * @param cache {Cache} cache
-   * @param cacheTtl {number|null} time to live for cache ms. 0 or null means the cache cannot expire
-   * @param [maxCallAttemptsToWaitForAlreadyRunningRequest=100] {number} number of request allowed to do waiting for
-   *        result before we fail the original request. Use custom value only if you need to make the attempts count
-   *        and polling interval changes.
-   * @param [timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished=1000] {number}
-   *        timeout ms for polling for a result. if you change maxCallAttemptsToWaitForAlreadyRunningRequest
-   *        then this parameter maybe also require the custom value.
-   * @param [removeExpiredCacheAutomatically=true] {boolean}
-   */
-  function CacheAndConcurrentRequestsResolver(bio, cache, cacheTtl, removeExpiredCacheAutomatically, maxCallAttemptsToWaitForAlreadyRunningRequest, timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished) {
-    if (removeExpiredCacheAutomatically === void 0) {
-      removeExpiredCacheAutomatically = true;
-    }
-    if (maxCallAttemptsToWaitForAlreadyRunningRequest === void 0) {
-      maxCallAttemptsToWaitForAlreadyRunningRequest = 100;
-    }
-    if (timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished === void 0) {
-      timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished = 1000;
-    }
-    if (cacheTtl != null && cacheTtl < timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished * 2) {
-      /*
-       * During the lifetime of this service e.g. if the data is being retrieved slowly we can get
-       * RACE CONDITION when we constantly retrieve data and during retrieval it is expired, so we are trying
-       * to retrieve it again and again.
-       * We have a protection mechanism that we will wait no more than
-       * maxCallAttemptsToWaitForAlreadyRunningRequest * timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished
-       * but this additional check is aimed to reduce potential loading time for some requests.
-       */
-      throw new Error("DEV: Wrong parameters passed to construct " + bio + " - TTL " + cacheTtl + " should be 2 times greater than " + timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished);
-    }
-    this._bio = bio;
-    this._cache = cache;
-    this._cacheTtlMs = cacheTtl != null ? cacheTtl : null;
-    this._maxExecutionTimeMs = maxCallAttemptsToWaitForAlreadyRunningRequest * timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished;
-    this._removeExpiredCacheAutomatically = removeExpiredCacheAutomatically;
-    this._requestsManager = new ManagerOfRequestsToTheSameResource(bio, maxCallAttemptsToWaitForAlreadyRunningRequest, timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished);
+   * Some endpoint support pagination. Override this method if so and implement corresponding methods.
+   *
+   * @return {boolean} true if this provider requires several requests to retrieve the data
+   */;
+  _proto.doesSupportPagination = function doesSupportPagination() {
+    return false;
   }
 
   /**
-   * When using this service this is the major method you should call to get data by cache id.
-   * This method checks is there cached data and ether
-   * - returns you flag that you can start requesting data from the shared resource
-   * - or if there is already started calculation waits until it is finished (removed from this service)
-   *   and returns you the retrieved data
-   * - or just returns you the cached data
-   *
-   * 'canStartDataRetrieval' equal true means that the lock was acquired, and you should manually call 'saveCachedData'
-   * if needed and then 'releaseLock' to mark this calculation as finished so other
-   * requesters can take their share of the resource.
+   * Composes a query string to be added to the endpoint of this provider.
    *
-   * @param cacheId {string}
-   * @return {Promise<({
-   *             canStartDataRetrieval: true,
-   *             cachedData: any,
-   *             lockId: string
-   *         }|{
-   *             canStartDataRetrieval: false,
-   *             cachedData: any
-   *         })>}
-   */
-  var _proto = CacheAndConcurrentRequestsResolver.prototype;
-  _proto.getCachedOrWaitForCachedOrAcquireLock = function getCachedOrWaitForCachedOrAcquireLock(cacheId) {
-    try {
-      var _this = this;
-      return Promise.resolve(_catch$5(function () {
-        function _temp2() {
-          var _cached, _cached2;
-          return calculationId ? {
-            canStartDataRetrieval: true,
-            cachedData: (_cached = cached) != null ? _cached : cachedDataBackupIsPresentButExpired,
-            lockId: calculationId
-          } : {
-            canStartDataRetrieval: false,
-            cachedData: (_cached2 = cached) != null ? _cached2 : cachedDataBackupIsPresentButExpired
-          };
-        }
-        var startedAtTimestamp = Date.now();
-        var cached = _this._cache.get(cacheId);
-        var cachedDataBackupIsPresentButExpired = null;
-        if (cached != null && !_this._removeExpiredCacheAutomatically) {
-          var lastUpdateTimestamp = _this._cache.getLastUpdateTimestamp(cacheId);
-          if ((lastUpdateTimestamp != null ? lastUpdateTimestamp : 0) + _this._cacheTtlMs < Date.now()) {
-            /*
-             * Here we are manually clearing 'cached' value retrieved from cache to force the data loading.
-             * But we save its value first to the backup variable to be able to return this value if ongoing
-             * requesting fails.
-             */
-            cachedDataBackupIsPresentButExpired = cached;
-            cached = null;
-          }
-        }
-        var calculationId = null;
-        var isRetrievedCacheExpired = true;
-        var isWaitingForActiveCalculationSucceeded;
-        var weStillHaveSomeTimeToProceedExecution = true;
-        var _temp = _for$1(function () {
-          return calculationId == null && cached == null && !!isRetrievedCacheExpired && !!weStillHaveSomeTimeToProceedExecution;
-        }, void 0, function () {
-          return Promise.resolve(_this._requestsManager.startCalculationOrWaitForActiveToFinish(cacheId)).then(function (result) {
-            calculationId = typeof result === "string" ? result : null;
-            isWaitingForActiveCalculationSucceeded = typeof result === "boolean" ? result : null;
-            cached = _this._cache.get(cacheId);
-            isRetrievedCacheExpired = isWaitingForActiveCalculationSucceeded && cached == null;
-            weStillHaveSomeTimeToProceedExecution = Date.now() - startedAtTimestamp < _this._maxExecutionTimeMs;
-          });
-        });
-        return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
-      }, function (e) {
-        improveAndRethrow(e, _this._bio + ".getCachedOrWaitForCachedOrAcquireLock");
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
+   * @param params {any[]} params array passed to the RobustExternalAPICallerService
+   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
+   * @returns {string} query string to be concatenated with endpoint
+   */;
+  _proto.composeQueryString = function composeQueryString(params, subRequestIndex) {
+    return "";
   }
+
   /**
-   * Returns just the current cache value for the given id.
-   * Doesn't wait for the active calculation, doesn't acquire lock, just retrieves the current cache as it is.
+   * Composes a body to be added to the request
    *
-   * @param cacheId {string}
-   * @return {any}
-   */
-  ;
-  _proto.getCached = function getCached(cacheId) {
-    try {
-      return this._cache.get(cacheId);
-    } catch (e) {
-      improveAndRethrow(e, "getCached");
-    }
-  };
-  _proto._getTtl = function _getTtl() {
-    return this._removeExpiredCacheAutomatically ? this._cacheTtlMs : null;
+   * @param params {any[]} params array passed to the RobustExternalAPICallerService
+   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
+   * @returns {string}
+   */;
+  _proto.composeBody = function composeBody(params, subRequestIndex) {
+    return "";
   }
 
   /**
-   * Directly acquires the lock despite on cached data availability.
-   * So if this method returns result === true you can start the data retrieval.
+   * Extracts data from the response and returns it
    *
-   * @param cacheId {string}
-   * @return {Promise<{ result: true, lockId: string }|{ result: false }>}
+   * @param response {Object} HTTP response returned by provider
+   * @param [params] {any[]} params array passed to the RobustExternalAPICallerService
+   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
+   * @param iterationsData {any[]} array of data retrieved from previous sub-requests
+   * @returns {any}
    */;
-  _proto.acquireLock = function acquireLock(cacheId) {
-    try {
-      var _this2 = this;
-      return Promise.resolve(_catch$5(function () {
-        return Promise.resolve(_this2._requestsManager.acquireLock(cacheId));
-      }, function (e) {
-        improveAndRethrow(e, "acquireLock");
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
+  _proto.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
+    return [];
   }
+
   /**
-   * This method should be called only if you acquired a lock successfully.
-   *
-   * If the current lock id is not equal to the passed one the passed data will be ignored.
-   * Or you can do the synchronous data merging on your side and pass the
-   * wasDataMergedSynchronouslyWithMostRecentCacheState=true so your data will be stored
-   * despite on the lockId.
-   * WARNING: you should do this only if you are sure you perform the synchronous update.
+   * Function changing the query string according to page number and previous response
+   * Only for endpoints supporting pagination
    *
-   * @param cacheId {string}
-   * @param lockId {string}
-   * @param data {any}
-   * @param [sessionDependentData=true] {boolean}
-   * @param [wasDataMergedSynchronouslyWithMostRecentCacheState=false]
-   */
-  ;
-  _proto.saveCachedData = function saveCachedData(cacheId, lockId, data, sessionDependentData, wasDataMergedSynchronouslyWithMostRecentCacheState) {
-    if (sessionDependentData === void 0) {
-      sessionDependentData = true;
-    }
-    if (wasDataMergedSynchronouslyWithMostRecentCacheState === void 0) {
-      wasDataMergedSynchronouslyWithMostRecentCacheState = false;
-    }
-    try {
-      if (wasDataMergedSynchronouslyWithMostRecentCacheState || this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
-        /* We save passed data only if the <caller> has the currently acquired lockId.
-         * If the passed lockId is not the active one it means that other code cleared/stopped the lock
-         * acquired by the <caller> recently due to some urgent/more prior changes.
-         *
-         * But we allow user to pass the 'wasDataMergedSynchronouslyWithMostRecentCacheState' flag
-         * that tells us that the user had taken the most recent cache value and merged his new data
-         * with that cached value (AFTER possibly performing async data retrieval). This means that we
-         * can ignore the fact that his lockId is no more relevant and save the passed data
-         * as it is synchronously merged with the most recent cached data. (Synchronously merged means that
-         * the lost update cannot occur during the merge time as JS execute the synchronous functions\
-         * till the end).
-         */
-        if (sessionDependentData) {
-          this._cache.putSessionDependentData(cacheId, data, this._getTtl());
-        } else {
-          this._cache.put(cacheId, data, this._getTtl());
-        }
-      }
-    } catch (e) {
-      improveAndRethrow(e, this._bio + ".saveCachedData");
-    }
+   * @param params {any[]} params array passed to the RobustExternalAPICallerService
+   * @param previousResponse {Object} HTTP response returned by provider for previous call (previous page)
+   * @param pageNumber {number} new page number. We count from 0. You need to manually increment with 1 if your
+   *        provider counts pages starting with 1
+   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
+   * @returns {any[]}
+   */;
+  _proto.changeQueryParametersForPageNumber = function changeQueryParametersForPageNumber(params, previousResponse, pageNumber, subRequestIndex) {
+    return params;
   }
 
   /**
-   * Should be called then and only then if you successfully acquired a lock with the lock id.
+   * Function checking whether the response is for the last page to stop requesting for a next page.
+   * Only for endpoints supporting pagination.
    *
-   * @param cacheId {string}
-   * @param lockId {string}
+   * @param previousResponse {Object} HTTP response returned by provider for previous call (previous page)
+   * @param currentResponse {Object} HTTP response returned by provider for current call (current page, next after the previous)
+   * @param currentPageNumber {number} current page number (for current response)
+   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
+   * @returns {boolean}
    */;
-  _proto.releaseLock = function releaseLock(cacheId, lockId) {
-    try {
-      if (this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
-        this._requestsManager.finishActiveCalculation(cacheId);
-      }
-    } catch (e) {
-      improveAndRethrow(e, this._bio + ".releaseLock");
-    }
+  _proto.checkWhetherResponseIsForLastPage = function checkWhetherResponseIsForLastPage(previousResponse, currentResponse, currentPageNumber, subRequestIndex) {
+    return true;
   }
 
   /**
-   * Actualized currently present cached data by key. Applies the provided function to the cached data.
+   * Resets the nice factor to default value
+   */;
+  _proto.resetNiceFactor = function resetNiceFactor() {
+    this.niceFactor = 1;
+  }
+
+  /**
+   * Internal method used for requests requiring sub-requests.
    *
-   * @param cacheId {string} id of cache entry
-   * @param synchronousCurrentCacheProcessor (function|null} synchronous function accepting cache entry. Should return
-   *        an object in following format:
-   *        {
-   *            isModified: boolean,
-   *            data: any
-   *        }
-   *        the flag signals whether data was changed during the processing or not
-   * @param [sessionDependent=true] {boolean} whether to mark the cache entry as session-dependent
+   * @param iterationsData {any[]} iterations data retrieved from getDataByResponse called per sub-request.
+   * @return {any} by default flatten the passed iterations data array. Should be redefined if you need another logic.
    */;
-  _proto.actualizeCachedData = function actualizeCachedData(cacheId, synchronousCurrentCacheProcessor, sessionDependent) {
-    if (sessionDependent === void 0) {
-      sessionDependent = true;
-    }
-    try {
-      var cached = this._cache.get(cacheId);
-      var result = synchronousCurrentCacheProcessor(cached);
-      if (result != null && result.isModified && (result == null ? void 0 : result.data) != null) {
-        if (sessionDependent) {
-          this._cache.putSessionDependentData(cacheId, result == null ? void 0 : result.data, this._getTtl());
-        } else {
-          this._cache.put(cacheId, result == null ? void 0 : result.data, this._getTtl());
-        }
+  _proto.incorporateIterationsData = function incorporateIterationsData(iterationsData) {
+    return iterationsData.flat();
+  };
+  return ExternalApiProvider;
+}();
 
-        /* Here we call the lock releasing to ensure the currently active calculation will be ignored.
-         * This is needed to ensure no 'lost update'.
-         * Lost update can occur if we change data in this method and after that some calculation finishes
-         * having the earlier data as its base to calculate its data set result. And the earlier data
-         * has no changes applied inside this method, so we will lose them.
-         *
-         * This is not so good solution: ideally, we should acquire lock before performing any data updating.
-         * But the goal of this method is to provide an instant ability to update the cached data.
-         * And if we start acquiring the lock here the data update can be postponed significantly.
-         * And this kills the desired nature of this method.
-         * So we better lose some data retrieval (means abusing the resource a bit) than lose
-         * the instant update expected after this method execution.
-         */
-        this._requestsManager.finishActiveCalculation(cacheId);
-      }
-    } catch (e) {
-      improveAndRethrow(e, this._bio + ".actualizeCachedData");
+/**
+ * Models a group of APIs provided by the same owner and used for different services in our app.
+ * It means we need to mention RPS several times for each usage and also have some holder of last call timestamp per
+ * api group. So this concept allows to use it for exact ExternalApiProvider and make sure that you use the same
+ * RPS value and make decisions on base of the same timestamp of last call to the API group owner.
+ */
+var ApiGroup = /*#__PURE__*/function () {
+  function ApiGroup(id, rps, backendProxyIdGenerator) {
+    if (backendProxyIdGenerator === void 0) {
+      backendProxyIdGenerator = null;
     }
+    this.id = id;
+    this.rps = rps;
+    this.lastCalledTimestamp = null;
+    this.backendProxyIdGenerator = backendProxyIdGenerator;
+  }
+  var _proto = ApiGroup.prototype;
+  _proto.isRpsExceeded = function isRpsExceeded() {
+    var _this$lastCalledTimes;
+    return ((_this$lastCalledTimes = this.lastCalledTimestamp) != null ? _this$lastCalledTimes : 0) + Math.floor(1000 / this.rps) > Date.now();
   };
-  _proto.invalidate = function invalidate(key) {
-    this._cache.invalidate(key);
-    this._requestsManager.finishActiveCalculation(key);
-  };
-  _proto.invalidateContaining = function invalidateContaining(keyPart) {
-    this._cache.invalidateContaining(keyPart);
-    this._requestsManager.finishAllActiveCalculations(keyPart);
-  };
-  _proto.markAsExpiredButDontRemove = function markAsExpiredButDontRemove(key) {
-    if (this._removeExpiredCacheAutomatically) {
-      this._cache.markCacheItemAsExpiredButDontRemove(key, this._cacheTtlMs);
-    } else {
-      this._cache.setLastUpdateTimestamp(key, Date.now() - this._cacheTtlMs - 1);
-    }
-    this._requestsManager.finishAllActiveCalculations(key);
+  _proto.actualizeLastCalledTimestamp = function actualizeLastCalledTimestamp() {
+    this.lastCalledTimestamp = Date.now();
   };
-  return CacheAndConcurrentRequestsResolver;
+  return ApiGroup;
 }();
-var ManagerOfRequestsToTheSameResource = /*#__PURE__*/function () {
+var ApiGroups = {
   /**
-   * @param bio {string} resource-related identifier for logging
-   * @param [maxPollsCount=100] {number} max number of attempts to wait when waiting for a lock acquisition
-   * @param [timeoutDuration=1000] {number} timeout between the polls for a lock acquisition
+   * Currently we use free version of etherscan provider with 0.2 RPS. But we have API key with 100k requests free
+   * per month. So we can add it if not enough current RPS.
    */
-  function ManagerOfRequestsToTheSameResource(bio, maxPollsCount, timeoutDuration) {
-    if (maxPollsCount === void 0) {
-      maxPollsCount = 100;
+  ETHERSCAN: new ApiGroup("etherscan", 0.17),
+  // Actually 0.2 but fails sometime, so we use smaller
+  ALCHEMY: new ApiGroup("alchemy", 0.3, function (networkKey) {
+    return "alchemy-" + networkKey;
+  }),
+  BLOCKSTREAM: new ApiGroup("blockstream", 0.2),
+  BLOCKCHAIN_INFO: new ApiGroup("blockchain.info", 1),
+  BLOCKNATIVE: new ApiGroup("blocknative", 0.5),
+  ETHGASSTATION: new ApiGroup("ethgasstation", 0.5),
+  TRONGRID: new ApiGroup("trongrid", 0.3, function (networkKey) {
+    return "trongrid-" + networkKey;
+  }),
+  TRONSCAN: new ApiGroup("tronscan", 0.3),
+  GETBLOCK: new ApiGroup("getblock", 0.3),
+  COINCAP: new ApiGroup("coincap", 0.5),
+  // 200 per minute without API key
+  COINGECKO: new ApiGroup("coingecko", 0.9),
+  // actually 0.13-0.5 according to the docs but we use smaller due to expirienced frequent abuses
+  MESSARI: new ApiGroup("messari", 0.2),
+  BTCCOM: new ApiGroup("btccom", 0.2),
+  BITAPS: new ApiGroup("bitaps", 0.25),
+  // Docs say that RPS is 3 but using it causes frequent 429 HTTP errors
+  CEX: new ApiGroup("cex", 0.5),
+  // Just assumption for RPS
+  BIGDATACLOUD: new ApiGroup("bigdatacloud", 1),
+  // Just assumption for RPS
+  TRACKIP: new ApiGroup("trackip", 1),
+  // Just assumption for RPS
+  IPIFY: new ApiGroup("ipify", 1),
+  // Just assumption for RPS
+  WHATISMYIPADDRESS: new ApiGroup("whatismyipaddress", 1),
+  // Just assumption for RPS
+  EXCHANGERATE: new ApiGroup("exchangerate", 1),
+  // Just assumption for RPS
+  FRANKFURTER: new ApiGroup("frankfurter", 1),
+  // Just assumption for RPS
+  BITGO: new ApiGroup("bitgo", 1),
+  // Just assumption for RPS
+  BITCOINER: new ApiGroup("bitcoiner", 1),
+  // Just assumption for RPS
+  BITCORE: new ApiGroup("bitcore", 1),
+  // Just assumption for RPS
+  // BLOCKCHAIR: new ApiGroup("blockchair", 0.04), // this provider require API key for commercial use (10usd 10000 reqs), we will add it later
+  MEMPOOL: new ApiGroup("mempool", 0.2) // Just assumption for RPS
+};
+
+// TODO: [refactoring, low] Consider removing this logic task_id=c360f2af75764bde8badd9ff1cc00d48
+var ConcurrentCalculationsMetadataHolder = /*#__PURE__*/function () {
+  function ConcurrentCalculationsMetadataHolder() {
+    this._calculations = {};
+  }
+  var _proto = ConcurrentCalculationsMetadataHolder.prototype;
+  _proto.startCalculation = function startCalculation(domain, calculationsHistoryMaxLength) {
+    if (calculationsHistoryMaxLength === void 0) {
+      calculationsHistoryMaxLength = 100;
     }
-    if (timeoutDuration === void 0) {
-      timeoutDuration = 1000;
+    if (!this._calculations[domain]) {
+      this._calculations[domain] = [];
+    }
+    if (this._calculations[domain].length > calculationsHistoryMaxLength) {
+      this._calculations[domain] = this._calculations[domain].slice(Math.round(calculationsHistoryMaxLength * 0.2));
+    }
+    var newCalculation = {
+      startTimestamp: Date.now(),
+      endTimestamp: null,
+      uuid: uuid.v4()
+    };
+    this._calculations[domain].push(newCalculation);
+    return newCalculation.uuid;
+  };
+  _proto.endCalculation = function endCalculation(domain, uuid, isFailed) {
+    if (isFailed === void 0) {
+      isFailed = false;
     }
-    this.bio = bio;
-    this.maxPollsCount = maxPollsCount;
-    this.timeoutDuration = timeoutDuration;
-    this._activeCalculationsIds = new Map();
-    this._nextCalculationIds = new Map();
-  }
-
-  /**
-   * If there is no active calculation just creates uuid and returns it.
-   * If there is active calculation waits until it removed from the active calculation uuid variable.
-   *
-   * @param requestHash {string}
-   * @return {Promise<string|boolean>} returns uuid of new active calculation or true if waiting for active
-   *         calculation succeed or false if max attempts count exceeded
-   */
-  var _proto2 = ManagerOfRequestsToTheSameResource.prototype;
-  _proto2.startCalculationOrWaitForActiveToFinish = function startCalculationOrWaitForActiveToFinish(requestHash) {
     try {
-      var _exit;
-      var _this3 = this;
-      var _temp3 = _catch$5(function () {
-        var activeCalculationIdForHash = _this3._activeCalculationsIds.get(requestHash);
-        if (activeCalculationIdForHash == null) {
-          var id = uuid.v4();
-          _this3._activeCalculationsIds.set(requestHash, id);
-          _exit = 1;
-          return id;
-        }
-        return Promise.resolve(_this3._waitForCalculationIdToFinish(requestHash, activeCalculationIdForHash, 0)).then(function (_await$_this3$_waitFo) {
-          _exit = 1;
-          return _await$_this3$_waitFo;
-        });
-      }, function (e) {
-        Logger.logError(e, "startCalculationOrWaitForActiveToFinish_" + _this3.bio);
+      var _calculation$endTimes, _calculation$startTim, _calculation$uuid;
+      var calculation = this._calculations[domain].find(function (calculation) {
+        return (calculation == null ? void 0 : calculation.uuid) === uuid;
       });
-      return Promise.resolve(_temp3 && _temp3.then ? _temp3.then(function (_result3) {
-        return _exit ? _result3 : null;
-      }) : _exit ? _temp3 : null);
+      if (calculation) {
+        calculation.endTimestamp = Date.now();
+        calculation.isFiled = isFailed;
+      }
+      var elapsed = ((((_calculation$endTimes = calculation == null ? void 0 : calculation.endTimestamp) != null ? _calculation$endTimes : 0) - ((_calculation$startTim = calculation == null ? void 0 : calculation.startTimestamp) != null ? _calculation$startTim : 0)) / 1000).toFixed(1);
+      Logger.log("endCalculation", elapsed + " ms: " + domain + "." + ((_calculation$uuid = calculation == null ? void 0 : calculation.uuid) != null ? _calculation$uuid : "").slice(0, 7));
+      return calculation;
     } catch (e) {
-      return Promise.reject(e);
+      Logger.logError(e, "endCalculation");
+    }
+  };
+  _proto.isCalculationLate = function isCalculationLate(domain, uuid) {
+    var queue = this._calculations[domain];
+    var analysingCalculation = queue.find(function (item) {
+      return item.uuid === uuid;
+    });
+    return analysingCalculation && !!queue.find(function (calculation) {
+      return calculation.endTimestamp != null && calculation.startTimestamp > analysingCalculation.startTimestamp;
+    });
+  };
+  _proto.printCalculationsWaitingMoreThanSpecifiedSeconds = function printCalculationsWaitingMoreThanSpecifiedSeconds(waitingLastsMs) {
+    var _this = this;
+    if (waitingLastsMs === void 0) {
+      waitingLastsMs = 2000;
     }
-  }
-  /**
-   * Acquires lock to the resource by the provided hash.
-   *
-   * @param requestHash {string}
-   * @return {Promise<{ result: true, lockId: string }|{ result: false }>} result is true if the lock is successfully
-   *         acquired, false if the max allowed time to wait for acquisition expired or any unexpected error occurs
-   *         during the waiting.
-   */
-  ;
-  _proto2.acquireLock = function acquireLock(requestHash) {
-    try {
-      var _this4 = this;
-      return Promise.resolve(_catch$5(function () {
-        var _this4$_nextCalculati;
-        var activeId = _this4._activeCalculationsIds.get(requestHash);
-        var nextId = uuid.v4();
-        if (activeId == null) {
-          _this4._activeCalculationsIds.set(requestHash, nextId);
-          return {
-            result: true,
-            lockId: nextId
-          };
-        }
-        var currentNext = (_this4$_nextCalculati = _this4._nextCalculationIds.get(requestHash)) != null ? _this4$_nextCalculati : [];
-        currentNext.push(nextId);
-        _this4._nextCalculationIds.set(requestHash, currentNext);
-        return Promise.resolve(_this4._waitForCalculationIdToFinish(requestHash, activeId, 0, nextId)).then(function (waitingResult) {
-          return {
-            result: waitingResult,
-            lockId: waitingResult ? nextId : undefined
-          };
-        });
-      }, function (e) {
-        improveAndRethrow(e, "acquireLock");
-      }));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-  /**
-   * Clears active calculation id.
-   * WARNING: if you forget to call this method the start* one will perform maxPollsCount attempts before finishing
-   * @param requestHash {string} hash of request. Helps to distinct the request for the same resource but
-   *        having different request parameters and hold a dedicated calculation id per this hash
-   */
-  ;
-  _proto2.finishActiveCalculation = function finishActiveCalculation(requestHash) {
-    if (requestHash === void 0) {
-      requestHash = "default";
-    }
-    try {
-      var _this$_nextCalculatio;
-      this._activeCalculationsIds["delete"](requestHash);
-      var next = (_this$_nextCalculatio = this._nextCalculationIds.get(requestHash)) != null ? _this$_nextCalculatio : [];
-      if (next.length) {
-        this._activeCalculationsIds.set(requestHash, next[0]);
-        this._nextCalculationIds.set(requestHash, next.slice(1));
-      }
-    } catch (e) {
-      improveAndRethrow(e, "finishActiveCalculation");
-    }
-  };
-  _proto2.finishAllActiveCalculations = function finishAllActiveCalculations(keyPart) {
-    var _this5 = this;
-    if (keyPart === void 0) {
-      keyPart = "";
-    }
-    try {
-      Array.from(this._activeCalculationsIds.keys()).forEach(function (hash) {
-        if (typeof hash === "string" && new RegExp(keyPart).test(hash)) {
-          _this5.finishActiveCalculation(hash);
-        }
-      });
-    } catch (e) {
-      improveAndRethrow(e, "finishAllActiveCalculations");
-    }
-  }
-
-  /**
-   * @param requestHash {string}
-   * @param lockId {string}
-   * @return {boolean}
-   */;
-  _proto2.isTheLockActiveOne = function isTheLockActiveOne(requestHash, lockId) {
-    try {
-      return this._activeCalculationsIds.get(requestHash) === lockId;
-    } catch (e) {
-      improveAndRethrow(e, "isTheLockActiveOne");
-    }
-  }
-
-  /**
-   * @param requestHash {string}
-   * @param activeCalculationId {string|null}
-   * @param [attemptIndex=0] {number}
-   * @param waitForCalculationId {string|null} if you want to wait for an exact id to appear as active then pass this parameter
-   * @return {Promise<boolean>} true
-   *                            - if the given calculation id is no more an active one
-   *                            - or it is equal to waitForCalculationId
-   *                            false
-   *                            - if waiting period exceeds the max allowed waiting time or unexpected error occurs
-   * @private
-   */;
-  _proto2._waitForCalculationIdToFinish = function _waitForCalculationIdToFinish(requestHash, activeCalculationId, attemptIndex, waitForCalculationId) {
-    if (attemptIndex === void 0) {
-      attemptIndex = 0;
-    }
-    if (waitForCalculationId === void 0) {
-      waitForCalculationId = null;
-    }
-    try {
-      var _this6 = this;
-      try {
-        if (attemptIndex + 1 > _this6.maxPollsCount) {
-          // Max number of polls for active calculation id change is achieved. So we return false.
-          return Promise.resolve(false);
-        }
-        var currentId = _this6._activeCalculationsIds.get(requestHash);
-        if (waitForCalculationId == null ? currentId !== activeCalculationId : currentId === waitForCalculationId) {
-          /* We return true depending on the usage of this function:
-           * 1. if there is calculation id that we should wait for to become an active then we return true only
-           *    if this id becomes the active one.
-           *
-           *    Theoretically we can fail to wait for the desired calculation id. This can be caused by wrong use of
-           *    this service or by any other mistakes/errors. But this waiting function will return false anyway if
-           *    the number of polls done exceeds the max allowed.
-           *
-           * 2. if we just wait for the currently active calculation id to be finished then we return true
-           *    when we notice that the current active id differs from the original passed into this function.
-           */
-          return Promise.resolve(true);
-        } else {
-          /* The original calculation id is still the active one, so we are scheduling a new attempt to check
-           * whether the active calculation id changed or not in timeoutDuration milliseconds.
-           */
-          var it = _this6;
-          return Promise.resolve(new Promise(function (resolve, reject) {
-            setTimeout(function () {
-              try {
-                resolve(it._waitForCalculationIdToFinish(requestHash, activeCalculationId, attemptIndex + 1));
-              } catch (e) {
-                reject(e);
-              }
-            }, _this6.timeoutDuration);
-          }));
-        }
-      } catch (e) {
-        Logger.logError(e, "_waitForCalculationIdToFinish", "Failed to wait for active calculation id change.");
-        return Promise.resolve(false);
-      }
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-  return ManagerOfRequestsToTheSameResource;
-}();
-
-// TODO: [refactoring, low] Consider removing this logic task_id=c360f2af75764bde8badd9ff1cc00d48
-var ConcurrentCalculationsMetadataHolder = /*#__PURE__*/function () {
-  function ConcurrentCalculationsMetadataHolder() {
-    this._calculations = {};
-  }
-  var _proto = ConcurrentCalculationsMetadataHolder.prototype;
-  _proto.startCalculation = function startCalculation(domain, calculationsHistoryMaxLength) {
-    if (calculationsHistoryMaxLength === void 0) {
-      calculationsHistoryMaxLength = 100;
-    }
-    if (!this._calculations[domain]) {
-      this._calculations[domain] = [];
-    }
-    if (this._calculations[domain].length > calculationsHistoryMaxLength) {
-      this._calculations[domain] = this._calculations[domain].slice(Math.round(calculationsHistoryMaxLength * 0.2));
-    }
-    var newCalculation = {
-      startTimestamp: Date.now(),
-      endTimestamp: null,
-      uuid: uuid.v4()
-    };
-    this._calculations[domain].push(newCalculation);
-    return newCalculation.uuid;
-  };
-  _proto.endCalculation = function endCalculation(domain, uuid, isFailed) {
-    if (isFailed === void 0) {
-      isFailed = false;
-    }
-    try {
-      var _calculation$endTimes, _calculation$startTim, _calculation$uuid;
-      var calculation = this._calculations[domain].find(function (calculation) {
-        return (calculation == null ? void 0 : calculation.uuid) === uuid;
-      });
-      if (calculation) {
-        calculation.endTimestamp = Date.now();
-        calculation.isFiled = isFailed;
-      }
-      var elapsed = ((((_calculation$endTimes = calculation == null ? void 0 : calculation.endTimestamp) != null ? _calculation$endTimes : 0) - ((_calculation$startTim = calculation == null ? void 0 : calculation.startTimestamp) != null ? _calculation$startTim : 0)) / 1000).toFixed(1);
-      Logger.log("endCalculation", elapsed + " ms: " + domain + "." + ((_calculation$uuid = calculation == null ? void 0 : calculation.uuid) != null ? _calculation$uuid : "").slice(0, 7));
-      return calculation;
-    } catch (e) {
-      Logger.logError(e, "endCalculation");
-    }
-  };
-  _proto.isCalculationLate = function isCalculationLate(domain, uuid) {
-    var queue = this._calculations[domain];
-    var analysingCalculation = queue.find(function (item) {
-      return item.uuid === uuid;
-    });
-    return analysingCalculation && !!queue.find(function (calculation) {
-      return calculation.endTimestamp != null && calculation.startTimestamp > analysingCalculation.startTimestamp;
-    });
-  };
-  _proto.printCalculationsWaitingMoreThanSpecifiedSeconds = function printCalculationsWaitingMoreThanSpecifiedSeconds(waitingLastsMs) {
-    var _this = this;
-    if (waitingLastsMs === void 0) {
-      waitingLastsMs = 2000;
-    }
-    var calculations = Object.keys(this._calculations).map(function (domain) {
-      return _this._calculations[domain].map(function (c) {
-        return _extends({}, c, {
-          domain: domain
-        });
-      });
-    }).flat().filter(function (c) {
-      return c.endTimestamp === null && Date.now() - c.startTimestamp > waitingLastsMs;
-    });
-    Logger.log("printCalculationsWaitingMoreThanSpecifiedSeconds", "Calculations waiting more than " + (waitingLastsMs / 1000).toFixed(1) + "s:\n" + calculations.map(function (c) {
-      return c.domain + "." + c.uuid.slice(0, 8) + ": " + (Date.now() - c.startTimestamp) + "\n";
-    }));
-  };
-  return ConcurrentCalculationsMetadataHolder;
-}();
-var concurrentCalculationsMetadataHolder = new ConcurrentCalculationsMetadataHolder();
-
-var ExternalServicesStatsCollector = /*#__PURE__*/function () {
-  function ExternalServicesStatsCollector() {
-    this.stats = new Map();
+    var calculations = Object.keys(this._calculations).map(function (domain) {
+      return _this._calculations[domain].map(function (c) {
+        return _extends({}, c, {
+          domain: domain
+        });
+      });
+    }).flat().filter(function (c) {
+      return c.endTimestamp === null && Date.now() - c.startTimestamp > waitingLastsMs;
+    });
+    Logger.log("printCalculationsWaitingMoreThanSpecifiedSeconds", "Calculations waiting more than " + (waitingLastsMs / 1000).toFixed(1) + "s:\n" + calculations.map(function (c) {
+      return c.domain + "." + c.uuid.slice(0, 8) + ": " + (Date.now() - c.startTimestamp) + "\n";
+    }));
+  };
+  return ConcurrentCalculationsMetadataHolder;
+}();
+var concurrentCalculationsMetadataHolder = new ConcurrentCalculationsMetadataHolder();
+
+var ExternalServicesStatsCollector = /*#__PURE__*/function () {
+  function ExternalServicesStatsCollector() {
+    this.stats = new Map();
   }
   var _proto = ExternalServicesStatsCollector.prototype;
   _proto.externalServiceFailed = function externalServiceFailed(serviceUrl, message) {
@@ -3675,7 +3220,7 @@ var ExternalServicesStatsCollector = /*#__PURE__*/function () {
  * improve the reliability of a data retrieval.
  */
 
-function _catch$4(body, recover) {
+function _catch$6(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -3686,21 +3231,21 @@ function _catch$4(body, recover) {
   }
   return result;
 }
-function _settle$1(pact, state, value) {
+function _settle$2(pact, state, value) {
   if (!pact.s) {
-    if (value instanceof _Pact$1) {
+    if (value instanceof _Pact$2) {
       if (value.s) {
         if (state & 1) {
           state = value.s;
         }
         value = value.v;
       } else {
-        value.o = _settle$1.bind(null, pact, state);
+        value.o = _settle$2.bind(null, pact, state);
         return;
       }
     }
     if (value && value.then) {
-      value.then(_settle$1.bind(null, pact, state), _settle$1.bind(null, pact, 2));
+      value.then(_settle$2.bind(null, pact, state), _settle$2.bind(null, pact, 2));
       return;
     }
     pact.s = state;
@@ -3711,7 +3256,7 @@ function _settle$1(pact, state, value) {
     }
   }
 }
-var _Pact$1 = /*#__PURE__*/function () {
+var _Pact$2 = /*#__PURE__*/function () {
   function _Pact() {}
   _Pact.prototype.then = function (onFulfilled, onRejected) {
     var result = new _Pact();
@@ -3720,9 +3265,9 @@ var _Pact$1 = /*#__PURE__*/function () {
       var callback = state & 1 ? onFulfilled : onRejected;
       if (callback) {
         try {
-          _settle$1(result, 1, callback(this.v));
+          _settle$2(result, 1, callback(this.v));
         } catch (e) {
-          _settle$1(result, 2, e);
+          _settle$2(result, 2, e);
         }
         return result;
       } else {
@@ -3733,28 +3278,28 @@ var _Pact$1 = /*#__PURE__*/function () {
       try {
         var value = _this.v;
         if (_this.s & 1) {
-          _settle$1(result, 1, onFulfilled ? onFulfilled(value) : value);
+          _settle$2(result, 1, onFulfilled ? onFulfilled(value) : value);
         } else if (onRejected) {
-          _settle$1(result, 1, onRejected(value));
+          _settle$2(result, 1, onRejected(value));
         } else {
-          _settle$1(result, 2, value);
+          _settle$2(result, 2, value);
         }
       } catch (e) {
-        _settle$1(result, 2, e);
+        _settle$2(result, 2, e);
       }
     };
     return result;
   };
   return _Pact;
 }();
-function _isSettledPact$1(thenable) {
-  return thenable instanceof _Pact$1 && thenable.s & 1;
-}
-function _for(test, update, body) {
+function _isSettledPact$2(thenable) {
+  return thenable instanceof _Pact$2 && thenable.s & 1;
+}
+function _for$1(test, update, body) {
   var stage;
   for (;;) {
     var shouldContinue = test();
-    if (_isSettledPact$1(shouldContinue)) {
+    if (_isSettledPact$2(shouldContinue)) {
       shouldContinue = shouldContinue.v;
     }
     if (!shouldContinue) {
@@ -3766,7 +3311,7 @@ function _for(test, update, body) {
     }
     var result = body();
     if (result && result.then) {
-      if (_isSettledPact$1(result)) {
+      if (_isSettledPact$2(result)) {
         result = result.s;
       } else {
         stage = 1;
@@ -3775,14 +3320,14 @@ function _for(test, update, body) {
     }
     if (update) {
       var updateValue = update();
-      if (updateValue && updateValue.then && !_isSettledPact$1(updateValue)) {
+      if (updateValue && updateValue.then && !_isSettledPact$2(updateValue)) {
         stage = 2;
         break;
       }
     }
   }
-  var pact = new _Pact$1();
-  var reject = _settle$1.bind(null, pact, 2);
+  var pact = new _Pact$2();
+  var reject = _settle$2.bind(null, pact, 2);
   (stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
   return pact;
   function _resumeAfterBody(value) {
@@ -3790,14 +3335,14 @@ function _for(test, update, body) {
     do {
       if (update) {
         updateValue = update();
-        if (updateValue && updateValue.then && !_isSettledPact$1(updateValue)) {
+        if (updateValue && updateValue.then && !_isSettledPact$2(updateValue)) {
           updateValue.then(_resumeAfterUpdate).then(void 0, reject);
           return;
         }
       }
       shouldContinue = test();
-      if (!shouldContinue || _isSettledPact$1(shouldContinue) && !shouldContinue.v) {
-        _settle$1(pact, 1, result);
+      if (!shouldContinue || _isSettledPact$2(shouldContinue) && !shouldContinue.v) {
+        _settle$2(pact, 1, result);
         return;
       }
       if (shouldContinue.then) {
@@ -3805,7 +3350,7 @@ function _for(test, update, body) {
         return;
       }
       result = body();
-      if (_isSettledPact$1(result)) {
+      if (_isSettledPact$2(result)) {
         result = result.v;
       }
     } while (!result || !result.then);
@@ -3820,7 +3365,7 @@ function _for(test, update, body) {
         _resumeAfterBody(result);
       }
     } else {
-      _settle$1(pact, 1, result);
+      _settle$2(pact, 1, result);
     }
   }
   function _resumeAfterUpdate() {
@@ -3831,7 +3376,7 @@ function _for(test, update, body) {
         _resumeAfterTest(shouldContinue);
       }
     } else {
-      _settle$1(pact, 1, result);
+      _settle$2(pact, 1, result);
     }
   }
 }
@@ -3851,7 +3396,7 @@ function _do(body, test) {
   do {
     var result = body();
     if (result && result.then) {
-      if (_isSettledPact$1(result)) {
+      if (_isSettledPact$2(result)) {
         result = result.v;
       } else {
         awaitBody = true;
@@ -3859,22 +3404,22 @@ function _do(body, test) {
       }
     }
     var shouldContinue = test();
-    if (_isSettledPact$1(shouldContinue)) {
+    if (_isSettledPact$2(shouldContinue)) {
       shouldContinue = shouldContinue.v;
     }
     if (!shouldContinue) {
       return result;
     }
   } while (!shouldContinue.then);
-  var pact = new _Pact$1();
-  var reject = _settle$1.bind(null, pact, 2);
+  var pact = new _Pact$2();
+  var reject = _settle$2.bind(null, pact, 2);
   (awaitBody ? result.then(_resumeAfterBody) : shouldContinue.then(_resumeAfterTest)).then(void 0, reject);
   return pact;
   function _resumeAfterBody(value) {
     result = value;
     for (;;) {
       shouldContinue = test();
-      if (_isSettledPact$1(shouldContinue)) {
+      if (_isSettledPact$2(shouldContinue)) {
         shouldContinue = shouldContinue.v;
       }
       if (!shouldContinue) {
@@ -3886,7 +3431,7 @@ function _do(body, test) {
       }
       result = body();
       if (result && result.then) {
-        if (_isSettledPact$1(result)) {
+        if (_isSettledPact$2(result)) {
           result = result.v;
         } else {
           result.then(_resumeAfterBody).then(void 0, reject);
@@ -3894,14 +3439,14 @@ function _do(body, test) {
         }
       }
     }
-    _settle$1(pact, 1, result);
+    _settle$2(pact, 1, result);
   }
   function _resumeAfterTest(shouldContinue) {
     if (shouldContinue) {
       do {
         result = body();
         if (result && result.then) {
-          if (_isSettledPact$1(result)) {
+          if (_isSettledPact$2(result)) {
             result = result.v;
           } else {
             result.then(_resumeAfterBody).then(void 0, reject);
@@ -3909,381 +3454,1069 @@ function _do(body, test) {
           }
         }
         shouldContinue = test();
-        if (_isSettledPact$1(shouldContinue)) {
+        if (_isSettledPact$2(shouldContinue)) {
           shouldContinue = shouldContinue.v;
         }
         if (!shouldContinue) {
-          _settle$1(pact, 1, result);
+          _settle$2(pact, 1, result);
           return;
         }
       } while (!shouldContinue.then);
       shouldContinue.then(_resumeAfterTest).then(void 0, reject);
     } else {
-      _settle$1(pact, 1, result);
+      _settle$2(pact, 1, result);
+    }
+  }
+}
+function _forTo$1(array, body, check) {
+  var i = -1,
+    pact,
+    reject;
+  function _cycle(result) {
+    try {
+      while (++i < array.length && (!check || !check())) {
+        result = body(i);
+        if (result && result.then) {
+          if (_isSettledPact$2(result)) {
+            result = result.v;
+          } else {
+            result.then(_cycle, reject || (reject = _settle$2.bind(null, pact = new _Pact$2(), 2)));
+            return;
+          }
+        }
+      }
+      if (pact) {
+        _settle$2(pact, 1, result);
+      } else {
+        pact = result;
+      }
+    } catch (e) {
+      _settle$2(pact || (pact = new _Pact$2()), 2, e);
+    }
+  }
+  _cycle();
+  return pact;
+}
+var RobustExternalAPICallerService = /*#__PURE__*/function () {
+  RobustExternalAPICallerService.getStats = function getStats() {
+    return this.statsCollector.getStats();
+  }
+
+  /**
+   * @param bio {string} service name for logging
+   * @param providersData {ExternalApiProvider[]} array of providers
+   * @param [logger] {function} function to be used for logging
+   */;
+  function RobustExternalAPICallerService(bio, providersData, logger) {
+    providersData.forEach(function (provider) {
+      if (!provider.endpoint && provider.endpoint !== "" || !provider.httpMethod) {
+        throw new Error("Wrong format of providers data for: " + JSON.stringify(provider));
+      }
+    });
+
+    // We add niceFactor - just number to order the providers array by. It is helpful to call
+    // less robust APIs only if more robust fails
+    this.providers = providersData;
+    providersData.forEach(function (provider) {
+      return provider.resetNiceFactor();
+    });
+    this.bio = bio;
+    this._logger = Logger.logError;
+  }
+  var _proto = RobustExternalAPICallerService.prototype;
+  /**
+   * Performs data retrieval from external APIs. Tries providers till the data is retrieved.
+   *
+   * @param parametersValues {array} array of values of the parameters for URL query string [and/or body]
+   * @param timeoutMS {number} http timeout to wait for response. If provider has its specific timeout value then it is used
+   * @param [cancelToken] {object|undefined} axios token to force-cancel requests from high-level code
+   * @param [attemptsCount] {number|undefined} number of attempts to be performed
+   * @param [doNotFailForNowData] {boolean|undefined} pass true if you do not want us to throw an error if we retrieved null data from all the providers
+   * @return {Promise<any>} resolving to retrieved data (or array of results if specific provider requires
+   *         several requests. NOTE: we flatten nested arrays - results of each separate request done for the specific provider)
+   * @throws Error if requests to all providers are failed
+   */
+  _proto.callExternalAPI = function callExternalAPI(parametersValues, timeoutMS, cancelToken, attemptsCount, doNotFailForNowData) {
+    if (parametersValues === void 0) {
+      parametersValues = [];
+    }
+    if (timeoutMS === void 0) {
+      timeoutMS = 3500;
+    }
+    if (cancelToken === void 0) {
+      cancelToken = null;
+    }
+    if (attemptsCount === void 0) {
+      attemptsCount = 1;
+    }
+    if (doNotFailForNowData === void 0) {
+      doNotFailForNowData = false;
+    }
+    try {
+      var _this = this;
+      var result;
+      var calculationUuid = concurrentCalculationsMetadataHolder.startCalculation(_this.bio);
+      return Promise.resolve(_finallyRethrows$1(function () {
+        return _catch$6(function () {
+          function _temp5() {
+            var _result2, _result3;
+            if (((_result2 = result) == null ? void 0 : _result2.data) == null) {
+              // TODO: [feature, moderate] looks like we should not fail for null data as it is strange - the provider will fail when processing data internally
+              var error = new Error("Failed to retrieve data. It means all attempts have been failed. DEV: add more attempts to this data retrieval");
+              if (!doNotFailForNowData) {
+                throw error;
+              } else {
+                _this._logger(error, _this.bio + ".callExternalAPI");
+              }
+            }
+            return (_result3 = result) == null ? void 0 : _result3.data;
+          }
+          var i = 0;
+          var _temp4 = _for$1(function () {
+            var _result4, _result5;
+            return (i < attemptsCount || !!((_result4 = result) != null && _result4.shouldBeForceRetried)) && ((_result5 = result) == null ? void 0 : _result5.data) == null;
+          }, function () {
+            return ++i;
+          }, function () {
+            /**
+             * We use rpsFactor to improve re-attempting to call the providers if the last attempt resulted with
+             * the fail due to abused RPSes of some (most part of) providers.
+             * The _performCallAttempt in such a case will return increased rpsFactor inside the result object.
+             */
+            var rpsFactor = result ? result.rpsFactor : RobustExternalAPICallerService.defaultRPSFactor;
+            result = null;
+            var _temp3 = _catch$6(function () {
+              function _temp2() {
+                var _result$errors;
+                if ((_result$errors = result.errors) != null && _result$errors.length) {
+                  var errors = result.errors;
+                  _this._logger(new Error("Failed at attempt " + i + ". " + errors.length + " errors. Messages: " + safeStringify(errors.map(function (error) {
+                    return error.message;
+                  })) + ": " + safeStringify(errors) + "."), _this.bio + ".callExternalAPI", "", true);
+                }
+              }
+              var _temp = function (_result6) {
+                if (i === 0 && !((_result6 = result) != null && _result6.shouldBeForceRetried)) {
+                  return Promise.resolve(_this._performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData)).then(function (_this$_performCallAtt) {
+                    result = _this$_performCallAtt;
+                  });
+                } else {
+                  var maxRps = Math.max.apply(Math, _this.providers.map(function (provider) {
+                    var _provider$getRps;
+                    return (_provider$getRps = provider.getRps()) != null ? _provider$getRps : 0;
+                  }));
+                  var waitingTimeMs = maxRps ? 1000 / (maxRps / rpsFactor) : 0;
+                  return Promise.resolve(new Promise(function (resolve, reject) {
+                    setTimeout(function () {
+                      try {
+                        var _temp6 = _catch$6(function () {
+                          return Promise.resolve(_this._performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData)).then(function (_this$_performCallAtt2) {
+                            resolve(_this$_performCallAtt2);
+                          });
+                        }, function (e) {
+                          reject(e);
+                        });
+                        return Promise.resolve(_temp6 && _temp6.then ? _temp6.then(function () {}) : void 0);
+                      } catch (e) {
+                        return Promise.reject(e);
+                      }
+                    }, waitingTimeMs);
+                  })).then(function (_Promise) {
+                    result = _Promise;
+                  });
+                }
+              }();
+              return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+            }, function (e) {
+              _this._logger(e, _this.bio + ".callExternalAPI", "Failed to perform external providers calling");
+            });
+            if (_temp3 && _temp3.then) return _temp3.then(function () {});
+          });
+          return _temp4 && _temp4.then ? _temp4.then(_temp5) : _temp5(_temp4);
+        }, function (e) {
+          improveAndRethrow(e, _this.bio + ".callExternalAPI");
+        });
+      }, function (_wasThrown, _result) {
+        concurrentCalculationsMetadataHolder.endCalculation(_this.bio, calculationUuid);
+        if (_wasThrown) throw _result;
+        return _result;
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto._performCallAttempt = function _performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData) {
+    try {
+      var _temp15 = function _temp15() {
+        var _data;
+        // If we are declining more than 50% of providers (by exceeding RPS) then we note that it better to retry the whole process of providers requesting
+        var shouldBeForceRetried = data == null && countOfRequestsDeclinedByRps > Math.floor(providers.length * 0.5);
+        var rpsMultiplier = shouldBeForceRetried ? RobustExternalAPICallerService.rpsMultiplier : 1;
+        return {
+          data: (_data = data) != null ? _data : null,
+          shouldBeForceRetried: shouldBeForceRetried,
+          rpsFactor: rpsFactor * rpsMultiplier,
+          errors: errors
+        };
+      };
+      var _this2 = this;
+      var providers = _this2._reorderProvidersByNiceFactor();
+      var data = undefined,
+        providerIndex = 0,
+        countOfRequestsDeclinedByRps = 0,
+        errors = [];
+      var _temp14 = _for$1(function () {
+        return !data && providerIndex < providers.length;
+      }, void 0, function () {
+        var provider = providers[providerIndex];
+        if (provider.isRpsExceeded()) {
+          /**
+           * Current provider's RPS is exceeded, so we try next provider. Also, we count such cases to make
+           * a decision about the force-retry need.
+           */
+          ++providerIndex;
+          ++countOfRequestsDeclinedByRps;
+          return;
+        }
+        var _temp13 = _finallyRethrows$1(function () {
+          return _catch$6(function () {
+            var _provider$specificHea;
+            function _temp12() {
+              if (iterationsData.length) {
+                if (httpMethods.length > 1) {
+                  data = provider.incorporateIterationsData(iterationsData);
+                } else {
+                  data = iterationsData[0];
+                }
+              } else if (!doNotFailForNowData) {
+                RobustExternalAPICallerService.statsCollector.externalServiceFailed(provider.getApiGroupId(), "Response data was null for some reason");
+                punishProvider(provider);
+              }
+            }
+            var axiosConfig = _extends({}, cancelToken ? {
+              cancelToken: cancelToken
+            } : {}, {
+              timeout: provider.timeout || timeoutMS,
+              headers: (_provider$specificHea = provider.specificHeaders) != null ? _provider$specificHea : {}
+            });
+            var httpMethods = Array.isArray(provider.httpMethod) ? provider.httpMethod : [provider.httpMethod];
+            var iterationsData = [];
+            var _temp11 = _forTo$1(httpMethods, function (subRequestIndex) {
+              function _temp10() {
+                var responsesDataForPages = responsesForPages.map(function (response) {
+                  return provider.getDataByResponse(response, parametersValues, subRequestIndex, iterationsData);
+                });
+                var allData = responsesDataForPages;
+                if (Array.isArray(responsesDataForPages[0])) {
+                  allData = responsesDataForPages.flat();
+                } else if (responsesDataForPages.length === 1) {
+                  allData = responsesDataForPages[0];
+                }
+                iterationsData.push(allData);
+              }
+              var query = provider.composeQueryString(parametersValues, subRequestIndex);
+              var endpoint = "" + provider.endpoint + query;
+              var axiosParams = [endpoint, axiosConfig];
+              if (["post", "put", "patch"].find(function (method) {
+                return method === httpMethods[subRequestIndex];
+              })) {
+                var _provider$composeBody;
+                var body = (_provider$composeBody = provider.composeBody(parametersValues, subRequestIndex)) != null ? _provider$composeBody : null;
+                axiosParams.splice(1, 0, body);
+              }
+              var pageNumber = 0;
+              var responsesForPages = [];
+              var hasNextPage = provider.doesSupportPagination();
+              var _temp9 = _do(function () {
+                function _temp8() {
+                  if (hasNextPage) {
+                    hasNextPage = !provider.checkWhetherResponseIsForLastPage(responsesForPages[pageNumber - 1], responsesForPages[pageNumber], pageNumber, subRequestIndex);
+                  }
+                  pageNumber++;
+                }
+                var _temp7 = function () {
+                  if (subRequestIndex === 0 && pageNumber === 0) {
+                    provider.actualizeLastCalledTimestamp();
+                    return Promise.resolve(AxiosAdapter.call.apply(AxiosAdapter, [httpMethods[subRequestIndex]].concat(axiosParams))).then(function (_AxiosAdapter$call) {
+                      responsesForPages[pageNumber] = _AxiosAdapter$call;
+                      RobustExternalAPICallerService.statsCollector.externalServiceCalledWithoutError(provider.getApiGroupId());
+                    });
+                  } else {
+                    if (pageNumber > 0) {
+                      var actualizedParams = provider.changeQueryParametersForPageNumber(parametersValues, responsesForPages[pageNumber - 1], pageNumber, subRequestIndex);
+                      var _query = provider.composeQueryString(actualizedParams, subRequestIndex);
+                      axiosParams[0] = "" + provider.endpoint + _query;
+                    }
+                    /**
+                     * For second and more request we postpone each request to not exceed RPS
+                     * of current provider. We use rpsFactor to dynamically increase the rps to avoid
+                     * too frequent calls if we continue failing to retrieve the data due to RPS exceeding.
+                     * TODO: [dev] test RPS factor logic (units or integration)
+                     */
+
+                    var waitingTimeMS = provider.getRps() ? 1000 / (provider.getRps() / rpsFactor) : 0;
+                    var postponeUntilRpsExceeded = function postponeUntilRpsExceeded(recursionLevel) {
+                      if (recursionLevel === void 0) {
+                        recursionLevel = 0;
+                      }
+                      try {
+                        return Promise.resolve(postponeExecution(function () {
+                          try {
+                            var _temp17 = function _temp17(_result8) {
+                              if (_exit) return _result8;
+                              provider.actualizeLastCalledTimestamp();
+                              return Promise.resolve(AxiosAdapter.call.apply(AxiosAdapter, [httpMethods[subRequestIndex]].concat(axiosParams)));
+                            };
+                            var _exit;
+                            var maxCountOfPostponingAttempts = 2;
+                            var _temp16 = function () {
+                              if (provider.isRpsExceeded() && recursionLevel < maxCountOfPostponingAttempts) {
+                                return Promise.resolve(postponeUntilRpsExceeded(recursionLevel + 1)).then(function (_await$postponeUntilR) {
+                                  _exit = 1;
+                                  return _await$postponeUntilR;
+                                });
+                              }
+                            }();
+                            return Promise.resolve(_temp16 && _temp16.then ? _temp16.then(_temp17) : _temp17(_temp16));
+                          } catch (e) {
+                            return Promise.reject(e);
+                          }
+                        }, waitingTimeMS));
+                      } catch (e) {
+                        return Promise.reject(e);
+                      }
+                    };
+                    return Promise.resolve(postponeUntilRpsExceeded()).then(function (_postponeUntilRpsExce) {
+                      responsesForPages[pageNumber] = _postponeUntilRpsExce;
+                    });
+                  }
+                }();
+                return _temp7 && _temp7.then ? _temp7.then(_temp8) : _temp8(_temp7);
+              }, function () {
+                return !!hasNextPage;
+              });
+              return _temp9 && _temp9.then ? _temp9.then(_temp10) : _temp10(_temp9);
+            });
+            return _temp11 && _temp11.then ? _temp11.then(_temp12) : _temp12(_temp11);
+          }, function (e) {
+            punishProvider(provider);
+            RobustExternalAPICallerService.statsCollector.externalServiceFailed(provider.getApiGroupId(), e == null ? void 0 : e.message);
+            errors.push(e);
+          });
+        }, function (_wasThrown2, _result7) {
+          providerIndex++;
+          if (_wasThrown2) throw _result7;
+          return _result7;
+        });
+        if (_temp13 && _temp13.then) return _temp13.then(function () {});
+      });
+      return Promise.resolve(_temp14 && _temp14.then ? _temp14.then(_temp15) : _temp15(_temp14));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto._reorderProvidersByNiceFactor = function _reorderProvidersByNiceFactor() {
+    var providersCopy = [].concat(this.providers);
+    return providersCopy.sort(function (p1, p2) {
+      return p2.niceFactor - p1.niceFactor;
+    });
+  };
+  return RobustExternalAPICallerService;
+}();
+RobustExternalAPICallerService.statsCollector = new ExternalServicesStatsCollector();
+RobustExternalAPICallerService.defaultRPSFactor = 1;
+RobustExternalAPICallerService.rpsMultiplier = 1.05;
+function punishProvider(provider) {
+  provider.niceFactor = provider.niceFactor - 1;
+}
+
+/**
+ * This util helps to avoid duplicated calls to a shared resource.
+ * It tracks is there currently active calculation for the specific cache id and make all other requests
+ * with the same cache id waiting for this active calculation to be finished. When the calculation ends
+ * the resolver allows all the waiting requesters to get the data from cache and start their own calculations.
+ *
+ * This class should be instantiated inside some other service where you need to request some resource concurrently.
+ * Rules:
+ * 1. When you need to make a request inside your main service call 'getCachedOrWaitForCachedOrAcquireLock'
+ *    on the instance of this class and await for the result. If the flag allowing to start calculation is true
+ *    then you can request data inside your main service. Otherwise you should use the cached data as an another
+ *    requester just finished the most resent requesting and there is actual data in the cache that
+ *    is returned to you here.
+ * 1.1 Also you can acquire a lock directly if you don't want to get cached data. Use the corresponding method 'acquireLock'.
+ *
+ * 2. If you start requesting (when you successfully acquired the lock) then after receiving the result of your
+ *    requesting you should call the 'saveCachedData' so the retrieved data will appear in the cache.
+ *
+ * 3. If you successfully acquired the lock then you should after calling the 'saveCachedData' call
+ *    the 'releaseLock' - this is mandatory to release the lock and allow other requesters to perform their requests.
+ *    WARNING: If for any reason you forget to call this method then this class instance will wait perpetually for
+ *    the lock releasing and all your attempts to request the data will constantly fail. So usually call it
+ *    inside the 'finally' block.
+ *
+ * TODO: [tests, critical++] add unit tests - massively used logic and can produce sophisticated concurrency bugs
+ */
+
+function _settle$1(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact$1) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = _settle$1.bind(null, pact, state);
+        return;
+      }
+    }
+    if (value && value.then) {
+      value.then(_settle$1.bind(null, pact, state), _settle$1.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    const observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+
+/**
+ * Util class to control access to a resource when it can be called in parallel for the same result.
+ * (E.g. getting today coins-fiat rates from some API).
+ */
+var _Pact$1 = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          _settle$1(result, 1, callback(this.v));
+        } catch (e) {
+          _settle$1(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
+      }
+    }
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+        if (_this.s & 1) {
+          _settle$1(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          _settle$1(result, 1, onRejected(value));
+        } else {
+          _settle$1(result, 2, value);
+        }
+      } catch (e) {
+        _settle$1(result, 2, e);
+      }
+    };
+    return result;
+  };
+  return _Pact;
+}();
+function _isSettledPact$1(thenable) {
+  return thenable instanceof _Pact$1 && thenable.s & 1;
+}
+function _for(test, update, body) {
+  var stage;
+  for (;;) {
+    var shouldContinue = test();
+    if (_isSettledPact$1(shouldContinue)) {
+      shouldContinue = shouldContinue.v;
+    }
+    if (!shouldContinue) {
+      return result;
+    }
+    if (shouldContinue.then) {
+      stage = 0;
+      break;
+    }
+    var result = body();
+    if (result && result.then) {
+      if (_isSettledPact$1(result)) {
+        result = result.s;
+      } else {
+        stage = 1;
+        break;
+      }
+    }
+    if (update) {
+      var updateValue = update();
+      if (updateValue && updateValue.then && !_isSettledPact$1(updateValue)) {
+        stage = 2;
+        break;
+      }
+    }
+  }
+  var pact = new _Pact$1();
+  var reject = _settle$1.bind(null, pact, 2);
+  (stage === 0 ? shouldContinue.then(_resumeAfterTest) : stage === 1 ? result.then(_resumeAfterBody) : updateValue.then(_resumeAfterUpdate)).then(void 0, reject);
+  return pact;
+  function _resumeAfterBody(value) {
+    result = value;
+    do {
+      if (update) {
+        updateValue = update();
+        if (updateValue && updateValue.then && !_isSettledPact$1(updateValue)) {
+          updateValue.then(_resumeAfterUpdate).then(void 0, reject);
+          return;
+        }
+      }
+      shouldContinue = test();
+      if (!shouldContinue || _isSettledPact$1(shouldContinue) && !shouldContinue.v) {
+        _settle$1(pact, 1, result);
+        return;
+      }
+      if (shouldContinue.then) {
+        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+        return;
+      }
+      result = body();
+      if (_isSettledPact$1(result)) {
+        result = result.v;
+      }
+    } while (!result || !result.then);
+    result.then(_resumeAfterBody).then(void 0, reject);
+  }
+  function _resumeAfterTest(shouldContinue) {
+    if (shouldContinue) {
+      result = body();
+      if (result && result.then) {
+        result.then(_resumeAfterBody).then(void 0, reject);
+      } else {
+        _resumeAfterBody(result);
+      }
+    } else {
+      _settle$1(pact, 1, result);
+    }
+  }
+  function _resumeAfterUpdate() {
+    if (shouldContinue = test()) {
+      if (shouldContinue.then) {
+        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+      } else {
+        _resumeAfterTest(shouldContinue);
+      }
+    } else {
+      _settle$1(pact, 1, result);
+    }
+  }
+}
+function _catch$5(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+var CacheAndConcurrentRequestsResolver = /*#__PURE__*/function () {
+  /**
+   * @param bio {string} unique identifier for the exact service
+   * @param cache {Cache} cache
+   * @param cacheTtl {number|null} time to live for cache ms. 0 or null means the cache cannot expire
+   * @param [maxCallAttemptsToWaitForAlreadyRunningRequest=100] {number} number of request allowed to do waiting for
+   *        result before we fail the original request. Use custom value only if you need to make the attempts count
+   *        and polling interval changes.
+   * @param [timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished=1000] {number}
+   *        timeout ms for polling for a result. if you change maxCallAttemptsToWaitForAlreadyRunningRequest
+   *        then this parameter maybe also require the custom value.
+   * @param [removeExpiredCacheAutomatically=true] {boolean}
+   */
+  function CacheAndConcurrentRequestsResolver(bio, cache, cacheTtl, removeExpiredCacheAutomatically, maxCallAttemptsToWaitForAlreadyRunningRequest, timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished) {
+    if (removeExpiredCacheAutomatically === void 0) {
+      removeExpiredCacheAutomatically = true;
+    }
+    if (maxCallAttemptsToWaitForAlreadyRunningRequest === void 0) {
+      maxCallAttemptsToWaitForAlreadyRunningRequest = 100;
+    }
+    if (timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished === void 0) {
+      timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished = 1000;
+    }
+    if (cacheTtl != null && cacheTtl < timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished * 2) {
+      /*
+       * During the lifetime of this service e.g. if the data is being retrieved slowly we can get
+       * RACE CONDITION when we constantly retrieve data and during retrieval it is expired, so we are trying
+       * to retrieve it again and again.
+       * We have a protection mechanism that we will wait no more than
+       * maxCallAttemptsToWaitForAlreadyRunningRequest * timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished
+       * but this additional check is aimed to reduce potential loading time for some requests.
+       */
+      throw new Error("DEV: Wrong parameters passed to construct " + bio + " - TTL " + cacheTtl + " should be 2 times greater than " + timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished);
+    }
+    this._bio = bio;
+    this._cache = cache;
+    this._cacheTtlMs = cacheTtl != null ? cacheTtl : null;
+    this._maxExecutionTimeMs = maxCallAttemptsToWaitForAlreadyRunningRequest * timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished;
+    this._removeExpiredCacheAutomatically = removeExpiredCacheAutomatically;
+    this._requestsManager = new ManagerOfRequestsToTheSameResource(bio, maxCallAttemptsToWaitForAlreadyRunningRequest, timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished);
+  }
+
+  /**
+   * When using this service this is the major method you should call to get data by cache id.
+   * This method checks is there cached data and ether
+   * - returns you flag that you can start requesting data from the shared resource
+   * - or if there is already started calculation waits until it is finished (removed from this service)
+   *   and returns you the retrieved data
+   * - or just returns you the cached data
+   *
+   * 'canStartDataRetrieval' equal true means that the lock was acquired, and you should manually call 'saveCachedData'
+   * if needed and then 'releaseLock' to mark this calculation as finished so other
+   * requesters can take their share of the resource.
+   *
+   * @param cacheId {string}
+   * @return {Promise<({
+   *             canStartDataRetrieval: true,
+   *             cachedData: any,
+   *             lockId: string
+   *         }|{
+   *             canStartDataRetrieval: false,
+   *             cachedData: any
+   *         })>}
+   */
+  var _proto = CacheAndConcurrentRequestsResolver.prototype;
+  _proto.getCachedOrWaitForCachedOrAcquireLock = function getCachedOrWaitForCachedOrAcquireLock(cacheId) {
+    try {
+      var _this = this;
+      return Promise.resolve(_catch$5(function () {
+        function _temp2() {
+          var _cached, _cached2;
+          return calculationId ? {
+            canStartDataRetrieval: true,
+            cachedData: (_cached = cached) != null ? _cached : cachedDataBackupIsPresentButExpired,
+            lockId: calculationId
+          } : {
+            canStartDataRetrieval: false,
+            cachedData: (_cached2 = cached) != null ? _cached2 : cachedDataBackupIsPresentButExpired
+          };
+        }
+        var startedAtTimestamp = Date.now();
+        var cached = _this._cache.get(cacheId);
+        var cachedDataBackupIsPresentButExpired = null;
+        if (cached != null && !_this._removeExpiredCacheAutomatically) {
+          var lastUpdateTimestamp = _this._cache.getLastUpdateTimestamp(cacheId);
+          if ((lastUpdateTimestamp != null ? lastUpdateTimestamp : 0) + _this._cacheTtlMs < Date.now()) {
+            /*
+             * Here we are manually clearing 'cached' value retrieved from cache to force the data loading.
+             * But we save its value first to the backup variable to be able to return this value if ongoing
+             * requesting fails.
+             */
+            cachedDataBackupIsPresentButExpired = cached;
+            cached = null;
+          }
+        }
+        var calculationId = null;
+        var isRetrievedCacheExpired = true;
+        var isWaitingForActiveCalculationSucceeded;
+        var weStillHaveSomeTimeToProceedExecution = true;
+        var _temp = _for(function () {
+          return calculationId == null && cached == null && !!isRetrievedCacheExpired && !!weStillHaveSomeTimeToProceedExecution;
+        }, void 0, function () {
+          return Promise.resolve(_this._requestsManager.startCalculationOrWaitForActiveToFinish(cacheId)).then(function (result) {
+            calculationId = typeof result === "string" ? result : null;
+            isWaitingForActiveCalculationSucceeded = typeof result === "boolean" ? result : null;
+            cached = _this._cache.get(cacheId);
+            isRetrievedCacheExpired = isWaitingForActiveCalculationSucceeded && cached == null;
+            weStillHaveSomeTimeToProceedExecution = Date.now() - startedAtTimestamp < _this._maxExecutionTimeMs;
+          });
+        });
+        return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
+      }, function (e) {
+        improveAndRethrow(e, _this._bio + ".getCachedOrWaitForCachedOrAcquireLock");
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Returns just the current cache value for the given id.
+   * Doesn't wait for the active calculation, doesn't acquire lock, just retrieves the current cache as it is.
+   *
+   * @param cacheId {string}
+   * @return {any}
+   */
+  ;
+  _proto.getCached = function getCached(cacheId) {
+    try {
+      return this._cache.get(cacheId);
+    } catch (e) {
+      improveAndRethrow(e, "getCached");
+    }
+  };
+  _proto._getTtl = function _getTtl() {
+    return this._removeExpiredCacheAutomatically ? this._cacheTtlMs : null;
+  }
+
+  /**
+   * Directly acquires the lock despite on cached data availability.
+   * So if this method returns result === true you can start the data retrieval.
+   *
+   * @param cacheId {string}
+   * @return {Promise<{ result: true, lockId: string }|{ result: false }>}
+   */;
+  _proto.acquireLock = function acquireLock(cacheId) {
+    try {
+      var _this2 = this;
+      return Promise.resolve(_catch$5(function () {
+        return Promise.resolve(_this2._requestsManager.acquireLock(cacheId));
+      }, function (e) {
+        improveAndRethrow(e, "acquireLock");
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * This method should be called only if you acquired a lock successfully.
+   *
+   * If the current lock id is not equal to the passed one the passed data will be ignored.
+   * Or you can do the synchronous data merging on your side and pass the
+   * wasDataMergedSynchronouslyWithMostRecentCacheState=true so your data will be stored
+   * despite on the lockId.
+   * WARNING: you should do this only if you are sure you perform the synchronous update.
+   *
+   * @param cacheId {string}
+   * @param lockId {string}
+   * @param data {any}
+   * @param [sessionDependentData=true] {boolean}
+   * @param [wasDataMergedSynchronouslyWithMostRecentCacheState=false]
+   */
+  ;
+  _proto.saveCachedData = function saveCachedData(cacheId, lockId, data, sessionDependentData, wasDataMergedSynchronouslyWithMostRecentCacheState) {
+    if (sessionDependentData === void 0) {
+      sessionDependentData = true;
+    }
+    if (wasDataMergedSynchronouslyWithMostRecentCacheState === void 0) {
+      wasDataMergedSynchronouslyWithMostRecentCacheState = false;
+    }
+    try {
+      if (wasDataMergedSynchronouslyWithMostRecentCacheState || this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
+        /* We save passed data only if the <caller> has the currently acquired lockId.
+         * If the passed lockId is not the active one it means that other code cleared/stopped the lock
+         * acquired by the <caller> recently due to some urgent/more prior changes.
+         *
+         * But we allow user to pass the 'wasDataMergedSynchronouslyWithMostRecentCacheState' flag
+         * that tells us that the user had taken the most recent cache value and merged his new data
+         * with that cached value (AFTER possibly performing async data retrieval). This means that we
+         * can ignore the fact that his lockId is no more relevant and save the passed data
+         * as it is synchronously merged with the most recent cached data. (Synchronously merged means that
+         * the lost update cannot occur during the merge time as JS execute the synchronous functions\
+         * till the end).
+         */
+        if (sessionDependentData) {
+          this._cache.putSessionDependentData(cacheId, data, this._getTtl());
+        } else {
+          this._cache.put(cacheId, data, this._getTtl());
+        }
+      }
+    } catch (e) {
+      improveAndRethrow(e, this._bio + ".saveCachedData");
+    }
+  }
+
+  /**
+   * Should be called then and only then if you successfully acquired a lock with the lock id.
+   *
+   * @param cacheId {string}
+   * @param lockId {string}
+   */;
+  _proto.releaseLock = function releaseLock(cacheId, lockId) {
+    try {
+      if (this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
+        this._requestsManager.finishActiveCalculation(cacheId);
+      }
+    } catch (e) {
+      improveAndRethrow(e, this._bio + ".releaseLock");
+    }
+  }
+
+  /**
+   * Actualized currently present cached data by key. Applies the provided function to the cached data.
+   *
+   * @param cacheId {string} id of cache entry
+   * @param synchronousCurrentCacheProcessor (function|null} synchronous function accepting cache entry. Should return
+   *        an object in following format:
+   *        {
+   *            isModified: boolean,
+   *            data: any
+   *        }
+   *        the flag signals whether data was changed during the processing or not
+   * @param [sessionDependent=true] {boolean} whether to mark the cache entry as session-dependent
+   */;
+  _proto.actualizeCachedData = function actualizeCachedData(cacheId, synchronousCurrentCacheProcessor, sessionDependent) {
+    if (sessionDependent === void 0) {
+      sessionDependent = true;
+    }
+    try {
+      var cached = this._cache.get(cacheId);
+      var result = synchronousCurrentCacheProcessor(cached);
+      if (result != null && result.isModified && (result == null ? void 0 : result.data) != null) {
+        if (sessionDependent) {
+          this._cache.putSessionDependentData(cacheId, result == null ? void 0 : result.data, this._getTtl());
+        } else {
+          this._cache.put(cacheId, result == null ? void 0 : result.data, this._getTtl());
+        }
+
+        /* Here we call the lock releasing to ensure the currently active calculation will be ignored.
+         * This is needed to ensure no 'lost update'.
+         * Lost update can occur if we change data in this method and after that some calculation finishes
+         * having the earlier data as its base to calculate its data set result. And the earlier data
+         * has no changes applied inside this method, so we will lose them.
+         *
+         * This is not so good solution: ideally, we should acquire lock before performing any data updating.
+         * But the goal of this method is to provide an instant ability to update the cached data.
+         * And if we start acquiring the lock here the data update can be postponed significantly.
+         * And this kills the desired nature of this method.
+         * So we better lose some data retrieval (means abusing the resource a bit) than lose
+         * the instant update expected after this method execution.
+         */
+        this._requestsManager.finishActiveCalculation(cacheId);
+      }
+    } catch (e) {
+      improveAndRethrow(e, this._bio + ".actualizeCachedData");
+    }
+  };
+  _proto.invalidate = function invalidate(key) {
+    this._cache.invalidate(key);
+    this._requestsManager.finishActiveCalculation(key);
+  };
+  _proto.invalidateContaining = function invalidateContaining(keyPart) {
+    this._cache.invalidateContaining(keyPart);
+    this._requestsManager.finishAllActiveCalculations(keyPart);
+  };
+  _proto.markAsExpiredButDontRemove = function markAsExpiredButDontRemove(key) {
+    if (this._removeExpiredCacheAutomatically) {
+      this._cache.markCacheItemAsExpiredButDontRemove(key, this._cacheTtlMs);
+    } else {
+      this._cache.setLastUpdateTimestamp(key, Date.now() - this._cacheTtlMs - 1);
+    }
+    this._requestsManager.finishAllActiveCalculations(key);
+  };
+  return CacheAndConcurrentRequestsResolver;
+}();
+var ManagerOfRequestsToTheSameResource = /*#__PURE__*/function () {
+  /**
+   * @param bio {string} resource-related identifier for logging
+   * @param [maxPollsCount=100] {number} max number of attempts to wait when waiting for a lock acquisition
+   * @param [timeoutDuration=1000] {number} timeout between the polls for a lock acquisition
+   */
+  function ManagerOfRequestsToTheSameResource(bio, maxPollsCount, timeoutDuration) {
+    if (maxPollsCount === void 0) {
+      maxPollsCount = 100;
+    }
+    if (timeoutDuration === void 0) {
+      timeoutDuration = 1000;
+    }
+    this.bio = bio;
+    this.maxPollsCount = maxPollsCount;
+    this.timeoutDuration = timeoutDuration;
+    this._activeCalculationsIds = new Map();
+    this._nextCalculationIds = new Map();
+  }
+
+  /**
+   * If there is no active calculation just creates uuid and returns it.
+   * If there is active calculation waits until it removed from the active calculation uuid variable.
+   *
+   * @param requestHash {string}
+   * @return {Promise<string|boolean>} returns uuid of new active calculation or true if waiting for active
+   *         calculation succeed or false if max attempts count exceeded
+   */
+  var _proto2 = ManagerOfRequestsToTheSameResource.prototype;
+  _proto2.startCalculationOrWaitForActiveToFinish = function startCalculationOrWaitForActiveToFinish(requestHash) {
+    try {
+      var _exit;
+      var _this3 = this;
+      var _temp3 = _catch$5(function () {
+        var activeCalculationIdForHash = _this3._activeCalculationsIds.get(requestHash);
+        if (activeCalculationIdForHash == null) {
+          var id = uuid.v4();
+          _this3._activeCalculationsIds.set(requestHash, id);
+          _exit = 1;
+          return id;
+        }
+        return Promise.resolve(_this3._waitForCalculationIdToFinish(requestHash, activeCalculationIdForHash, 0)).then(function (_await$_this3$_waitFo) {
+          _exit = 1;
+          return _await$_this3$_waitFo;
+        });
+      }, function (e) {
+        Logger.logError(e, "startCalculationOrWaitForActiveToFinish_" + _this3.bio);
+      });
+      return Promise.resolve(_temp3 && _temp3.then ? _temp3.then(function (_result3) {
+        return _exit ? _result3 : null;
+      }) : _exit ? _temp3 : null);
+    } catch (e) {
+      return Promise.reject(e);
     }
   }
-}
-function _forTo$1(array, body, check) {
-  var i = -1,
-    pact,
-    reject;
-  function _cycle(result) {
+  /**
+   * Acquires lock to the resource by the provided hash.
+   *
+   * @param requestHash {string}
+   * @return {Promise<{ result: true, lockId: string }|{ result: false }>} result is true if the lock is successfully
+   *         acquired, false if the max allowed time to wait for acquisition expired or any unexpected error occurs
+   *         during the waiting.
+   */
+  ;
+  _proto2.acquireLock = function acquireLock(requestHash) {
     try {
-      while (++i < array.length && (!check || !check())) {
-        result = body(i);
-        if (result && result.then) {
-          if (_isSettledPact$1(result)) {
-            result = result.v;
-          } else {
-            result.then(_cycle, reject || (reject = _settle$1.bind(null, pact = new _Pact$1(), 2)));
-            return;
-          }
+      var _this4 = this;
+      return Promise.resolve(_catch$5(function () {
+        var _this4$_nextCalculati;
+        var activeId = _this4._activeCalculationsIds.get(requestHash);
+        var nextId = uuid.v4();
+        if (activeId == null) {
+          _this4._activeCalculationsIds.set(requestHash, nextId);
+          return {
+            result: true,
+            lockId: nextId
+          };
         }
-      }
-      if (pact) {
-        _settle$1(pact, 1, result);
-      } else {
-        pact = result;
-      }
+        var currentNext = (_this4$_nextCalculati = _this4._nextCalculationIds.get(requestHash)) != null ? _this4$_nextCalculati : [];
+        currentNext.push(nextId);
+        _this4._nextCalculationIds.set(requestHash, currentNext);
+        return Promise.resolve(_this4._waitForCalculationIdToFinish(requestHash, activeId, 0, nextId)).then(function (waitingResult) {
+          return {
+            result: waitingResult,
+            lockId: waitingResult ? nextId : undefined
+          };
+        });
+      }, function (e) {
+        improveAndRethrow(e, "acquireLock");
+      }));
     } catch (e) {
-      _settle$1(pact || (pact = new _Pact$1()), 2, e);
+      return Promise.reject(e);
     }
   }
-  _cycle();
-  return pact;
-}
-var RobustExternalAPICallerService = /*#__PURE__*/function () {
-  RobustExternalAPICallerService.getStats = function getStats() {
-    this.statsCollector.getStats();
-  }
-
-  /**
-   * @param bio {string} service name for logging
-   * @param providersData {ExternalApiProvider[]} array of providers
-   * @param [logger] {function} function to be used for logging
-   */;
-  function RobustExternalAPICallerService(bio, providersData, logger) {
-    providersData.forEach(function (provider) {
-      if (!provider.endpoint && provider.endpoint !== "" || !provider.httpMethod) {
-        throw new Error("Wrong format of providers data for: " + JSON.stringify(provider));
-      }
-    });
-
-    // We add niceFactor - just number to order the providers array by. It is helpful to call
-    // less robust APIs only if more robust fails
-    this.providers = providersData;
-    providersData.forEach(function (provider) {
-      return provider.resetNiceFactor();
-    });
-    this.bio = bio;
-    this._logger = Logger.logError;
-  }
-  var _proto = RobustExternalAPICallerService.prototype;
   /**
-   * Performs data retrieval from external APIs. Tries providers till the data is retrieved.
-   *
-   * @param parametersValues {array} array of values of the parameters for URL query string [and/or body]
-   * @param timeoutMS {number} http timeout to wait for response. If provider has its specific timeout value then it is used
-   * @param [cancelToken] {object|undefined} axios token to force-cancel requests from high-level code
-   * @param [attemptsCount] {number|undefined} number of attempts to be performed
-   * @param [doNotFailForNowData] {boolean|undefined} pass true if you do not want us to throw an error if we retrieved null data from all the providers
-   * @return {Promise<any>} resolving to retrieved data (or array of results if specific provider requires
-   *         several requests. NOTE: we flatten nested arrays - results of each separate request done for the specific provider)
-   * @throws Error if requests to all providers are failed
+   * Clears active calculation id.
+   * WARNING: if you forget to call this method the start* one will perform maxPollsCount attempts before finishing
+   * @param requestHash {string} hash of request. Helps to distinct the request for the same resource but
+   *        having different request parameters and hold a dedicated calculation id per this hash
    */
-  _proto.callExternalAPI = function callExternalAPI(parametersValues, timeoutMS, cancelToken, attemptsCount, doNotFailForNowData) {
-    if (parametersValues === void 0) {
-      parametersValues = [];
-    }
-    if (timeoutMS === void 0) {
-      timeoutMS = 3500;
+  ;
+  _proto2.finishActiveCalculation = function finishActiveCalculation(requestHash) {
+    if (requestHash === void 0) {
+      requestHash = "default";
     }
-    if (cancelToken === void 0) {
-      cancelToken = null;
+    try {
+      var _this$_nextCalculatio;
+      this._activeCalculationsIds["delete"](requestHash);
+      var next = (_this$_nextCalculatio = this._nextCalculationIds.get(requestHash)) != null ? _this$_nextCalculatio : [];
+      if (next.length) {
+        this._activeCalculationsIds.set(requestHash, next[0]);
+        this._nextCalculationIds.set(requestHash, next.slice(1));
+      }
+    } catch (e) {
+      improveAndRethrow(e, "finishActiveCalculation");
     }
-    if (attemptsCount === void 0) {
-      attemptsCount = 1;
+  };
+  _proto2.finishAllActiveCalculations = function finishAllActiveCalculations(keyPart) {
+    var _this5 = this;
+    if (keyPart === void 0) {
+      keyPart = "";
     }
-    if (doNotFailForNowData === void 0) {
-      doNotFailForNowData = false;
+    try {
+      Array.from(this._activeCalculationsIds.keys()).forEach(function (hash) {
+        if (typeof hash === "string" && new RegExp(keyPart).test(hash)) {
+          _this5.finishActiveCalculation(hash);
+        }
+      });
+    } catch (e) {
+      improveAndRethrow(e, "finishAllActiveCalculations");
     }
+  }
+
+  /**
+   * @param requestHash {string}
+   * @param lockId {string}
+   * @return {boolean}
+   */;
+  _proto2.isTheLockActiveOne = function isTheLockActiveOne(requestHash, lockId) {
     try {
-      var _this = this;
-      var result;
-      var calculationUuid = concurrentCalculationsMetadataHolder.startCalculation(_this.bio);
-      return Promise.resolve(_finallyRethrows$1(function () {
-        return _catch$4(function () {
-          function _temp5() {
-            var _result2, _result3;
-            if (((_result2 = result) == null ? void 0 : _result2.data) == null) {
-              // TODO: [feature, moderate] looks like we should not fail for null data as it is strange - the provider will fail when processing data internally
-              var error = new Error("Failed to retrieve data. It means all attempts have been failed. DEV: add more attempts to this data retrieval");
-              if (!doNotFailForNowData) {
-                throw error;
-              } else {
-                _this._logger(error, _this.bio + ".callExternalAPI");
-              }
-            }
-            return (_result3 = result) == null ? void 0 : _result3.data;
-          }
-          var i = 0;
-          var _temp4 = _for(function () {
-            var _result4, _result5;
-            return (i < attemptsCount || !!((_result4 = result) != null && _result4.shouldBeForceRetried)) && ((_result5 = result) == null ? void 0 : _result5.data) == null;
-          }, function () {
-            return ++i;
-          }, function () {
-            /**
-             * We use rpsFactor to improve re-attempting to call the providers if the last attempt resulted with
-             * the fail due to abused RPSes of some (most part of) providers.
-             * The _performCallAttempt in such a case will return increased rpsFactor inside the result object.
-             */
-            var rpsFactor = result ? result.rpsFactor : RobustExternalAPICallerService.defaultRPSFactor;
-            result = null;
-            var _temp3 = _catch$4(function () {
-              function _temp2() {
-                var _result$errors;
-                if ((_result$errors = result.errors) != null && _result$errors.length) {
-                  var errors = result.errors;
-                  _this._logger(new Error("Failed at attempt " + i + ". " + errors.length + " errors. Messages: " + safeStringify(errors.map(function (error) {
-                    return error.message;
-                  })) + ": " + safeStringify(errors) + "."), _this.bio + ".callExternalAPI", "", true);
-                }
-              }
-              var _temp = function (_result6) {
-                if (i === 0 && !((_result6 = result) != null && _result6.shouldBeForceRetried)) {
-                  return Promise.resolve(_this._performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData)).then(function (_this$_performCallAtt) {
-                    result = _this$_performCallAtt;
-                  });
-                } else {
-                  var maxRps = Math.max.apply(Math, _this.providers.map(function (provider) {
-                    var _provider$getRps;
-                    return (_provider$getRps = provider.getRps()) != null ? _provider$getRps : 0;
-                  }));
-                  var waitingTimeMs = maxRps ? 1000 / (maxRps / rpsFactor) : 0;
-                  return Promise.resolve(new Promise(function (resolve, reject) {
-                    setTimeout(function () {
-                      try {
-                        var _temp6 = _catch$4(function () {
-                          return Promise.resolve(_this._performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData)).then(function (_this$_performCallAtt2) {
-                            resolve(_this$_performCallAtt2);
-                          });
-                        }, function (e) {
-                          reject(e);
-                        });
-                        return Promise.resolve(_temp6 && _temp6.then ? _temp6.then(function () {}) : void 0);
-                      } catch (e) {
-                        return Promise.reject(e);
-                      }
-                    }, waitingTimeMs);
-                  })).then(function (_Promise) {
-                    result = _Promise;
-                  });
-                }
-              }();
-              return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
-            }, function (e) {
-              _this._logger(e, _this.bio + ".callExternalAPI", "Failed to perform external providers calling");
-            });
-            if (_temp3 && _temp3.then) return _temp3.then(function () {});
-          });
-          return _temp4 && _temp4.then ? _temp4.then(_temp5) : _temp5(_temp4);
-        }, function (e) {
-          improveAndRethrow(e, _this.bio + ".callExternalAPI");
-        });
-      }, function (_wasThrown, _result) {
-        concurrentCalculationsMetadataHolder.endCalculation(_this.bio, calculationUuid);
-        if (_wasThrown) throw _result;
-        return _result;
-      }));
+      return this._activeCalculationsIds.get(requestHash) === lockId;
     } catch (e) {
-      return Promise.reject(e);
+      improveAndRethrow(e, "isTheLockActiveOne");
+    }
+  }
+
+  /**
+   * @param requestHash {string}
+   * @param activeCalculationId {string|null}
+   * @param [attemptIndex=0] {number}
+   * @param waitForCalculationId {string|null} if you want to wait for an exact id to appear as active then pass this parameter
+   * @return {Promise<boolean>} true
+   *                            - if the given calculation id is no more an active one
+   *                            - or it is equal to waitForCalculationId
+   *                            false
+   *                            - if waiting period exceeds the max allowed waiting time or unexpected error occurs
+   * @private
+   */;
+  _proto2._waitForCalculationIdToFinish = function _waitForCalculationIdToFinish(requestHash, activeCalculationId, attemptIndex, waitForCalculationId) {
+    if (attemptIndex === void 0) {
+      attemptIndex = 0;
+    }
+    if (waitForCalculationId === void 0) {
+      waitForCalculationId = null;
     }
-  };
-  _proto._performCallAttempt = function _performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData) {
     try {
-      var _temp15 = function _temp15() {
-        var _data;
-        // If we are declining more than 50% of providers (by exceeding RPS) then we note that it better to retry the whole process of providers requesting
-        var shouldBeForceRetried = data == null && countOfRequestsDeclinedByRps > Math.floor(providers.length * 0.5);
-        var rpsMultiplier = shouldBeForceRetried ? RobustExternalAPICallerService.rpsMultiplier : 1;
-        return {
-          data: (_data = data) != null ? _data : null,
-          shouldBeForceRetried: shouldBeForceRetried,
-          rpsFactor: rpsFactor * rpsMultiplier,
-          errors: errors
-        };
-      };
-      var _this2 = this;
-      var providers = _this2._reorderProvidersByNiceFactor();
-      var data = undefined,
-        providerIndex = 0,
-        countOfRequestsDeclinedByRps = 0,
-        errors = [];
-      var _temp14 = _for(function () {
-        return !data && providerIndex < providers.length;
-      }, void 0, function () {
-        var provider = providers[providerIndex];
-        if (provider.isRpsExceeded()) {
-          /**
-           * Current provider's RPS is exceeded, so we try next provider. Also, we count such cases to make
-           * a decision about the force-retry need.
-           */
-          ++providerIndex;
-          ++countOfRequestsDeclinedByRps;
-          return;
+      var _this6 = this;
+      try {
+        if (attemptIndex + 1 > _this6.maxPollsCount) {
+          // Max number of polls for active calculation id change is achieved. So we return false.
+          return Promise.resolve(false);
         }
-        var _temp13 = _finallyRethrows$1(function () {
-          return _catch$4(function () {
-            var _provider$specificHea;
-            function _temp12() {
-              if (iterationsData.length) {
-                if (httpMethods.length > 1) {
-                  data = provider.incorporateIterationsData(iterationsData);
-                } else {
-                  data = iterationsData[0];
-                }
-              } else if (!doNotFailForNowData) {
-                RobustExternalAPICallerService.statsCollector.externalServiceFailed(provider.getApiGroupId(), "Response data was null for some reason");
-                punishProvider(provider);
-              }
-            }
-            var axiosConfig = _extends({}, cancelToken ? {
-              cancelToken: cancelToken
-            } : {}, {
-              timeout: provider.timeout || timeoutMS,
-              headers: (_provider$specificHea = provider.specificHeaders) != null ? _provider$specificHea : {}
-            });
-            var httpMethods = Array.isArray(provider.httpMethod) ? provider.httpMethod : [provider.httpMethod];
-            var iterationsData = [];
-            var _temp11 = _forTo$1(httpMethods, function (subRequestIndex) {
-              function _temp10() {
-                var responsesDataForPages = responsesForPages.map(function (response) {
-                  return provider.getDataByResponse(response, parametersValues, subRequestIndex, iterationsData);
-                });
-                var allData = responsesDataForPages;
-                if (Array.isArray(responsesDataForPages[0])) {
-                  allData = responsesDataForPages.flat();
-                } else if (responsesDataForPages.length === 1) {
-                  allData = responsesDataForPages[0];
-                }
-                iterationsData.push(allData);
-              }
-              var query = provider.composeQueryString(parametersValues, subRequestIndex);
-              var endpoint = "" + provider.endpoint + query;
-              var axiosParams = [endpoint, axiosConfig];
-              if (["post", "put", "patch"].find(function (method) {
-                return method === httpMethods[subRequestIndex];
-              })) {
-                var _provider$composeBody;
-                var body = (_provider$composeBody = provider.composeBody(parametersValues, subRequestIndex)) != null ? _provider$composeBody : null;
-                axiosParams.splice(1, 0, body);
+        var currentId = _this6._activeCalculationsIds.get(requestHash);
+        if (waitForCalculationId == null ? currentId !== activeCalculationId : currentId === waitForCalculationId) {
+          /* We return true depending on the usage of this function:
+           * 1. if there is calculation id that we should wait for to become an active then we return true only
+           *    if this id becomes the active one.
+           *
+           *    Theoretically we can fail to wait for the desired calculation id. This can be caused by wrong use of
+           *    this service or by any other mistakes/errors. But this waiting function will return false anyway if
+           *    the number of polls done exceeds the max allowed.
+           *
+           * 2. if we just wait for the currently active calculation id to be finished then we return true
+           *    when we notice that the current active id differs from the original passed into this function.
+           */
+          return Promise.resolve(true);
+        } else {
+          /* The original calculation id is still the active one, so we are scheduling a new attempt to check
+           * whether the active calculation id changed or not in timeoutDuration milliseconds.
+           */
+          var it = _this6;
+          return Promise.resolve(new Promise(function (resolve, reject) {
+            setTimeout(function () {
+              try {
+                resolve(it._waitForCalculationIdToFinish(requestHash, activeCalculationId, attemptIndex + 1));
+              } catch (e) {
+                reject(e);
               }
-              var pageNumber = 0;
-              var responsesForPages = [];
-              var hasNextPage = provider.doesSupportPagination();
-              var _temp9 = _do(function () {
-                function _temp8() {
-                  if (hasNextPage) {
-                    hasNextPage = !provider.checkWhetherResponseIsForLastPage(responsesForPages[pageNumber - 1], responsesForPages[pageNumber], pageNumber, subRequestIndex);
-                  }
-                  pageNumber++;
-                }
-                var _temp7 = function () {
-                  if (subRequestIndex === 0 && pageNumber === 0) {
-                    provider.actualizeLastCalledTimestamp();
-                    return Promise.resolve(AxiosAdapter.call.apply(AxiosAdapter, [httpMethods[subRequestIndex]].concat(axiosParams))).then(function (_AxiosAdapter$call) {
-                      responsesForPages[pageNumber] = _AxiosAdapter$call;
-                      RobustExternalAPICallerService.statsCollector.externalServiceCalledWithoutError(provider.getApiGroupId());
-                    });
-                  } else {
-                    if (pageNumber > 0) {
-                      var actualizedParams = provider.changeQueryParametersForPageNumber(parametersValues, responsesForPages[pageNumber - 1], pageNumber, subRequestIndex);
-                      var _query = provider.composeQueryString(actualizedParams, subRequestIndex);
-                      axiosParams[0] = "" + provider.endpoint + _query;
-                    }
-                    /**
-                     * For second and more request we postpone each request to not exceed RPS
-                     * of current provider. We use rpsFactor to dynamically increase the rps to avoid
-                     * too frequent calls if we continue failing to retrieve the data due to RPS exceeding.
-                     * TODO: [dev] test RPS factor logic (units or integration)
-                     */
-
-                    var waitingTimeMS = provider.getRps() ? 1000 / (provider.getRps() / rpsFactor) : 0;
-                    var postponeUntilRpsExceeded = function postponeUntilRpsExceeded(recursionLevel) {
-                      if (recursionLevel === void 0) {
-                        recursionLevel = 0;
-                      }
-                      try {
-                        return Promise.resolve(postponeExecution(function () {
-                          try {
-                            var _temp17 = function _temp17(_result8) {
-                              if (_exit) return _result8;
-                              provider.actualizeLastCalledTimestamp();
-                              return Promise.resolve(AxiosAdapter.call.apply(AxiosAdapter, [httpMethods[subRequestIndex]].concat(axiosParams)));
-                            };
-                            var _exit;
-                            var maxCountOfPostponingAttempts = 2;
-                            var _temp16 = function () {
-                              if (provider.isRpsExceeded() && recursionLevel < maxCountOfPostponingAttempts) {
-                                return Promise.resolve(postponeUntilRpsExceeded(recursionLevel + 1)).then(function (_await$postponeUntilR) {
-                                  _exit = 1;
-                                  return _await$postponeUntilR;
-                                });
-                              }
-                            }();
-                            return Promise.resolve(_temp16 && _temp16.then ? _temp16.then(_temp17) : _temp17(_temp16));
-                          } catch (e) {
-                            return Promise.reject(e);
-                          }
-                        }, waitingTimeMS));
-                      } catch (e) {
-                        return Promise.reject(e);
-                      }
-                    };
-                    return Promise.resolve(postponeUntilRpsExceeded()).then(function (_postponeUntilRpsExce) {
-                      responsesForPages[pageNumber] = _postponeUntilRpsExce;
-                    });
-                  }
-                }();
-                return _temp7 && _temp7.then ? _temp7.then(_temp8) : _temp8(_temp7);
-              }, function () {
-                return !!hasNextPage;
-              });
-              return _temp9 && _temp9.then ? _temp9.then(_temp10) : _temp10(_temp9);
-            });
-            return _temp11 && _temp11.then ? _temp11.then(_temp12) : _temp12(_temp11);
-          }, function (e) {
-            punishProvider(provider);
-            RobustExternalAPICallerService.statsCollector.externalServiceFailed(provider.getApiGroupId(), e == null ? void 0 : e.message);
-            errors.push(e);
-          });
-        }, function (_wasThrown2, _result7) {
-          providerIndex++;
-          if (_wasThrown2) throw _result7;
-          return _result7;
-        });
-        if (_temp13 && _temp13.then) return _temp13.then(function () {});
-      });
-      return Promise.resolve(_temp14 && _temp14.then ? _temp14.then(_temp15) : _temp15(_temp14));
+            }, _this6.timeoutDuration);
+          }));
+        }
+      } catch (e) {
+        Logger.logError(e, "_waitForCalculationIdToFinish", "Failed to wait for active calculation id change.");
+        return Promise.resolve(false);
+      }
     } catch (e) {
       return Promise.reject(e);
     }
   };
-  _proto._reorderProvidersByNiceFactor = function _reorderProvidersByNiceFactor() {
-    var providersCopy = [].concat(this.providers);
-    return providersCopy.sort(function (p1, p2) {
-      return p2.niceFactor - p1.niceFactor;
-    });
-  };
-  return RobustExternalAPICallerService;
+  return ManagerOfRequestsToTheSameResource;
 }();
-RobustExternalAPICallerService.statsCollector = new ExternalServicesStatsCollector();
-RobustExternalAPICallerService.defaultRPSFactor = 1;
-RobustExternalAPICallerService.rpsMultiplier = 1.05;
-function punishProvider(provider) {
-  provider.niceFactor = provider.niceFactor - 1;
-}
 
 /**
  * Extended edit of RobustExternalApiCallerService supporting cache and management of concurrent requests
@@ -4291,7 +4524,7 @@ function punishProvider(provider) {
  * TODO: [tests, critical] Massively used logic
  */
 
-function _catch$3(body, recover) {
+function _catch$4(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -4388,7 +4621,7 @@ var CachedRobustExternalApiCallerService = /*#__PURE__*/function () {
       var cacheId;
       var result;
       return Promise.resolve(_finallyRethrows(function () {
-        return _catch$3(function () {
+        return _catch$4(function () {
           cacheId = _this._calculateCacheId(parametersValues, customHashFunctionForParams);
           return Promise.resolve(_this._cahceAndRequestsResolver.getCachedOrWaitForCachedOrAcquireLock(cacheId)).then(function (_this$_cahceAndReques) {
             var _result2, _result4;
@@ -4436,26 +4669,123 @@ var CachedRobustExternalApiCallerService = /*#__PURE__*/function () {
     var cacheId = this._calculateCacheId(params, customHashFunctionForParams);
     this._cahceAndRequestsResolver.actualizeCachedData(cacheId, synchronousCurrentCacheProcessor, sessionDependent);
   };
-  _proto.markCacheAsExpiredButDontRemove = function markCacheAsExpiredButDontRemove(parametersValues, customHashFunctionForParams) {
-    try {
-      this._cahceAndRequestsResolver.markAsExpiredButDontRemove(this._calculateCacheId(parametersValues, customHashFunctionForParams));
-    } catch (e) {
-      improveAndRethrow(e, "markCacheAsExpiredButDontRemove");
-    }
+  _proto.markCacheAsExpiredButDontRemove = function markCacheAsExpiredButDontRemove(parametersValues, customHashFunctionForParams) {
+    try {
+      this._cahceAndRequestsResolver.markAsExpiredButDontRemove(this._calculateCacheId(parametersValues, customHashFunctionForParams));
+    } catch (e) {
+      improveAndRethrow(e, "markCacheAsExpiredButDontRemove");
+    }
+  };
+  _proto._calculateCacheId = function _calculateCacheId(parametersValues, customHashFunctionForParams) {
+    if (customHashFunctionForParams === void 0) {
+      customHashFunctionForParams = null;
+    }
+    try {
+      var hash = typeof customHashFunctionForParams === "function" ? customHashFunctionForParams(parametersValues) : !parametersValues ? "" : new Hashes__default["default"].SHA512().hex(safeStringify(parametersValues));
+      return this._provider.bio + "-" + hash;
+    } catch (e) {
+      improveAndRethrow(e, this._provider.bio + "_calculateCacheId");
+    }
+  };
+  return CachedRobustExternalApiCallerService;
+}();
+
+function _catch$3(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+var BigdatacloudIpAddressProvider = /*#__PURE__*/function (_ExternalApiProvider) {
+  _inheritsLoose(BigdatacloudIpAddressProvider, _ExternalApiProvider);
+  function BigdatacloudIpAddressProvider() {
+    return _ExternalApiProvider.call(this, "https://api.bigdatacloud.net/data/client-ip", "get", 15000, ApiGroups.BIGDATACLOUD) || this;
+  }
+  var _proto = BigdatacloudIpAddressProvider.prototype;
+  _proto.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
+    var _response$data;
+    return (response == null ? void 0 : response.data) && ((_response$data = response.data) == null ? void 0 : _response$data.ipString);
+  };
+  return BigdatacloudIpAddressProvider;
+}(ExternalApiProvider);
+var TrackipIpAddressProvider = /*#__PURE__*/function (_ExternalApiProvider2) {
+  _inheritsLoose(TrackipIpAddressProvider, _ExternalApiProvider2);
+  function TrackipIpAddressProvider() {
+    return _ExternalApiProvider2.call(this, "https://www.trackip.net/ip", "get", 15000, ApiGroups.TRACKIP) || this;
+  }
+  var _proto2 = TrackipIpAddressProvider.prototype;
+  _proto2.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
+    return response == null ? void 0 : response.data;
+  };
+  return TrackipIpAddressProvider;
+}(ExternalApiProvider);
+var IpifyV6IpAddressProvider = /*#__PURE__*/function (_ExternalApiProvider3) {
+  _inheritsLoose(IpifyV6IpAddressProvider, _ExternalApiProvider3);
+  function IpifyV6IpAddressProvider() {
+    return _ExternalApiProvider3.call(this, "https://api6.ipify.org/?format=json", "get", 15000, ApiGroups.IPIFY) || this;
+  }
+  var _proto3 = IpifyV6IpAddressProvider.prototype;
+  _proto3.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
+    var _response$data2;
+    return (response == null ? void 0 : response.data) && ((_response$data2 = response.data) == null ? void 0 : _response$data2.ip);
+  };
+  return IpifyV6IpAddressProvider;
+}(ExternalApiProvider);
+var IpifyIpAddressProvider = /*#__PURE__*/function (_ExternalApiProvider4) {
+  _inheritsLoose(IpifyIpAddressProvider, _ExternalApiProvider4);
+  function IpifyIpAddressProvider() {
+    return _ExternalApiProvider4.call(this, "https://api.ipify.org/?format=json", "get", 15000, ApiGroups.IPIFY) || this;
+  }
+  var _proto4 = IpifyIpAddressProvider.prototype;
+  _proto4.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
+    var _response$data3;
+    return (response == null ? void 0 : response.data) && ((_response$data3 = response.data) == null ? void 0 : _response$data3.ip);
   };
-  _proto._calculateCacheId = function _calculateCacheId(parametersValues, customHashFunctionForParams) {
-    if (customHashFunctionForParams === void 0) {
-      customHashFunctionForParams = null;
-    }
+  return IpifyIpAddressProvider;
+}(ExternalApiProvider);
+var WhatismyipaddressIpAddressProvider = /*#__PURE__*/function (_ExternalApiProvider5) {
+  _inheritsLoose(WhatismyipaddressIpAddressProvider, _ExternalApiProvider5);
+  function WhatismyipaddressIpAddressProvider() {
+    return _ExternalApiProvider5.call(this, "http://bot.whatismyipaddress.com/", "get", 15000, ApiGroups.WHATISMYIPADDRESS) || this;
+  }
+  var _proto5 = WhatismyipaddressIpAddressProvider.prototype;
+  _proto5.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
+    return response == null ? void 0 : response.data;
+  };
+  return WhatismyipaddressIpAddressProvider;
+}(ExternalApiProvider);
+var IpAddressProvider = /*#__PURE__*/function () {
+  function IpAddressProvider() {}
+  /**
+   * Returns current public IP address identified by one of external services.
+   *
+   * It is easier than manual identification and also (as ip needed for server side to check it) it saves us from
+   * issues related to changes of infrastructure configurations (like adding proxies etc.) so we should not configure
+   * anything on server side to get correct client's IP.
+   *
+   * @returns {Promise<String>} IP address
+   * @throws {Error} if fails to retrieve IP address from all the services
+   */
+  IpAddressProvider.getClientIpAddress = function getClientIpAddress() {
     try {
-      var hash = typeof customHashFunctionForParams === "function" ? customHashFunctionForParams(parametersValues) : !parametersValues ? "" : new Hashes__default["default"].SHA512().hex(safeStringify(parametersValues));
-      return this._provider.bio + "-" + hash;
+      var _this = this;
+      return Promise.resolve(_catch$3(function () {
+        return Promise.resolve(_this.externalIPAddressAPICaller.callExternalAPICached([], 7000));
+      }, function (e) {
+        improveAndRethrow(e, "getClientIpAddress");
+      }));
     } catch (e) {
-      improveAndRethrow(e, this._provider.bio + "_calculateCacheId");
+      return Promise.reject(e);
     }
   };
-  return CachedRobustExternalApiCallerService;
+  return IpAddressProvider;
 }();
+IpAddressProvider.externalIPAddressAPICaller = new CachedRobustExternalApiCallerService("externalIPAddressAPICaller", new Cache(EventBusInstance__default["default"]), [new BigdatacloudIpAddressProvider(), new TrackipIpAddressProvider(), new IpifyV6IpAddressProvider(), new IpifyIpAddressProvider(), new WhatismyipaddressIpAddressProvider()], 300000);
 
 /**
  * Utils class needed to perform cancelling of axios request inside some process.
@@ -4483,239 +4813,6 @@ var CancelProcessing = /*#__PURE__*/function () {
   return CancelProcessing;
 }();
 
-var ExternalApiProvider = /*#__PURE__*/function () {
-  /**
-   * Creates an instance of external api provider.
-   *
-   * If you need sub-request then use 'subRequestIndex' to check current request index in functions below.
-   * Also use array for 'httpMethod'.
-   *
-   * If the endpoint of dedicated provider has pagination then you should customize the behavior using
-   * "changeQueryParametersForPageNumber", "checkWhetherResponseIsForLastPage".
-   *
-   * We perform RPS counting all over the App to avoid blocking our clients due to abuses of the providers.
-   *
-   * @param endpoint {string} URL to the provider's endpoint. Note: you can customize it using composeQueryString
-   * @param [httpMethod] {string|string[]} one of "get", "post", "put", "patch", "delete" or an array of these values
-   *        for request having sub-requests
-   * @param [timeout] {number} number of milliseconds to wait for the response
-   * @param [apiGroup] {ApiGroup} singleton object containing parameters of API group. Helpful when you use the same
-   *        api for different providers to avoid hardcoding RPS inside each provider what can cause mistakes
-   * @param [specificHeaders] {Object} contains specific keys (headers) and values (their content) if needed for this provider
-   * @param [maxPageLength] {number} optional number of items per page if the request supports pagination
-   */
-  function ExternalApiProvider(endpoint, httpMethod, timeout, apiGroup, specificHeaders, maxPageLength) {
-    var _maxPageLength, _specificHeaders;
-    if (specificHeaders === void 0) {
-      specificHeaders = {};
-    }
-    if (maxPageLength === void 0) {
-      maxPageLength = Number.MAX_SAFE_INTEGER;
-    }
-    this.endpoint = endpoint;
-    this.httpMethod = httpMethod != null ? httpMethod : "get";
-    // TODO: [refactoring, critical] We have two timeouts for robust data retrieval - here and inside the service method call, need to remain the only
-    this.timeout = timeout != null ? timeout : 10000;
-    // TODO: [refactoring, critical] We need single place for all RPSes as we use them as hardcoded constants now inside different services
-    this.apiGroup = apiGroup;
-    this.maxPageLength = (_maxPageLength = maxPageLength) != null ? _maxPageLength : Number.MAX_SAFE_INTEGER;
-    this.niceFactor = 1;
-    this.specificHeaders = (_specificHeaders = specificHeaders) != null ? _specificHeaders : {};
-  }
-  var _proto = ExternalApiProvider.prototype;
-  _proto.getRps = function getRps() {
-    var _this$apiGroup$rps;
-    return (_this$apiGroup$rps = this.apiGroup.rps) != null ? _this$apiGroup$rps : 2;
-  };
-  _proto.isRpsExceeded = function isRpsExceeded() {
-    return this.apiGroup.isRpsExceeded();
-  };
-  _proto.actualizeLastCalledTimestamp = function actualizeLastCalledTimestamp() {
-    this.apiGroup.actualizeLastCalledTimestamp();
-  };
-  _proto.getApiGroupId = function getApiGroupId() {
-    return this.apiGroup.id;
-  }
-
-  /**
-   * Some endpoint can require several sub requests. Example is one request to get confirmed transactions
-   * and another request for unconfirmed transactions. You should override this method to return true for such requests.
-   *
-   * @return {boolean} true if this provider requires several requests to retrieve the data
-   */;
-  _proto.doesRequireSubRequests = function doesRequireSubRequests() {
-    return false;
-  }
-
-  /**
-   * Some endpoint support pagination. Override this method if so and implement corresponding methods.
-   *
-   * @return {boolean} true if this provider requires several requests to retrieve the data
-   */;
-  _proto.doesSupportPagination = function doesSupportPagination() {
-    return false;
-  }
-
-  /**
-   * Composes a query string to be added to the endpoint of this provider.
-   *
-   * @param params {any[]} params array passed to the RobustExternalAPICallerService
-   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
-   * @returns {string} query string to be concatenated with endpoint
-   */;
-  _proto.composeQueryString = function composeQueryString(params, subRequestIndex) {
-    return "";
-  }
-
-  /**
-   * Composes a body to be added to the request
-   *
-   * @param params {any[]} params array passed to the RobustExternalAPICallerService
-   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
-   * @returns {string}
-   */;
-  _proto.composeBody = function composeBody(params, subRequestIndex) {
-    return "";
-  }
-
-  /**
-   * Extracts data from the response and returns it
-   *
-   * @param response {Object} HTTP response returned by provider
-   * @param [params] {any[]} params array passed to the RobustExternalAPICallerService
-   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
-   * @param iterationsData {any[]} array of data retrieved from previous sub-requests
-   * @returns {any}
-   */;
-  _proto.getDataByResponse = function getDataByResponse(response, params, subRequestIndex, iterationsData) {
-    return [];
-  }
-
-  /**
-   * Function changing the query string according to page number and previous response
-   * Only for endpoints supporting pagination
-   *
-   * @param params {any[]} params array passed to the RobustExternalAPICallerService
-   * @param previousResponse {Object} HTTP response returned by provider for previous call (previous page)
-   * @param pageNumber {number} new page number. We count from 0. You need to manually increment with 1 if your
-   *        provider counts pages starting with 1
-   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
-   * @returns {any[]}
-   */;
-  _proto.changeQueryParametersForPageNumber = function changeQueryParametersForPageNumber(params, previousResponse, pageNumber, subRequestIndex) {
-    return params;
-  }
-
-  /**
-   * Function checking whether the response is for the last page to stop requesting for a next page.
-   * Only for endpoints supporting pagination.
-   *
-   * @param previousResponse {Object} HTTP response returned by provider for previous call (previous page)
-   * @param currentResponse {Object} HTTP response returned by provider for current call (current page, next after the previous)
-   * @param currentPageNumber {number} current page number (for current response)
-   * @param [subRequestIndex] {number} optional number of the sub-request the call is performed for
-   * @returns {boolean}
-   */;
-  _proto.checkWhetherResponseIsForLastPage = function checkWhetherResponseIsForLastPage(previousResponse, currentResponse, currentPageNumber, subRequestIndex) {
-    return true;
-  }
-
-  /**
-   * Resets the nice factor to default value
-   */;
-  _proto.resetNiceFactor = function resetNiceFactor() {
-    this.niceFactor = 1;
-  }
-
-  /**
-   * Internal method used for requests requiring sub-requests.
-   *
-   * @param iterationsData {any[]} iterations data retrieved from getDataByResponse called per sub-request.
-   * @return {any} by default flatten the passed iterations data array. Should be redefined if you need another logic.
-   */;
-  _proto.incorporateIterationsData = function incorporateIterationsData(iterationsData) {
-    return iterationsData.flat();
-  };
-  return ExternalApiProvider;
-}();
-
-/**
- * Models a group of APIs provided by the same owner and used for different services in our app.
- * It means we need to mention RPS several times for each usage and also have some holder of last call timestamp per
- * api group. So this concept allows to use it for exact ExternalApiProvider and make sure that you use the same
- * RPS value and make decisions on base of the same timestamp of last call to the API group owner.
- */
-var ApiGroup = /*#__PURE__*/function () {
-  function ApiGroup(id, rps, backendProxyIdGenerator) {
-    if (backendProxyIdGenerator === void 0) {
-      backendProxyIdGenerator = null;
-    }
-    this.id = id;
-    this.rps = rps;
-    this.lastCalledTimestamp = null;
-    this.backendProxyIdGenerator = backendProxyIdGenerator;
-  }
-  var _proto = ApiGroup.prototype;
-  _proto.isRpsExceeded = function isRpsExceeded() {
-    var _this$lastCalledTimes;
-    return ((_this$lastCalledTimes = this.lastCalledTimestamp) != null ? _this$lastCalledTimes : 0) + Math.floor(1000 / this.rps) > Date.now();
-  };
-  _proto.actualizeLastCalledTimestamp = function actualizeLastCalledTimestamp() {
-    this.lastCalledTimestamp = Date.now();
-  };
-  return ApiGroup;
-}();
-var ApiGroups = {
-  /**
-   * Currently we use free version of etherscan provider with 0.2 RPS. But we have API key with 100k requests free
-   * per month. So we can add it if not enough current RPS.
-   */
-  ETHERSCAN: new ApiGroup("etherscan", 0.17),
-  // Actually 0.2 but fails sometime, so we use smaller
-  ALCHEMY: new ApiGroup("alchemy", 0.3, function (networkKey) {
-    return "alchemy-" + networkKey;
-  }),
-  BLOCKSTREAM: new ApiGroup("blockstream", 0.2),
-  BLOCKCHAIN_INFO: new ApiGroup("blockchain.info", 1),
-  BLOCKNATIVE: new ApiGroup("blocknative", 0.5),
-  ETHGASSTATION: new ApiGroup("ethgasstation", 0.5),
-  TRONGRID: new ApiGroup("trongrid", 0.3, function (networkKey) {
-    return "trongrid-" + networkKey;
-  }),
-  TRONSCAN: new ApiGroup("tronscan", 0.3),
-  GETBLOCK: new ApiGroup("getblock", 0.3),
-  COINCAP: new ApiGroup("coincap", 0.5),
-  // 200 per minute without API key
-  COINGECKO: new ApiGroup("coingecko", 0.9),
-  // actually 0.13-0.5 according to the docs but we use smaller due to expirienced frequent abuses
-  MESSARI: new ApiGroup("messari", 0.2),
-  BTCCOM: new ApiGroup("btccom", 0.2),
-  BITAPS: new ApiGroup("bitaps", 0.25),
-  // Docs say that RPS is 3 but using it causes frequent 429 HTTP errors
-  CEX: new ApiGroup("cex", 0.5),
-  // Just assumption for RPS
-  BIGDATACLOUD: new ApiGroup("bigdatacloud", 1),
-  // Just assumption for RPS
-  TRACKIP: new ApiGroup("trackip", 1),
-  // Just assumption for RPS
-  IPIFY: new ApiGroup("ipify", 1),
-  // Just assumption for RPS
-  WHATISMYIPADDRESS: new ApiGroup("whatismyipaddress", 1),
-  // Just assumption for RPS
-  EXCHANGERATE: new ApiGroup("exchangerate", 1),
-  // Just assumption for RPS
-  FRANKFURTER: new ApiGroup("frankfurter", 1),
-  // Just assumption for RPS
-  BITGO: new ApiGroup("bitgo", 1),
-  // Just assumption for RPS
-  BITCOINER: new ApiGroup("bitcoiner", 1),
-  // Just assumption for RPS
-  BITCORE: new ApiGroup("bitcore", 1),
-  // Just assumption for RPS
-  // BLOCKCHAIR: new ApiGroup("blockchair", 0.04), // this provider require API key for commercial use (10usd 10000 reqs), we will add it later
-  MEMPOOL: new ApiGroup("mempool", 0.2) // Just assumption for RPS
-};
-
 var ExistingSwap =
 /**
  * @param swapId {string}
@@ -6707,6 +6804,7 @@ exports.ExistingSwap = ExistingSwap;
 exports.ExistingSwapWithFiatData = ExistingSwapWithFiatData;
 exports.ExternalApiProvider = ExternalApiProvider;
 exports.FiatCurrenciesService = FiatCurrenciesService;
+exports.IpAddressProvider = IpAddressProvider;
 exports.LoadingDots = LoadingDots;
 exports.Logger = Logger;
 exports.LogsStorage = LogsStorage;