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

package/dist/index.umd.js

@@ -1,14 +1,14 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('bignumber.js'), require('axios'), require('uuid'), require('jshashes'), require('eventbusjs')) :
-	typeof define === 'function' && define.amd ? define(['exports', 'react', 'bignumber.js', 'axios', 'uuid', 'jshashes', 'eventbusjs'], factory) :
-	(global = global || self, factory(global.uiKit = {}, global.react, global.bignumber_js, global.axios, global.uuid, global.jshashes, global.eventbusjs));
-})(this, (function (exports, React, bignumber_js, axios, uuid, Hashes, EventBusInstance) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('bignumber.js'), require('axios'), require('eventbusjs'), require('jshashes'), require('uuid')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'react', 'bignumber.js', 'axios', 'eventbusjs', 'jshashes', 'uuid'], factory) :
+	(global = global || self, factory(global.uiKit = {}, global.react, global.bignumber_js, global.axios, global.eventbusjs, global.jshashes, global.uuid));
+})(this, (function (exports, React, bignumber_js, axios, EventBusInstance, Hashes, 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: {} };
@@ -1628,7 +1628,7 @@
 	  return Logger;
 	}();
 
-	function _catch$8(body, recover) {
+	function _catch$9(body, recover) {
 	  try {
 	    var result = body();
 	  } catch (e) {
@@ -1644,7 +1644,7 @@
 	    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");
@@ -1697,6 +1697,60 @@
 	  };
 	};
 
+	var InputValuesProviders = /*#__PURE__*/function () {
+	  function InputValuesProviders() {}
+	  /**
+	   * Designed to be called onKeyUp event of html input field for float value
+	   * Removes all prohibited stuff from the given float string and remains only allowed.
+	   * Removes digits before and after the dot.
+	   *
+	   * @param inputString {string} string to be corrected
+	   * @param maxValue {string} max value for the correcting float value
+	   * @param digitsAfterDot {number} count of digits after the dot that this method should provide, min 0
+	   * @return {string} corrected float value string
+	   */
+	  InputValuesProviders.provideFormatOfFloatValueByInputString = function provideFormatOfFloatValueByInputString(inputString, digitsAfterDot, maxValue) {
+	    var _parts$2;
+	    if (digitsAfterDot === void 0) {
+	      digitsAfterDot = 2;
+	    }
+	    if (maxValue === void 0) {
+	      maxValue = null;
+	    }
+	    var value = inputString;
+	    if (!value) {
+	      return "";
+	    }
+	    if (digitsAfterDot < 0) {
+	      throw new Error("Min suffix length is 0, got " + digitsAfterDot);
+	    }
+	    value = value.replace(/[,]/g, "."); // replaces commas with dots
+	    value = value.replace(/[^0-9.]/g, ""); // remove non digits/dots
+	    value = value.replace(/^\./g, "0."); // adds leading zero
+	    value = value.replace(/\.+/g, "."); // replaces series of dots with single dot
+
+	    var parts = value.split(".");
+	    if (parts.length > 2) {
+	      // removes all after second dot and itself
+	      parts = [parts[0], parts[1]];
+	    }
+	    if (maxValue != null) {
+	      var _parts$;
+	      var maxDigitsCountBeforeTheDot = bignumber_js.BigNumber(maxValue).toFixed(0).length;
+	      if (((_parts$ = parts[0]) == null ? void 0 : _parts$.length) > maxDigitsCountBeforeTheDot) {
+	        // removes redundant prefix digits
+	        parts[0] = parts[0].substring(parts[0].length - maxDigitsCountBeforeTheDot, parts[0].length);
+	      }
+	    }
+	    if (((_parts$2 = parts[1]) == null ? void 0 : _parts$2.length) > digitsAfterDot) {
+	      // removes redundant suffix digits
+	      parts[1] = parts[1].substring(0, digitsAfterDot);
+	    }
+	    return parts.join(".");
+	  };
+	  return InputValuesProviders;
+	}();
+
 	var PARAMETER_VALUES_SEPARATOR = "|*|"; // Sting that with high probability will not be in the user's data
 
 	/**
@@ -2097,11 +2151,13 @@
 	  }
 
 	  /**
+	   * Returns integer part of number as a string.
+	   *
 	   * @param amount {BigNumber|number|string|null|undefined} The number value to be trimmed.
 	   *                                                        HEX strings also allowed "0x..." and JS hex numbers
 	   * @return {string|null}
 	   */;
-	  AmountUtils.intStr = function intStr(amount) {
+	  AmountUtils.toIntegerString = function toIntegerString(amount) {
 	    return this.trim(amount, 0);
 	  }
 
@@ -2188,7 +2244,7 @@
 	          leftNumber = leftNumber.times(multiplier);
 	        }
 	      }
-	      var leftAmountString = AmountUtils.intStr(leftNumber);
+	      var leftAmountString = AmountUtils.toIntegerString(leftNumber);
 	      var rightAmountString = right != null ? right.toFixed(rightCurrencyDigitsAfterDots, bignumber_js.BigNumber.ROUND_FLOOR) : null;
 	      return leftAmountString + " " + leftTicker + " ~ " + (rightAmountString != null ? rightAmountString : "?") + " " + rightTicker;
 	    } catch (e) {
@@ -2424,10 +2480,13 @@
 	 */
 	var Cache = /*#__PURE__*/function () {
 	  /**
-	   * @param eventBus {EventBus} EventBus.js lib instance
-	   * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session"
+	   * @param [eventBus=null] {EventBus} EventBus.js lib instance if you plan to use Cache with events handling
+	   * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session", you should pass EventBus to make it work
 	   */
 	  function Cache(eventBus, noSessionEvents) {
+	    if (eventBus === void 0) {
+	      eventBus = null;
+	    }
 	    if (noSessionEvents === void 0) {
 	      noSessionEvents = [];
 	    }
@@ -2523,7 +2582,7 @@
 	        });
 	        if (eventAndKeys) {
 	          eventAndKeys.push(key);
-	        } else {
+	        } else if (_this._eventBus) {
 	          _this._eventDependentDataKeys.push([event, key]);
 	          _this._eventBus.addEventListener(event, function () {
 	            try {
@@ -2682,7 +2741,7 @@
 	  return Cache;
 	}();
 
-	function _catch$7(body, recover) {
+	function _catch$8(body, recover) {
 	  try {
 	    var result = body();
 	  } catch (e) {
@@ -2700,7 +2759,7 @@
 	  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);
 	          });
@@ -2784,7 +2843,7 @@
 	  return AxiosAdapter;
 	}();
 
-	function _catch$6(body, recover) {
+	function _catch$7(body, recover) {
 	  try {
 	    var result = body();
 	  } catch (e) {
@@ -2800,7 +2859,7 @@
 	  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,
@@ -2818,736 +2877,281 @@
 	}();
 	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;
-	      }
-	    }
+	  _proto.isRpsExceeded = function isRpsExceeded() {
+	    return this.apiGroup.isRpsExceeded();
+	  };
+	  _proto.actualizeLastCalledTimestamp = function actualizeLastCalledTimestamp() {
+	    this.apiGroup.actualizeLastCalledTimestamp();
+	  };
+	  _proto.getApiGroupId = function getApiGroupId() {
+	    return this.apiGroup.id;
 	  }
-	  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);
+
+	  /**
+	   * 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;
 	  }
-	  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);
-	  }
-	  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);
+
+	  /**
+	   * 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);
-	    }
-	  }
-	  /**
-	   * 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");
+	      Logger.logError(e, "endCalculation");
 	    }
 	  };
 	  _proto.isCalculationLate = function isCalculationLate(domain, uuid) {
@@ -3673,7 +3277,7 @@
 	 * improve the reliability of a data retrieval.
 	 */
 
-	function _catch$4(body, recover) {
+	function _catch$6(body, recover) {
 	  try {
 	    var result = body();
 	  } catch (e) {
@@ -3684,6 +3288,634 @@
 	  }
 	  return result;
 	}
+	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;
+	    }
+	    pact.s = state;
+	    pact.v = value;
+	    var observer = pact.o;
+	    if (observer) {
+	      observer(pact);
+	    }
+	  }
+	}
+	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;
+	  };
+	  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 _finallyRethrows$1(body, finalizer) {
+	  try {
+	    var result = body();
+	  } catch (e) {
+	    return finalizer(true, e);
+	  }
+	  if (result && result.then) {
+	    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
+	  }
+	  return finalizer(false, result);
+	}
+	function _do(body, test) {
+	  var awaitBody;
+	  do {
+	    var result = body();
+	    if (result && result.then) {
+	      if (_isSettledPact$2(result)) {
+	        result = result.v;
+	      } else {
+	        awaitBody = true;
+	        break;
+	      }
+	    }
+	    var shouldContinue = test();
+	    if (_isSettledPact$2(shouldContinue)) {
+	      shouldContinue = shouldContinue.v;
+	    }
+	    if (!shouldContinue) {
+	      return result;
+	    }
+	  } while (!shouldContinue.then);
+	  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$2(shouldContinue)) {
+	        shouldContinue = shouldContinue.v;
+	      }
+	      if (!shouldContinue) {
+	        break;
+	      }
+	      if (shouldContinue.then) {
+	        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+	        return;
+	      }
+	      result = body();
+	      if (result && result.then) {
+	        if (_isSettledPact$2(result)) {
+	          result = result.v;
+	        } else {
+	          result.then(_resumeAfterBody).then(void 0, reject);
+	          return;
+	        }
+	      }
+	    }
+	    _settle$2(pact, 1, result);
+	  }
+	  function _resumeAfterTest(shouldContinue) {
+	    if (shouldContinue) {
+	      do {
+	        result = body();
+	        if (result && result.then) {
+	          if (_isSettledPact$2(result)) {
+	            result = result.v;
+	          } else {
+	            result.then(_resumeAfterBody).then(void 0, reject);
+	            return;
+	          }
+	        }
+	        shouldContinue = test();
+	        if (_isSettledPact$2(shouldContinue)) {
+	          shouldContinue = shouldContinue.v;
+	        }
+	        if (!shouldContinue) {
+	          _settle$2(pact, 1, result);
+	          return;
+	        }
+	      } while (!shouldContinue.then);
+	      shouldContinue.then(_resumeAfterTest).then(void 0, reject);
+	    } else {
+	      _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 = function () {
+	      Logger.logError.apply(Logger, [].slice.call(arguments));
+	    };
+	  }
+	  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) {
@@ -3703,12 +3935,17 @@
 	    }
 	    pact.s = state;
 	    pact.v = value;
-	    var observer = pact.o;
+	    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) {
@@ -3771,517 +4008,574 @@
 	        break;
 	      }
 	    }
-	    if (update) {
-	      var updateValue = update();
-	      if (updateValue && updateValue.then && !_isSettledPact$1(updateValue)) {
-	        stage = 2;
-	        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;
 	    }
-	  }
-	  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;
+	    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());
 	        }
 	      }
-	      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);
+	    } catch (e) {
+	      improveAndRethrow(e, this._bio + ".saveCachedData");
 	    }
 	  }
-	  function _resumeAfterUpdate() {
-	    if (shouldContinue = test()) {
-	      if (shouldContinue.then) {
-	        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-	      } else {
-	        _resumeAfterTest(shouldContinue);
+
+	  /**
+	   * 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);
 	      }
-	    } else {
-	      _settle$1(pact, 1, result);
+	    } catch (e) {
+	      improveAndRethrow(e, this._bio + ".releaseLock");
 	    }
 	  }
-	}
-	function _finallyRethrows$1(body, finalizer) {
-	  try {
-	    var result = body();
-	  } catch (e) {
-	    return finalizer(true, e);
-	  }
-	  if (result && result.then) {
-	    return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
-	  }
-	  return finalizer(false, result);
-	}
-	function _do(body, test) {
-	  var awaitBody;
-	  do {
-	    var result = body();
-	    if (result && result.then) {
-	      if (_isSettledPact$1(result)) {
-	        result = result.v;
-	      } else {
-	        awaitBody = true;
-	        break;
-	      }
-	    }
-	    var shouldContinue = test();
-	    if (_isSettledPact$1(shouldContinue)) {
-	      shouldContinue = shouldContinue.v;
-	    }
-	    if (!shouldContinue) {
-	      return result;
+
+	  /**
+	   * 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;
 	    }
-	  } while (!shouldContinue.then);
-	  var pact = new _Pact$1();
-	  var reject = _settle$1.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)) {
-	        shouldContinue = shouldContinue.v;
-	      }
-	      if (!shouldContinue) {
-	        break;
-	      }
-	      if (shouldContinue.then) {
-	        shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-	        return;
-	      }
-	      result = body();
-	      if (result && result.then) {
-	        if (_isSettledPact$1(result)) {
-	          result = result.v;
+	    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 {
-	          result.then(_resumeAfterBody).then(void 0, reject);
-	          return;
+	          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;
 	    }
-	    _settle$1(pact, 1, result);
+	    this.bio = bio;
+	    this.maxPollsCount = maxPollsCount;
+	    this.timeoutDuration = timeoutDuration;
+	    this._activeCalculationsIds = new Map();
+	    this._nextCalculationIds = new Map();
 	  }
-	  function _resumeAfterTest(shouldContinue) {
-	    if (shouldContinue) {
-	      do {
-	        result = body();
-	        if (result && result.then) {
-	          if (_isSettledPact$1(result)) {
-	            result = result.v;
-	          } else {
-	            result.then(_resumeAfterBody).then(void 0, reject);
-	            return;
-	          }
-	        }
-	        shouldContinue = test();
-	        if (_isSettledPact$1(shouldContinue)) {
-	          shouldContinue = shouldContinue.v;
-	        }
-	        if (!shouldContinue) {
-	          _settle$1(pact, 1, result);
-	          return;
+
+	  /**
+	   * 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;
 	        }
-	      } while (!shouldContinue.then);
-	      shouldContinue.then(_resumeAfterTest).then(void 0, reject);
-	    } else {
-	      _settle$1(pact, 1, result);
+	        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
@@ -4289,7 +4583,7 @@
 	 * TODO: [tests, critical] Massively used logic
 	 */
 
-	function _catch$3(body, recover) {
+	function _catch$4(body, recover) {
 	  try {
 	    var result = body();
 	  } catch (e) {
@@ -4386,7 +4680,7 @@
 	      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;
@@ -4446,14 +4740,111 @@
 	      customHashFunctionForParams = null;
 	    }
 	    try {
-	      var hash = typeof customHashFunctionForParams === "function" ? customHashFunctionForParams(parametersValues) : !parametersValues ? "" : new Hashes__default["default"].SHA512().hex(safeStringify(parametersValues));
-	      return this._provider.bio + "-" + hash;
+	      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);
+	  };
+	  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 _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.
@@ -4481,239 +4872,6 @@
 	  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}
@@ -4722,6 +4880,7 @@
 	 * @param expiresAt {number}
 	 * @param confirmations {number}
 	 * @param rate {string}
+	 * @param fixed {boolean}
 	 * @param refundAddress {string}
 	 * @param payToAddress {string}
 	 * @param fromCoin {Coin}
@@ -4738,7 +4897,7 @@
 	 * @param toExtraId {string}
 	 * @param refundExtraId {string}
 	 */
-	function ExistingSwap(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress,
+	function ExistingSwap(swapId, status, createdAt, expiresAt, confirmations, rate, fixed, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress,
 	// TODO: [refactoring, moderate] toAddress is not quite clear. How about recipientAddress? task_id=0815a111c99543b78d374217eadbde4f
 	partner, fromExtraId, toExtraId, refundExtraId) {
 	  this.swapId = swapId;
@@ -4747,6 +4906,7 @@
 	  this.expiresAt = expiresAt;
 	  this.confirmations = confirmations;
 	  this.rate = rate;
+	  this.fixed = fixed;
 	  this.refundAddress = refundAddress;
 	  this.payToAddress = payToAddress;
 	  this.fromCoin = fromCoin;
@@ -4773,6 +4933,7 @@
 	   * @param expiresAt {number}
 	   * @param confirmations {number}
 	   * @param rate {string}
+	   * @param fixed {boolean}
 	   * @param refundAddress {string}
 	   * @param payToAddress {string}
 	   * @param fromCoin {Coin}
@@ -4793,9 +4954,9 @@
 	   * @param fiatCurrencyCode {string}
 	   * @param fiatCurrencyDecimals {number}
 	   */
-	  function ExistingSwapWithFiatData(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromExtraId, toExtraId, refundExtraId, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
+	  function ExistingSwapWithFiatData(swapId, status, createdAt, expiresAt, confirmations, rate, fixed, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromExtraId, toExtraId, refundExtraId, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
 	    var _this;
-	    _this = _ExistingSwap.call(this, swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromExtraId, toExtraId, refundExtraId) || this;
+	    _this = _ExistingSwap.call(this, swapId, status, createdAt, expiresAt, confirmations, rate, fixed, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromExtraId, toExtraId, refundExtraId) || this;
 	    _this.fromAmountFiat = fromAmountFiat;
 	    _this.toAmountFiat = toAmountFiat;
 	    _this.fiatCurrencyCode = fiatCurrencyCode;
@@ -4812,7 +4973,7 @@
 	   * @return {ExistingSwapWithFiatData}
 	   */
 	  ExistingSwapWithFiatData.fromExistingSwap = function fromExistingSwap(existingSwap, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
-	    return new ExistingSwapWithFiatData(existingSwap.swapId, existingSwap.status, existingSwap.createdAt, existingSwap.expiresAt, existingSwap.confirmations, existingSwap.rate, existingSwap.refundAddress, existingSwap.payToAddress, existingSwap.fromCoin, existingSwap.fromAmount, existingSwap.fromTransactionId, existingSwap.fromTransactionLink, existingSwap.toCoin, existingSwap.toAmount, existingSwap.toTransactionId, existingSwap.toTransactionLink, existingSwap.toAddress, existingSwap.partner, existingSwap.fromExtraId, existingSwap.toExtraId, existingSwap.refundExtraId, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals);
+	    return new ExistingSwapWithFiatData(existingSwap.swapId, existingSwap.status, existingSwap.createdAt, existingSwap.expiresAt, existingSwap.confirmations, existingSwap.rate, existingSwap.fixed, existingSwap.refundAddress, existingSwap.payToAddress, existingSwap.fromCoin, existingSwap.fromAmount, existingSwap.fromTransactionId, existingSwap.fromTransactionLink, existingSwap.toCoin, existingSwap.toAmount, existingSwap.toTransactionId, existingSwap.toTransactionLink, existingSwap.toAddress, existingSwap.partner, existingSwap.fromExtraId, existingSwap.toExtraId, existingSwap.refundExtraId, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals);
 	  };
 	  return ExistingSwapWithFiatData;
 	}(ExistingSwap);
@@ -4830,8 +4991,9 @@
 	 * @param max {string}
 	 * @param fiatMax {number}
 	 * @param durationMinutesRange {string}
+	 * @param fixed {boolean}
 	 */
-	function BaseSwapCreationInfo(fromCoin, toCoin, fromAmountCoins, toAmountCoins, rate, rawSwapData, min, fiatMin, max, fiatMax, durationMinutesRange) {
+	function BaseSwapCreationInfo(fromCoin, toCoin, fromAmountCoins, toAmountCoins, rate, rawSwapData, min, fiatMin, max, fiatMax, durationMinutesRange, fixed) {
 	  this.fromCoin = fromCoin;
 	  this.toCoin = toCoin;
 	  this.fromAmountCoins = fromAmountCoins;
@@ -4843,6 +5005,7 @@
 	  this.max = max;
 	  this.fiatMax = fiatMax;
 	  this.durationMinutesRange = durationMinutesRange;
+	  this.fixed = fixed;
 	};
 
 	var SwapProvider = /*#__PURE__*/function () {
@@ -4941,6 +5104,7 @@
 	   * @param fromCoin {Coin}
 	   * @param toCoin {Coin}
 	   * @param amountCoins {string}
+	   * @param [fixed=false] {boolean|null} null means fixed or float doesn't matter
 	   * @param [fromCoinToUsdRate=null] pass if you want to increase the min amount returned
 	   *        by provider with some fixed "insurance" amount to cover min amount fluctuations.
 	   * @return {Promise<({
@@ -4956,11 +5120,12 @@
 	   *            greatestMax: (string|null),
 	   *            rate: (string|null),
 	   *            durationMinutesRange: string,
+	   *            fixed: boolean,
 	   *            [rawSwapData]: Object
 	   *         })>}
 	   */
 	  ;
-	  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate) {
+	  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fixed, fromCoinToUsdRate) {
 	    try {
 	      throw new Error("Not implemented in base");
 	    } catch (e) {
@@ -4968,7 +5133,7 @@
 	    }
 	  }
 	  /**
-	   * For fail result we return one of SwapProvider.CREATION_FAIL_REASONS or SwapProvider.COMMON_ERRORS.
+	   * For fail result we return one of SwapProvider.CREATION_FAIL_REASONS or SwapProvider.COMMON_ERRORS.*
 	   *
 	   * @param fromCoin {Coin}
 	   * @param toCoin {Coin}
@@ -4977,6 +5142,7 @@
 	   * @param refundAddress {string}
 	   * @param rawSwapData {Object|null}
 	   * @param clientIpAddress {string}
+	   * @param fixed {boolean}
 	   * @param [toCurrencyExtraId=""] {string} optional extra ID
 	   * @param [refundExtraId=""] {string} optional extra ID for refund address
 	   * @return {Promise<({
@@ -4989,7 +5155,8 @@
 	   *                     toAmount: string,
 	   *                     toAddress: string,
 	   *                     rate: string,
-	   *                     fromCurrencyExtraId: string|undefined
+	   *                     fromCurrencyExtraId: string|undefined,
+	   *                     fixed: boolean
 	   *                 }|{
 	   *                     result: false,
 	   *                     reason: string,
@@ -4997,7 +5164,7 @@
 	   *                 })>}
 	   */
 	  ;
-	  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, toCurrencyExtraId, refundExtraId) {
+	  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, fixed, toCurrencyExtraId, refundExtraId) {
 	    try {
 	      throw new Error("Not implemented in base");
 	    } catch (e) {
@@ -5052,7 +5219,9 @@
 	SwapProvider.NO_SWAPS_REASONS = {
 	  TOO_LOW: "tooLow",
 	  TOO_HIGH: "tooHigh",
-	  NOT_SUPPORTED: "notSupported"
+	  NOT_SUPPORTED: "notSupported",
+	  NO_FIXED_BUT_HAVE_FLOATING: "noFixedButHaveFloating",
+	  NO_FLOATING_BUT_HAVE_FIXED: "noFloatingButHaveFixed"
 	};
 	SwapProvider.CREATION_FAIL_REASONS = {
 	  RETRIABLE_FAIL: "retriableFail"
@@ -5264,7 +5433,6 @@
 	                  var ticker = "" + code + (code === network ? "" : network);
 	                  var defaultDecimalPlacesForCoinNotSupportedOOB = 8;
 	                  var defaultMinConfirmationsForCoinNotSupportedOOB = 1;
-	                  // TODO: [dev] maybe we should recognize standard protocols?
 	                  coin = new Coin(item.name, ticker, code, defaultDecimalPlacesForCoinNotSupportedOOB, null, "", null, null, defaultMinConfirmationsForCoinNotSupportedOOB, null, [], 60000, null,
 	                  // We cannot recognize blockchain from swapspace data
 	                  code !== network ? new Protocol(network) : null, item.contractAddress || null, false);
@@ -5277,7 +5445,7 @@
 	                    network: item.network,
 	                    hasExtraId: item.hasExtraId,
 	                    extraIdName: item.extraIdName,
-	                    isPopular: !!(item != null && item.popular),
+	                    isPopular: !!item.popular,
 	                    iconURL: item.icon ? "https://storage.swapspace.co" + item.icon : FALLBACK_ICON_URL,
 	                    deposit: (_item$deposit = item.deposit) != null ? _item$deposit : false,
 	                    withdrawal: (_item$withdrawal = item.withdrawal) != null ? _item$withdrawal : false,
@@ -5335,7 +5503,7 @@
 	            };
 	          }
 	          Logger.log("Loading USDT->coin rate as not found in cache:", coin == null ? void 0 : coin.ticker);
-	          return Promise.resolve(_this7.getSwapInfo(usdtTrc20, coin, "5000")).then(function (result) {
+	          return Promise.resolve(_this7.getSwapInfo(usdtTrc20, coin, "5000", false)).then(function (result) {
 	            if (!result.result) {
 	              return {
 	                result: false
@@ -5343,7 +5511,7 @@
 	            }
 
 	            // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
-	            var standardSwapspaceFeeMultiplier = 1.004; // usually 0.2%
+	            var standardSwapspaceFeeMultiplier = 1.004; // fee is usually 0.4%
 	            var rate = bignumber_js.BigNumber(1).div(bignumber_js.BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
 	            _this7._cache.put("swapspace_usdt_rate_" + coin.ticker, rate, 15 * 60000 // 15 minutes
 	            );
@@ -5371,7 +5539,10 @@
 	      improveAndRethrow(e, "getCoinByTickerIfPresent");
 	    }
 	  };
-	  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate) {
+	  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fixed, fromCoinToUsdRate) {
+	    if (fixed === void 0) {
+	      fixed = false;
+	    }
 	    if (fromCoinToUsdRate === void 0) {
 	      fromCoinToUsdRate = null;
 	    }
@@ -5379,8 +5550,8 @@
 	      var _this8 = this;
 	      var loggerSource = "getSwapInfo";
 	      return Promise.resolve(_catch$2(function () {
-	        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || bignumber_js.BigNumber(amountCoins).lt("0")) {
-	          throw new Error("Wrong input params: " + amountCoins + " " + fromCoin.ticker + " -> " + toCoin.ticker + (fromCoin instanceof Coin) + (toCoin instanceof Coin));
+	        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || bignumber_js.BigNumber(amountCoins).lt("0") || fixed !== null && typeof fixed !== "boolean") {
+	          throw new Error("Wrong input params: " + amountCoins + " " + fromCoin.ticker + " -> " + toCoin.ticker + ", " + (fromCoin instanceof Coin) + ", " + (toCoin instanceof Coin) + ", " + typeof fixed + " " + fixed);
 	        }
 	        var fromCoinSwapspaceDetails = _this8._supportedCoins.find(function (i) {
 	          var _i$coin;
@@ -5396,17 +5567,29 @@
 	        return !fromCoinSwapspaceDetails.deposit || !toCoinSwapspaceDetails.withdrawal ? {
 	          result: false,
 	          reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
-	        } : Promise.resolve(axios__default["default"].get(_this8._URL + "/api/v2/amounts?fromCurrency=" + fromCoinSwapspaceDetails.code + "&fromNetwork=" + fromCoinSwapspaceDetails.network + "&toNetwork=" + toCoinSwapspaceDetails.network + "&toCurrency=" + toCoinSwapspaceDetails.code + "&amount=" + amountCoins + "&float=true&estimated=false")).then(function (response) {
-	          var _response$data;
+	        } : Promise.resolve(axios__default["default"].get(_this8._URL + "/api/v2/amounts?fromCurrency=" + fromCoinSwapspaceDetails.code + "&fromNetwork=" + fromCoinSwapspaceDetails.network + "&toNetwork=" + toCoinSwapspaceDetails.network + "&toCurrency=" + toCoinSwapspaceDetails.code + "&amount=" + amountCoins + "&estimated=false")).then(function (response) {
+	          var _response$data, _exchangesSupportingT;
 	          Logger.log("Retrieved " + (response == null || (_response$data = response.data) == null ? void 0 : _response$data.length) + " options", loggerSource);
 	          var options = Array.isArray(response.data) ? response.data : [];
-	          var exchangesSupportingThePair = options.filter(function (exchange) {
+	          var exchangesSupportingThePairDespiteFixedOrFloating = options.filter(function (exchange) {
 	            return (exchange == null ? void 0 : exchange.exists) && !BANNED_PARTNERS.find(function (bannedPartner) {
 	              return bannedPartner === (exchange == null ? void 0 : exchange.partner);
-	            }) && (exchange == null ? void 0 : exchange.fixed) === false && (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min || (typeof exchange.min !== "number" || typeof exchange.max !== "number") && exchange.toAmount > 0);
+	            }) && ((exchange == null ? void 0 : exchange.fixed) === false || (exchange == null ? void 0 : exchange.fixed) === true) && (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min || (typeof exchange.min !== "number" || typeof exchange.max !== "number") && exchange.toAmount > 0);
 	          });
-	          Logger.log((exchangesSupportingThePair == null ? void 0 : exchangesSupportingThePair.length) + " of them have exist=true", loggerSource);
-	          if (!exchangesSupportingThePair.length) {
+	          var exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating;
+	          if (fixed != null) {
+	            exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating.filter(function (option) {
+	              return option.fixed === fixed;
+	            });
+	          }
+	          Logger.log(((_exchangesSupportingT = exchangesSupportingThePair) == null ? void 0 : _exchangesSupportingT.length) + " of them have exist=true", loggerSource);
+	          if (exchangesSupportingThePair.length === 0) {
+	            if (exchangesSupportingThePairDespiteFixedOrFloating.length > 0 && fixed !== null) {
+	              return {
+	                result: false,
+	                reason: fixed ? SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING : SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED
+	              };
+	            }
 	            return {
 	              result: false,
 	              reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
@@ -5477,6 +5660,7 @@
 	              greatestMax: greatestMax,
 	              rate: rate != null ? AmountUtils.trim(rate, _this8._maxRateDigits) : null,
 	              durationMinutesRange: (_bestOpt$duration = bestOpt.duration) != null ? _bestOpt$duration : null,
+	              fixed: bestOpt.fixed,
 	              rawSwapData: bestOpt
 	            };
 	          }
@@ -5504,7 +5688,7 @@
 	      return Promise.reject(e);
 	    }
 	  };
-	  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, toCurrencyExtraId, refundExtraId) {
+	  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, fixed, toCurrencyExtraId, refundExtraId) {
 	    if (toCurrencyExtraId === void 0) {
 	      toCurrencyExtraId = "";
 	    }
@@ -5516,13 +5700,18 @@
 	      var loggerSource = "createSwap";
 	      var partner = rawSwapData == null ? void 0 : rawSwapData.partner;
 	      return Promise.resolve(_catch$2(function () {
-	        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amount !== "string" || typeof toAddress !== "string" || typeof refundAddress !== "string") {
-	          throw new Error("Invalid input: " + fromCoin + " " + toCoin + " " + amount + " " + toAddress + " " + refundAddress);
+	        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amount !== "string" || typeof toAddress !== "string" || typeof refundAddress !== "string" || typeof clientIpAddress != "string" || typeof fixed != "boolean" || clientIpAddress.length === 0) {
+	          throw new Error("Invalid input: " + fromCoin + " " + toCoin + " " + amount + " " + toAddress + " " + refundAddress + " " + (clientIpAddress == null ? void 0 : clientIpAddress.length) + " " + fixed);
 	        }
 	        if (typeof partner !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.fromCurrency) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.fromNetwork) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.toCurrency) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.toNetwork) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.id) !== "string" // can be just empty
 	        ) {
 	          throw new Error("Invalid raw swap data: " + safeStringify(rawSwapData));
 	        }
+	        var _this9$_supportedCoin = _this9._supportedCoins.reduce(function (prev, coinData) {
+	            return [coinData.coin.ticker === fromCoin.ticker ? coinData.hasExtraId : prev[0], coinData.coin.ticker === toCoin.ticker ? coinData.hasExtraId : prev[1]];
+	          }, [false, false]),
+	          fromCurrencyHasExtraId = _this9$_supportedCoin[0],
+	          toCurrencyHasExtraId = _this9$_supportedCoin[1];
 	        return Promise.resolve(_this9._fetchSupportedCurrenciesIfNeeded()).then(function () {
 	          var _toCurrencyExtraId, _refundExtraId;
 	          var requestData = {
@@ -5533,10 +5722,10 @@
 	            toNetwork: rawSwapData == null ? void 0 : rawSwapData.toNetwork,
 	            address: toAddress,
 	            amount: amount,
-	            fixed: false,
-	            extraId: (_toCurrencyExtraId = toCurrencyExtraId) != null ? _toCurrencyExtraId : "",
-	            refundExtraId: (_refundExtraId = refundExtraId) != null ? _refundExtraId : "",
+	            fixed: fixed,
+	            extraId: toCurrencyHasExtraId ? (_toCurrencyExtraId = toCurrencyExtraId) != null ? _toCurrencyExtraId : "" : "",
 	            // This param is not documented. But the refund is usually manual so this is not critical.
+	            refundExtraId: fromCurrencyHasExtraId ? (_refundExtraId = refundExtraId) != null ? _refundExtraId : "" : "",
 	            rateId: rawSwapData == null ? void 0 : rawSwapData.id,
 	            userIp: clientIpAddress,
 	            refund: refundAddress
@@ -5547,7 +5736,7 @@
 	            Logger.log("Creation result " + safeStringify(result), loggerSource);
 	            if (result != null && result.id) {
 	              var _result$from, _result$from2, _result$to, _result$to2, _result$from4, _result$from5, _result$to4, _result$to5, _result$from$extraId, _result$from6;
-	              if (typeof (result == null || (_result$from = result.from) == null ? void 0 : _result$from.amount) !== "number" || typeof (result == null || (_result$from2 = result.from) == null ? void 0 : _result$from2.address) !== "string" || typeof (result == null || (_result$to = result.to) == null ? void 0 : _result$to.amount) !== "number" || typeof (result == null || (_result$to2 = result.to) == null ? void 0 : _result$to2.address) !== "string") throw new Error("Wrong swap creation result " + result);
+	              if (typeof (result == null || (_result$from = result.from) == null ? void 0 : _result$from.amount) !== "number" || typeof (result == null || (_result$from2 = result.from) == null ? void 0 : _result$from2.address) !== "string" || typeof (result == null ? void 0 : result.fixed) !== "boolean" || typeof (result == null || (_result$to = result.to) == null ? void 0 : _result$to.amount) !== "number" || typeof (result == null || (_result$to2 = result.to) == null ? void 0 : _result$to2.address) !== "string") throw new Error("Wrong swap creation result " + result);
 	              /* We use the returned rate preferably but if the retrieved
 	               * rate 0/null/undefined we calculate it manually */
 	              var rate = result.rate;
@@ -5567,7 +5756,8 @@
 	                toAmount: AmountUtils.trim(result == null || (_result$to4 = result.to) == null ? void 0 : _result$to4.amount, toCoin.digits),
 	                toAddress: result == null || (_result$to5 = result.to) == null ? void 0 : _result$to5.address,
 	                fromCurrencyExtraId: (_result$from$extraId = result == null || (_result$from6 = result.from) == null ? void 0 : _result$from6.extraId) != null ? _result$from$extraId : "",
-	                rate: AmountUtils.trim(rate, _this9._maxRateDigits)
+	                rate: AmountUtils.trim(rate, _this9._maxRateDigits),
+	                fixed: result.fixed
 	              };
 	            }
 	            var errorMessage = "Swap creation succeeded but the response is wrong: " + safeStringify(response);
@@ -5684,7 +5874,7 @@
 	            var status = _this10._mapSwapspaceStatusToRabbitStatus(swap.status, isExpiredByTime);
 	            var toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
 	            var addressToSendCoinsToSwapspace = swap.from.address;
-	            return new ExistingSwap(swapIds[index], status, toUtcTimestamp(swap.timestamps.createdAt), expiresAt, swap.confirmations, AmountUtils.trim(swap.rate, _this10._maxRateDigits), swap.refundAddress, addressToSendCoinsToSwapspace, fromCoin, AmountUtils.trim(swap.from.amount, fromCoin.digits), swap.from.transactionHash, swap.blockExplorerTransactionUrl.from, toCoin, AmountUtils.trim(swap.to.amount, toDigits), swap.to.transactionHash, swap.blockExplorerTransactionUrl.to, swap.to.address, swap.partner, (_swap$from$extraId = swap.from.extraId) != null ? _swap$from$extraId : null, (_swap$to$extraId = swap.to.extraId) != null ? _swap$to$extraId : null, (_swap$refundExtraId = swap.refundExtraId) != null ? _swap$refundExtraId : null);
+	            return new ExistingSwap(swapIds[index], status, toUtcTimestamp(swap.timestamps.createdAt), expiresAt, swap.confirmations, AmountUtils.trim(swap.rate, _this10._maxRateDigits), swap.fixed, swap.refundAddress, addressToSendCoinsToSwapspace, fromCoin, AmountUtils.trim(swap.from.amount, fromCoin.digits), swap.from.transactionHash, swap.blockExplorerTransactionUrl.from, toCoin, AmountUtils.trim(swap.to.amount, toDigits), swap.to.transactionHash, swap.blockExplorerTransactionUrl.to, swap.to.address, swap.partner, (_swap$from$extraId = swap.from.extraId) != null ? _swap$from$extraId : null, (_swap$to$extraId = swap.to.extraId) != null ? _swap$to$extraId : null, (_swap$refundExtraId = swap.refundExtraId) != null ? _swap$refundExtraId : null);
 	          }).flat();
 	          Logger.log("Swap details result " + safeStringify(swaps), loggerSource);
 	          return {
@@ -6242,6 +6432,7 @@
 	   * @param fromCoin {Coin}
 	   * @param toCoin {Coin}
 	   * @param fromAmountCoins {string}
+	   * @param [fixed=false] {boolean|null} null means fixed or float doesn't matter
 	   * @param [withoutFiat=false] {boolean} pass true if you don't need the fiat equivalent - this will diminish requests count
 	   * @return {Promise<{
 	   *             result: false,
@@ -6257,7 +6448,10 @@
 	   *         }>}
 	   */
 	  ;
-	  _proto.getPublicSwapDetails = function getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins, withoutFiat) {
+	  _proto.getPublicSwapDetails = function getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins, fixed, withoutFiat) {
+	    if (fixed === void 0) {
+	      fixed = false;
+	    }
 	    if (withoutFiat === void 0) {
 	      withoutFiat = false;
 	    }
@@ -6268,7 +6462,7 @@
 	        function _temp2(_this7$_swapProvider$) {
 	          var _this7$_swapProvider$2;
 	          var coinUsdtRate = withoutFiat ? _this7$_swapProvider$ : (_this7$_swapProvider$2 = _this7$_swapProvider$ == null ? void 0 : _this7$_swapProvider$.rate) != null ? _this7$_swapProvider$2 : null;
-	          return Promise.resolve(_this7._swapProvider.getSwapInfo(fromCoin, toCoin, fromAmountCoins, coinUsdtRate)).then(function (details) {
+	          return Promise.resolve(_this7._swapProvider.getSwapInfo(fromCoin, toCoin, fromAmountCoins, fixed, coinUsdtRate)).then(function (details) {
 	            var _result$swapCreationI, _result$swapCreationI2;
 	            var min = details.result ? details.min : details.smallestMin;
 	            var max = details.result ? details.max : details.greatestMax;
@@ -6295,9 +6489,15 @@
 	              };
 	            };
 	            if (!details.result) {
-	              if ((details == null ? void 0 : details.reason) === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) return composeFailResult(PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED);else if ((details == null ? void 0 : details.reason) === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+	              if ((details == null ? void 0 : details.reason) === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) {
+	                return composeFailResult(PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED);
+	              } else if ((details == null ? void 0 : details.reason) === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
 	                SwapUtils.safeHandleRequestsLimitExceeding();
 	                return composeFailResult(PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+	              } else if ((details == null ? void 0 : details.reason) === SwapProvider.NO_SWAPS_REASONS.NO_FLOATING_BUT_HAVE_FIXED) {
+	                return composeFailResult(PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION);
+	              } else if ((details == null ? void 0 : details.reason) === SwapProvider.NO_SWAPS_REASONS.NO_FIXED_BUT_HAVE_FLOATING) {
+	                return composeFailResult(PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS.NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION);
 	              }
 	            }
 	            var fromAmountBigNumber = bignumber_js.BigNumber(fromAmountCoins);
@@ -6309,7 +6509,7 @@
 	            var toAmountCoins = AmountUtils.trim(fromAmountBigNumber.times(details.rate), fromCoin.digits);
 	            var result = {
 	              result: true,
-	              swapCreationInfo: new BaseSwapCreationInfo(fromCoin, toCoin, fromAmountCoins, toAmountCoins, details.rate, details.rawSwapData, min, fiatMin, max, fiatMax, details.durationMinutesRange)
+	              swapCreationInfo: new BaseSwapCreationInfo(fromCoin, toCoin, fromAmountCoins, toAmountCoins, details.rate, details.rawSwapData, min, fiatMin, max, fiatMax, details.durationMinutesRange, details.fixed)
 	            };
 	            Logger.log("Result: " + safeStringify({
 	              result: result.result,
@@ -6355,7 +6555,8 @@
 	   *             fromCoin: Coin,
 	   *             rate: string,
 	   *             swapId: string,
-	   *             fromCurrencyExtraId: string
+	   *             fromCurrencyExtraId: string,
+	   *             fixed: boolean
 	   *         }|{
 	   *             result: false,
 	   *             reason: string
@@ -6375,7 +6576,7 @@
 	          fromCoin: swapCreationInfo == null || (_swapCreationInfo$fro = swapCreationInfo.fromCoin) == null ? void 0 : _swapCreationInfo$fro.ticker,
 	          toCoin: swapCreationInfo == null || (_swapCreationInfo$toC = swapCreationInfo.toCoin) == null ? void 0 : _swapCreationInfo$toC.ticker
 	        })), loggerSource);
-	        return Promise.resolve(_this8._swapProvider.createSwap(fromCoin, toCoin, fromAmount, toAddress, refundAddress, swapCreationInfo.rawSwapData, clientIp, toCurrencyExtraId, refundExtraId)).then(function (result) {
+	        return Promise.resolve(_this8._swapProvider.createSwap(fromCoin, toCoin, fromAmount, toAddress, refundAddress, swapCreationInfo.rawSwapData, clientIp, swapCreationInfo.fixed, toCurrencyExtraId, refundExtraId)).then(function (result) {
 	          var _exit;
 	          function _temp6(_result8) {
 	            if (_exit) return _result8;
@@ -6405,6 +6606,7 @@
 	            if (result.result && result != null && result.swapId) {
 	              var _temp4 = function _temp4() {
 	                var _result$fromCurrencyE;
+	                // TODO: feature, cirtical] add GA event. task_id=tbd
 	                EventBusInstance__default["default"].dispatch(PublicSwapService.PUBLIC_SWAP_CREATED_EVENT, null, fromCoin.ticker, toCoin.ticker, _fromAmountFiat);
 	                var toReturn = {
 	                  result: true,
@@ -6421,7 +6623,9 @@
 	                  durationMinutesRange: swapCreationInfo.durationMinutesRange,
 	                  address: result.fromAddress,
 	                  // CRITICAL: this is the address to send coins to swaps provider
-	                  fromCurrencyExtraId: (_result$fromCurrencyE = result.fromCurrencyExtraId) != null ? _result$fromCurrencyE : "" // CRITICAL: this is the extra ID for address to send coins to swaps provider
+	                  fromCurrencyExtraId: (_result$fromCurrencyE = result.fromCurrencyExtraId) != null ? _result$fromCurrencyE : "",
+	                  // CRITICAL: this is the extra ID for address to send coins to swaps provider
+	                  fixed: result.fixed
 	                };
 	                _this8._savePublicSwapIdLocally(result.swapId);
 	                Logger.log("Returning: " + safeStringify(_extends({}, toReturn, {
@@ -6682,7 +6886,9 @@
 	PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS = {
 	  AMOUNT_LESS_THAN_MIN_SWAPPABLE: "amountLessThanMinSwappable",
 	  AMOUNT_HIGHER_THAN_MAX_SWAPPABLE: "amountHigherThanMaxSwappable",
-	  PAIR_NOT_SUPPORTED: "pairNotSupported"
+	  PAIR_NOT_SUPPORTED: "pairNotSupported",
+	  NO_FIXED_BUT_HAVE_FLOATING_PUBLIC_SWAP_OPTION: "noFixedButHaveFloatingPublicSwapOption",
+	  NO_FLOATING_BUT_HAVE_FIXED_PUBLIC_SWAP_OPTION: "noFloatingButHaveFixedPublicSwapOption"
 	};
 	PublicSwapService._fiatDecimalsCount = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
 
@@ -6705,6 +6911,8 @@
 	exports.ExistingSwapWithFiatData = ExistingSwapWithFiatData;
 	exports.ExternalApiProvider = ExternalApiProvider;
 	exports.FiatCurrenciesService = FiatCurrenciesService;
+	exports.InputValuesProviders = InputValuesProviders;
+	exports.IpAddressProvider = IpAddressProvider;
 	exports.LoadingDots = LoadingDots;
 	exports.Logger = Logger;
 	exports.LogsStorage = LogsStorage;