@rabbitio/ui-kit 1.0.0-beta.37 → 1.0.0-beta.39

package/dist/index.modern.js

@@ -1,6 +1,8 @@
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { BigNumber } from 'bignumber.js';
 import axios from 'axios';
+import { v4 } from 'uuid';
+import Hashes from 'jshashes';
 import EventBusInstance from 'eventbusjs';
 
 function createCommonjsModule(fn) {
@@ -1599,6 +1601,74 @@ function useReferredState(initialValue) {
   return [reference, setReferredState];
 }
 
+const handleClickOutside = (exceptionsRefs, callback) => {
+  function handleClick(event) {
+    const isExceptionClicked = exceptionsRefs.find(ref => (ref == null ? void 0 : ref.current) && ref.current.contains(event.target));
+    if (!isExceptionClicked) {
+      callback();
+    }
+  }
+  document.addEventListener("click", handleClick);
+  return () => document.removeEventListener("click", handleClick);
+};
+
+const PARAMETER_VALUES_SEPARATOR = "|*|"; // Sting that with high probability will not be in the user's data
+
+/**
+ * Adds specified parameter with values to the URL query string
+ *
+ * @param parameterName - String - name of the parameter
+ * @param values - Array of String values
+ * @param updateURLCallback - callback that will be called with the updated query string. Can be used to save it to URL
+ */
+function saveQueryParameterAndValues(parameterName, values, updateURLCallback = newQueryString => {}) {
+  let parametersAndValues = parseSearchString();
+  parametersAndValues = parametersAndValues.filter(parameterAndValues => parameterAndValues[0] !== parameterName);
+  const parameterValuesForURL = encodeURIComponent(values.join(PARAMETER_VALUES_SEPARATOR));
+  parametersAndValues.push([parameterName, parameterValuesForURL]);
+  const newQueryString = `?${parametersAndValues.map(parameterAndValues => parameterAndValues.join("=")).join("&")}`;
+  updateURLCallback(newQueryString);
+  return newQueryString;
+}
+
+/**
+ * Removes specified parameter with values from the URL query string
+ *
+ * @param parameterName - String - name of the parameter
+ * @param updateURLCallback - callback that will be called with the updated query string. Can be used to save it to URL
+ */
+// TODO: [tests, moderate] units required the same as or other functions in this module
+function removeQueryParameterAndValues(parameterName, updateURLCallback = newQueryString => {}) {
+  let parametersAndValues = parseSearchString();
+  parametersAndValues = parametersAndValues.filter(parameterAndValues => parameterAndValues[0] !== parameterName);
+  const newQueryString = `?${parametersAndValues.map(parameterAndValues => parameterAndValues.join("=")).join("&")}`;
+  updateURLCallback(newQueryString);
+  return newQueryString;
+}
+
+/**
+ * Retrieves parameter values from the URL query string.
+ *
+ * If there are several parameters with the same name in the URL then all their values are returned
+ *
+ * @param name {string} - parameter name
+ * @return {string[]} [] - if the parameter is not present in URL. [""] - if parameter present but has empty value
+ */
+function getQueryParameterValues(name) {
+  return parseSearchString().filter(parameterAndValue => parameterAndValue[0] === name).reduce((allValues, parameterAndValue) => {
+    const values = decodeURIComponent(parameterAndValue[1] || "").split(PARAMETER_VALUES_SEPARATOR);
+    return [...allValues, ...values];
+  }, []);
+}
+function parseSearchString() {
+  var _window$location$sear;
+  const trimmed = (((_window$location$sear = window.location.search) == null ? void 0 : _window$location$sear.slice(1)) || "").trim();
+  return trimmed && trimmed.split("&").map(parameterAndValue => parameterAndValue.split("=")) || [];
+}
+function getQueryParameterSingleValue(name) {
+  return (getQueryParameterValues(name) || [])[0];
+}
+
 /**
  * This function improves the passed error object (its message) by adding the passed function name
  * and additional message to it.
@@ -1624,6 +1694,17 @@ function improvedErrorMessage(e, settingFunction, additionalMessage) {
   additionalMessage && (message += `${additionalMessage} `);
   return message;
 }
+function logErrorOrOutputToConsole(e) {
+  try {
+    // TODO: [dev] remove this after few weeks of testing output in real life
+    // eslint-disable-next-line no-console
+    console.log("BEFORE SAFE", e);
+    Logger.log("logErrorOrOutputToConsole", safeStringify(e));
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.log("logErrorOrOutputToConsole", e);
+  }
+}
 
 class FiatCurrenciesService {
   static getFullCurrencyNameByCode(code = "") {
@@ -2366,6 +2447,45 @@ class Cache {
   }
 }
 
+function postponeExecution(execution, timeoutMS = 1000) {
+  return new Promise((resolve, reject) => {
+    setTimeout(async () => {
+      try {
+        resolve(await execution());
+      } catch (e) {
+        reject(e);
+      }
+    }, timeoutMS);
+  });
+}
+
+class AxiosAdapter {
+  static async call(method, ...args) {
+    return await axios[method](...args);
+  }
+  static async get(...args) {
+    return await axios.get(...args);
+  }
+  static async post(...args) {
+    return await axios.post(...args);
+  }
+  static async put(...args) {
+    return await axios.put(...args);
+  }
+  static async delete(...args) {
+    return await axios.delete(...args);
+  }
+  static async patch(...args) {
+    return await axios.patch(...args);
+  }
+  static async options(...args) {
+    return await axios.options(...args);
+  }
+  static async head(...args) {
+    return await axios.head(...args);
+  }
+}
+
 class EmailsApi {
   static async sendEmail(subject, body) {
     try {
@@ -2381,6 +2501,1078 @@ class EmailsApi {
 }
 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
+ */
+class CacheAndConcurrentRequestsResolver {
+  /**
+   * @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}
+   */
+  constructor(bio, cache, cacheTtl, removeExpiredCacheAutomatically = true, maxCallAttemptsToWaitForAlreadyRunningRequest = 100, 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
+   *         })>}
+   */
+  async getCachedOrWaitForCachedOrAcquireLock(cacheId) {
+    try {
+      var _cached2;
+      const startedAtTimestamp = Date.now();
+      let cached = this._cache.get(cacheId);
+      let cachedDataBackupIsPresentButExpired = null;
+      if (cached != null && !this._removeExpiredCacheAutomatically) {
+        const 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;
+        }
+      }
+      let calculationId = null;
+      let isRetrievedCacheExpired = true;
+      let isWaitingForActiveCalculationSucceeded;
+      let weStillHaveSomeTimeToProceedExecution = true;
+      while (calculationId == null && cached == null && isRetrievedCacheExpired && weStillHaveSomeTimeToProceedExecution) {
+        const result = await this._requestsManager.startCalculationOrWaitForActiveToFinish(cacheId);
+        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;
+      }
+      if (calculationId) {
+        var _cached;
+        return {
+          canStartDataRetrieval: true,
+          cachedData: (_cached = cached) != null ? _cached : cachedDataBackupIsPresentButExpired,
+          lockId: calculationId
+        };
+      }
+      return {
+        canStartDataRetrieval: false,
+        cachedData: (_cached2 = cached) != null ? _cached2 : cachedDataBackupIsPresentButExpired
+      };
+    } catch (e) {
+      improveAndRethrow(e, `${this._bio}.getCachedOrWaitForCachedOrAcquireLock`);
+    }
+  }
+
+  /**
+   * 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}
+   */
+  getCached(cacheId) {
+    try {
+      return this._cache.get(cacheId);
+    } catch (e) {
+      improveAndRethrow(e, "getCached");
+    }
+  }
+  _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 }>}
+   */
+  async acquireLock(cacheId) {
+    try {
+      return await this._requestsManager.acquireLock(cacheId);
+    } catch (e) {
+      improveAndRethrow(e, "acquireLock");
+    }
+  }
+
+  /**
+   * 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]
+   */
+  saveCachedData(cacheId, lockId, data, sessionDependentData = true, wasDataMergedSynchronouslyWithMostRecentCacheState = false) {
+    try {
+      if (wasDataMergedSynchronouslyWithMostRecentCacheState || this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
+        /* We save passed data only if the <caller> has the currently acquired lockId.
+         * If the passed lockId is not the active one it means that other code cleared/stopped the lock
+         * acquired by the <caller> recently due to some urgent/more prior changes.
+         *
+         * But we allow user to pass the 'wasDataMergedSynchronouslyWithMostRecentCacheState' flag
+         * that tells us that the user had taken the most recent cache value and merged his new data
+         * with that cached value (AFTER possibly performing async data retrieval). This means that we
+         * can ignore the fact that his lockId is no more relevant and save the passed data
+         * as it is synchronously merged with the most recent cached data. (Synchronously merged means that
+         * the lost update cannot occur during the merge time as JS execute the synchronous functions\
+         * till the end).
+         */
+        if (sessionDependentData) {
+          this._cache.putSessionDependentData(cacheId, data, this._getTtl());
+        } else {
+          this._cache.put(cacheId, data, this._getTtl());
+        }
+      }
+    } catch (e) {
+      improveAndRethrow(e, `${this._bio}.saveCachedData`);
+    }
+  }
+
+  /**
+   * Should be called then and only then if you successfully acquired a lock with the lock id.
+   *
+   * @param cacheId {string}
+   * @param lockId {string}
+   */
+  releaseLock(cacheId, lockId) {
+    try {
+      if (this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
+        this._requestsManager.finishActiveCalculation(cacheId);
+      }
+    } catch (e) {
+      improveAndRethrow(e, `${this._bio}.releaseLock`);
+    }
+  }
+
+  /**
+   * Actualized currently present cached data by key. Applies the provided function to the cached data.
+   *
+   * @param cacheId {string} id of cache entry
+   * @param synchronousCurrentCacheProcessor (function|null} synchronous function accepting cache entry. Should return
+   *        an object in following format:
+   *        {
+   *            isModified: boolean,
+   *            data: any
+   *        }
+   *        the flag signals whether data was changed during the processing or not
+   * @param [sessionDependent=true] {boolean} whether to mark the cache entry as session-dependent
+   */
+  actualizeCachedData(cacheId, synchronousCurrentCacheProcessor, sessionDependent = true) {
+    try {
+      const cached = this._cache.get(cacheId);
+      const result = synchronousCurrentCacheProcessor(cached);
+      if (result != null && result.isModified && (result == null ? void 0 : result.data) != null) {
+        if (sessionDependent) {
+          this._cache.putSessionDependentData(cacheId, result == null ? void 0 : result.data, this._getTtl());
+        } else {
+          this._cache.put(cacheId, result == null ? void 0 : result.data, this._getTtl());
+        }
+
+        /* Here we call the lock releasing to ensure the currently active calculation will be ignored.
+         * This is needed to ensure no 'lost update'.
+         * Lost update can occur if we change data in this method and after that some calculation finishes
+         * having the earlier data as its base to calculate its data set result. And the earlier data
+         * has no changes applied inside this method, so we will lose them.
+         *
+         * This is not so good solution: ideally, we should acquire lock before performing any data updating.
+         * But the goal of this method is to provide an instant ability to update the cached data.
+         * And if we start acquiring the lock here the data update can be postponed significantly.
+         * And this kills the desired nature of this method.
+         * So we better lose some data retrieval (means abusing the resource a bit) than lose
+         * the instant update expected after this method execution.
+         */
+        this._requestsManager.finishActiveCalculation(cacheId);
+      }
+    } catch (e) {
+      improveAndRethrow(e, `${this._bio}.actualizeCachedData`);
+    }
+  }
+  invalidate(key) {
+    this._cache.invalidate(key);
+    this._requestsManager.finishActiveCalculation(key);
+  }
+  invalidateContaining(keyPart) {
+    this._cache.invalidateContaining(keyPart);
+    this._requestsManager.finishAllActiveCalculations(keyPart);
+  }
+  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);
+  }
+}
+
+/**
+ * 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).
+ */
+class ManagerOfRequestsToTheSameResource {
+  /**
+   * @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
+   */
+  constructor(bio, maxPollsCount = 100, timeoutDuration = 1000) {
+    this.bio = bio;
+    this.maxPollsCount = maxPollsCount;
+    this.timeoutDuration = timeoutDuration;
+    this._activeCalculationsIds = new Map();
+    this._nextCalculationIds = new Map();
+  }
+
+  /**
+   * If there is no active calculation just creates uuid and returns it.
+   * If there is active calculation waits until it removed from the active calculation uuid variable.
+   *
+   * @param requestHash {string}
+   * @return {Promise<string|boolean>} returns uuid of new active calculation or true if waiting for active
+   *         calculation succeed or false if max attempts count exceeded
+   */
+  async startCalculationOrWaitForActiveToFinish(requestHash) {
+    try {
+      const activeCalculationIdForHash = this._activeCalculationsIds.get(requestHash);
+      if (activeCalculationIdForHash == null) {
+        const id = v4();
+        this._activeCalculationsIds.set(requestHash, id);
+        return id;
+      }
+      return await this._waitForCalculationIdToFinish(requestHash, activeCalculationIdForHash, 0);
+    } catch (e) {
+      Logger.logError(e, `startCalculationOrWaitForActiveToFinish_${this.bio}`);
+    }
+    return null;
+  }
+
+  /**
+   * 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.
+   */
+  async acquireLock(requestHash) {
+    try {
+      var _this$_nextCalculatio;
+      const activeId = this._activeCalculationsIds.get(requestHash);
+      const nextId = v4();
+      if (activeId == null) {
+        this._activeCalculationsIds.set(requestHash, nextId);
+        return {
+          result: true,
+          lockId: nextId
+        };
+      }
+      const currentNext = (_this$_nextCalculatio = this._nextCalculationIds.get(requestHash)) != null ? _this$_nextCalculatio : [];
+      currentNext.push(nextId);
+      this._nextCalculationIds.set(requestHash, currentNext);
+      const waitingResult = await this._waitForCalculationIdToFinish(requestHash, activeId, 0, nextId);
+      return {
+        result: waitingResult,
+        lockId: waitingResult ? nextId : undefined
+      };
+    } catch (e) {
+      improveAndRethrow(e, "acquireLock");
+    }
+  }
+
+  /**
+   * 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
+   */
+  finishActiveCalculation(requestHash = "default") {
+    try {
+      var _this$_nextCalculatio2;
+      this._activeCalculationsIds.delete(requestHash);
+      const next = (_this$_nextCalculatio2 = this._nextCalculationIds.get(requestHash)) != null ? _this$_nextCalculatio2 : [];
+      if (next.length) {
+        this._activeCalculationsIds.set(requestHash, next[0]);
+        this._nextCalculationIds.set(requestHash, next.slice(1));
+      }
+    } catch (e) {
+      improveAndRethrow(e, "finishActiveCalculation");
+    }
+  }
+  finishAllActiveCalculations(keyPart = "") {
+    try {
+      Array.from(this._activeCalculationsIds.keys()).forEach(hash => {
+        if (typeof hash === "string" && new RegExp(keyPart).test(hash)) {
+          this.finishActiveCalculation(hash);
+        }
+      });
+    } catch (e) {
+      improveAndRethrow(e, "finishAllActiveCalculations");
+    }
+  }
+
+  /**
+   * @param requestHash {string}
+   * @param lockId {string}
+   * @return {boolean}
+   */
+  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
+   */
+  async _waitForCalculationIdToFinish(requestHash, activeCalculationId, attemptIndex = 0, waitForCalculationId = null) {
+    try {
+      if (attemptIndex + 1 > this.maxPollsCount) {
+        // Max number of polls for active calculation id change is achieved. So we return false.
+        return false;
+      }
+      const currentId = this._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 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.
+         */
+        const it = this;
+        return new Promise((resolve, reject) => {
+          setTimeout(function () {
+            try {
+              resolve(it._waitForCalculationIdToFinish(requestHash, activeCalculationId, attemptIndex + 1));
+            } catch (e) {
+              reject(e);
+            }
+          }, this.timeoutDuration);
+        });
+      }
+    } catch (e) {
+      Logger.logError(e, "_waitForCalculationIdToFinish", "Failed to wait for active calculation id change.");
+      return false;
+    }
+  }
+}
+
+// TODO: [refactoring, low] Consider removing this logic task_id=c360f2af75764bde8badd9ff1cc00d48
+class ConcurrentCalculationsMetadataHolder {
+  constructor() {
+    this._calculations = {};
+  }
+  startCalculation(domain, 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));
+    }
+    const newCalculation = {
+      startTimestamp: Date.now(),
+      endTimestamp: null,
+      uuid: v4()
+    };
+    this._calculations[domain].push(newCalculation);
+    return newCalculation.uuid;
+  }
+  endCalculation(domain, uuid, isFailed = false) {
+    try {
+      var _calculation$endTimes, _calculation$startTim, _calculation$uuid;
+      const calculation = this._calculations[domain].find(calculation => (calculation == null ? void 0 : calculation.uuid) === uuid);
+      if (calculation) {
+        calculation.endTimestamp = Date.now();
+        calculation.isFiled = isFailed;
+      }
+      const 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");
+    }
+  }
+  isCalculationLate(domain, uuid) {
+    const queue = this._calculations[domain];
+    const analysingCalculation = queue.find(item => item.uuid === uuid);
+    return analysingCalculation && !!queue.find(calculation => calculation.endTimestamp != null && calculation.startTimestamp > analysingCalculation.startTimestamp);
+  }
+  printCalculationsWaitingMoreThanSpecifiedSeconds(waitingLastsMs = 2000) {
+    const calculations = Object.keys(this._calculations).map(domain => this._calculations[domain].map(c => _extends({}, c, {
+      domain
+    }))).flat().filter(c => c.endTimestamp === null && Date.now() - c.startTimestamp > waitingLastsMs);
+    Logger.log("printCalculationsWaitingMoreThanSpecifiedSeconds", `Calculations waiting more than ${(waitingLastsMs / 1000).toFixed(1)}s:\n` + calculations.map(c => `${c.domain}.${c.uuid.slice(0, 8)}: ${Date.now() - c.startTimestamp}\n`));
+  }
+}
+const concurrentCalculationsMetadataHolder = new ConcurrentCalculationsMetadataHolder();
+
+class ExternalServicesStatsCollector {
+  constructor() {
+    this.stats = new Map();
+  }
+  externalServiceFailed(serviceUrl, message) {
+    try {
+      const processMessage = (stat, errorMessage) => {
+        var _stat$errors, _errorMessage;
+        const errors = (_stat$errors = stat.errors) != null ? _stat$errors : {};
+        errorMessage = (_errorMessage = errorMessage) != null ? _errorMessage : "";
+        if (errorMessage.match(/.*network.+error.*/i)) {
+          errors["networkError"] = (errors["networkError"] || 0) + 1;
+        } else if (errorMessage.match(/.*timeout.+exceeded.*/i)) {
+          errors["timeoutExceeded"] = (errors["timeoutExceeded"] || 0) + 1;
+        } else if (errors["other"]) {
+          errors["other"].push(message);
+        } else {
+          errors["other"] = [message];
+        }
+        stat.errors = errors;
+      };
+      if (this.stats.has(serviceUrl)) {
+        const stat = this.stats.get(serviceUrl);
+        stat.callsCount += 1;
+        stat.failsCount += 1;
+        processMessage(stat, message);
+      } else {
+        this.stats.set(serviceUrl, {
+          callsCount: 1,
+          failsCount: 1
+        });
+        processMessage(this.stats.get(serviceUrl), message);
+      }
+    } catch (e) {
+      improveAndRethrow(e, "externalServiceFailed");
+    }
+  }
+  externalServiceCalledWithoutError(serviceUrl) {
+    try {
+      if (this.stats.has(serviceUrl)) {
+        const stat = this.stats.get(serviceUrl);
+        stat.callsCount += 1;
+      } else {
+        this.stats.set(serviceUrl, {
+          callsCount: 1,
+          failsCount: 0
+        });
+      }
+    } catch (e) {
+      improveAndRethrow(e, "externalServiceCalledWithoutError");
+    }
+  }
+
+  /**
+   * Returns statistics about external services failures.
+   * Provides how many calls were performed and what the percent of failed calls. Also returns errors stat.
+   *
+   * @return {Array<object>} Array of objects of type { failsPerCent: number, calls: number }
+   *                         sorted by the highest fails percent desc
+   */
+  getStats() {
+    try {
+      return Array.from(this.stats.keys()).map(key => {
+        var _stat$errors2;
+        const stat = this.stats.get(key);
+        return {
+          url: key,
+          failsPerCent: (stat.failsCount / stat.callsCount * 100).toFixed(2),
+          calls: stat.callsCount,
+          errors: (_stat$errors2 = stat.errors) != null ? _stat$errors2 : []
+        };
+      }).sort((s1, s2) => s1.failsPerCent - s2.failsPerCent);
+    } catch (e) {
+      Logger.logError(e, "getStats");
+    }
+  }
+}
+
+/**
+ * TODO: [refactoring, critical] update backend copy of this service. Also there is a task to extract this
+ *                               service and other related to it stuff to dedicated npm package task_id=b008ee5e4a3f42c08c73831c4bb3db4e
+ *
+ * Template service needed to avoid duplication of the same logic when we need to call
+ * external APIs to retrieve some data. The idea is to use several API providers to retrieve the same data. It helps to
+ * improve the reliability of a data retrieval.
+ */
+class RobustExternalAPICallerService {
+  static 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
+   */
+  constructor(bio, providersData, logger = Logger.logError) {
+    providersData.forEach(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(provider => provider.resetNiceFactor());
+    this.bio = bio;
+    this._logger = Logger.logError;
+  }
+  /**
+   * 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
+   */
+  async callExternalAPI(parametersValues = [], timeoutMS = 3500, cancelToken = null, attemptsCount = 1, doNotFailForNowData = false) {
+    var _this = this;
+    let result;
+    const calculationUuid = concurrentCalculationsMetadataHolder.startCalculation(this.bio);
+    try {
+      var _result4, _result5;
+      for (let i = 0; (i < attemptsCount || (_result = result) != null && _result.shouldBeForceRetried) && ((_result2 = result) == null ? void 0 : _result2.data) == null; ++i) {
+        var _result, _result2;
+        /**
+         * 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.
+         */
+        const rpsFactor = result ? result.rpsFactor : RobustExternalAPICallerService.defaultRPSFactor;
+        result = null;
+        try {
+          var _result3, _result$errors;
+          if (i === 0 && !((_result3 = result) != null && _result3.shouldBeForceRetried)) {
+            result = await this._performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData);
+          } else {
+            const maxRps = Math.max(...this.providers.map(provider => {
+              var _provider$getRps;
+              return (_provider$getRps = provider.getRps()) != null ? _provider$getRps : 0;
+            }));
+            const waitingTimeMs = maxRps ? 1000 / (maxRps / rpsFactor) : 0;
+            result = await new Promise((resolve, reject) => {
+              setTimeout(async function () {
+                try {
+                  resolve(await _this._performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData));
+                } catch (e) {
+                  reject(e);
+                }
+              }, waitingTimeMs);
+            });
+          }
+          if ((_result$errors = result.errors) != null && _result$errors.length) {
+            const errors = result.errors;
+            this._logger(new Error(`Failed at attempt ${i}. ${errors.length} errors. Messages: ${safeStringify(errors.map(error => error.message))}: ${safeStringify(errors)}.`), `${this.bio}.callExternalAPI`, "", true);
+          }
+        } catch (e) {
+          this._logger(e, `${this.bio}.callExternalAPI`, "Failed to perform external providers calling");
+        }
+      }
+      if (((_result4 = result) == null ? void 0 : _result4.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
+        const 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 (_result5 = result) == null ? void 0 : _result5.data;
+    } catch (e) {
+      improveAndRethrow(e, `${this.bio}.callExternalAPI`);
+    } finally {
+      concurrentCalculationsMetadataHolder.endCalculation(this.bio, calculationUuid);
+    }
+  }
+  async _performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData) {
+    var _data;
+    const providers = this._reorderProvidersByNiceFactor();
+    let data = undefined,
+      providerIndex = 0,
+      countOfRequestsDeclinedByRps = 0,
+      errors = [];
+    while (!data && providerIndex < providers.length) {
+      let 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;
+        continue;
+      }
+      try {
+        var _provider$specificHea;
+        const axiosConfig = _extends({}, cancelToken ? {
+          cancelToken
+        } : {}, {
+          timeout: provider.timeout || timeoutMS,
+          headers: (_provider$specificHea = provider.specificHeaders) != null ? _provider$specificHea : {}
+        });
+        const httpMethods = Array.isArray(provider.httpMethod) ? provider.httpMethod : [provider.httpMethod];
+        const iterationsData = [];
+        for (let subRequestIndex = 0; subRequestIndex < httpMethods.length; ++subRequestIndex) {
+          const query = provider.composeQueryString(parametersValues, subRequestIndex);
+          const endpoint = `${provider.endpoint}${query}`;
+          const axiosParams = [endpoint, axiosConfig];
+          if (["post", "put", "patch"].find(method => method === httpMethods[subRequestIndex])) {
+            var _provider$composeBody;
+            const body = (_provider$composeBody = provider.composeBody(parametersValues, subRequestIndex)) != null ? _provider$composeBody : null;
+            axiosParams.splice(1, 0, body);
+          }
+          let pageNumber = 0;
+          const responsesForPages = [];
+          let hasNextPage = provider.doesSupportPagination();
+          do {
+            if (subRequestIndex === 0 && pageNumber === 0) {
+              provider.actualizeLastCalledTimestamp();
+              responsesForPages[pageNumber] = await AxiosAdapter.call(httpMethods[subRequestIndex], ...axiosParams);
+              RobustExternalAPICallerService.statsCollector.externalServiceCalledWithoutError(provider.getApiGroupId());
+            } else {
+              if (pageNumber > 0) {
+                const actualizedParams = provider.changeQueryParametersForPageNumber(parametersValues, responsesForPages[pageNumber - 1], pageNumber, subRequestIndex);
+                const _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)
+               */
+
+              const waitingTimeMS = provider.getRps() ? 1000 / (provider.getRps() / rpsFactor) : 0;
+              const postponeUntilRpsExceeded = async function postponeUntilRpsExceeded(recursionLevel = 0) {
+                return await postponeExecution(async function () {
+                  const maxCountOfPostponingAttempts = 2;
+                  if (provider.isRpsExceeded() && recursionLevel < maxCountOfPostponingAttempts) {
+                    return await postponeUntilRpsExceeded(recursionLevel + 1);
+                  }
+                  provider.actualizeLastCalledTimestamp();
+                  return await AxiosAdapter.call(httpMethods[subRequestIndex], ...axiosParams);
+                }, waitingTimeMS);
+              };
+              responsesForPages[pageNumber] = await postponeUntilRpsExceeded();
+            }
+            if (hasNextPage) {
+              hasNextPage = !provider.checkWhetherResponseIsForLastPage(responsesForPages[pageNumber - 1], responsesForPages[pageNumber], pageNumber, subRequestIndex);
+            }
+            pageNumber++;
+          } while (hasNextPage);
+          const responsesDataForPages = responsesForPages.map(response => provider.getDataByResponse(response, parametersValues, subRequestIndex, iterationsData));
+          let allData = responsesDataForPages;
+          if (Array.isArray(responsesDataForPages[0])) {
+            allData = responsesDataForPages.flat();
+          } else if (responsesDataForPages.length === 1) {
+            allData = responsesDataForPages[0];
+          }
+          iterationsData.push(allData);
+        }
+        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);
+        }
+      } catch (e) {
+        punishProvider(provider);
+        RobustExternalAPICallerService.statsCollector.externalServiceFailed(provider.getApiGroupId(), e == null ? void 0 : e.message);
+        errors.push(e);
+      } finally {
+        providerIndex++;
+      }
+    }
+
+    // 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
+    const shouldBeForceRetried = data == null && countOfRequestsDeclinedByRps > Math.floor(providers.length * 0.5);
+    const rpsMultiplier = shouldBeForceRetried ? RobustExternalAPICallerService.rpsMultiplier : 1;
+    return {
+      data: (_data = data) != null ? _data : null,
+      shouldBeForceRetried,
+      rpsFactor: rpsFactor * rpsMultiplier,
+      errors
+    };
+  }
+  _reorderProvidersByNiceFactor() {
+    const providersCopy = [...this.providers];
+    return providersCopy.sort((p1, p2) => p2.niceFactor - p1.niceFactor);
+  }
+}
+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
+ * to the same resource.
+ * TODO: [tests, critical] Massively used logic
+ */
+class CachedRobustExternalApiCallerService {
+  /**
+   * @param bio {string} unique service identifier
+   * @param cache {Cache} cache instance
+   * @param providersData {ExternalApiProvider[]} array of providers
+   * @param [cacheTtlMs=10000] {number} time to live for cache ms
+   * @param [maxCallAttemptsToWaitForAlreadyRunningRequest=50] {number} see details in CacheAndConcurrentRequestsResolver
+   * @param [timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished=3000] {number} see details in CacheAndConcurrentRequestsResolver
+   * @param [removeExpiredCacheAutomatically=true] {boolean} whether to remove cached data automatically when ttl exceeds
+   * @param [mergeCachedAndNewlyRetrievedData=null] {function} function accepting cached data, newly retrieved data and id field name for list items
+   *        and merging them. use if needed
+   */
+  constructor(bio, cache, providersData, cacheTtlMs = 10000, removeExpiredCacheAutomatically = true, mergeCachedAndNewlyRetrievedData = null, maxCallAttemptsToWaitForAlreadyRunningRequest = 100, timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished = 1000) {
+    this._provider = new RobustExternalAPICallerService(`cached_${bio}`, providersData, Logger.logError);
+    this._cacheTtlMs = cacheTtlMs;
+    this._cahceAndRequestsResolver = new CacheAndConcurrentRequestsResolver(bio, cache, cacheTtlMs, removeExpiredCacheAutomatically, maxCallAttemptsToWaitForAlreadyRunningRequest, timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished);
+    this._cahceIds = [];
+    this._mergeCachedAndNewlyRetrievedData = mergeCachedAndNewlyRetrievedData;
+  }
+
+  /**
+   * Calls the external API or returns data from cache. Just waits if the same data already requested.
+   *
+   * @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 [customHashFunctionForParams] {function|undefined} function without params calculating the hash to be
+   *        added to bio of the service to compose a unique parameters-specific cache id
+   * @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
+   */
+  async callExternalAPICached(parametersValues = [], timeoutMS = 3500, cancelToken = null, attemptsCount = 1, customHashFunctionForParams = null, doNotFailForNowData = false) {
+    const loggerSource = `${this._provider.bio}.callExternalAPICached`;
+    let cacheId;
+    let result;
+    try {
+      var _result;
+      cacheId = this._calculateCacheId(parametersValues, customHashFunctionForParams);
+      result = await this._cahceAndRequestsResolver.getCachedOrWaitForCachedOrAcquireLock(cacheId);
+      if (!((_result = result) != null && _result.canStartDataRetrieval)) {
+        var _result2;
+        return (_result2 = result) == null ? void 0 : _result2.cachedData;
+      }
+      let data = await this._provider.callExternalAPI(parametersValues, timeoutMS, cancelToken, attemptsCount, doNotFailForNowData);
+      const canPerformMerge = typeof this._mergeCachedAndNewlyRetrievedData === "function";
+      if (canPerformMerge) {
+        const mostRecentCached = this._cahceAndRequestsResolver.getCached(cacheId);
+        data = this._mergeCachedAndNewlyRetrievedData(mostRecentCached, data, parametersValues);
+      }
+      if (data != null) {
+        var _result3;
+        this._cahceAndRequestsResolver.saveCachedData(cacheId, (_result3 = result) == null ? void 0 : _result3.lockId, data, true, canPerformMerge);
+        this._cahceIds.indexOf(cacheId) < 0 && this._cahceIds.push(cacheId);
+      }
+      return data;
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    } finally {
+      var _result4;
+      this._cahceAndRequestsResolver.releaseLock(cacheId, (_result4 = result) == null ? void 0 : _result4.lockId);
+    }
+  }
+  invalidateCaches() {
+    this._cahceIds.forEach(key => this._cahceAndRequestsResolver.invalidate(key));
+  }
+  actualizeCachedData(params, synchronousCurrentCacheProcessor, customHashFunctionForParams = null, sessionDependent = true, actualizedAtTimestamp) {
+    const cacheId = this._calculateCacheId(params, customHashFunctionForParams);
+    this._cahceAndRequestsResolver.actualizeCachedData(cacheId, synchronousCurrentCacheProcessor, sessionDependent);
+  }
+  markCacheAsExpiredButDontRemove(parametersValues, customHashFunctionForParams) {
+    try {
+      this._cahceAndRequestsResolver.markAsExpiredButDontRemove(this._calculateCacheId(parametersValues, customHashFunctionForParams));
+    } catch (e) {
+      improveAndRethrow(e, "markCacheAsExpiredButDontRemove");
+    }
+  }
+  _calculateCacheId(parametersValues, customHashFunctionForParams = null) {
+    try {
+      const hash = typeof customHashFunctionForParams === "function" ? customHashFunctionForParams(parametersValues) : !parametersValues ? "" : new Hashes.SHA512().hex(safeStringify(parametersValues));
+      return `${this._provider.bio}-${hash}`;
+    } catch (e) {
+      improveAndRethrow(e, this._provider.bio + "_calculateCacheId");
+    }
+  }
+}
+
+/**
+ * Utils class needed to perform cancelling of axios request inside some process.
+ * Provides cancel state and axios token for HTTP requests
+ */
+class CancelProcessing {
+  constructor() {
+    this._cancelToken = axios.CancelToken.source();
+    this._isCanceled = false;
+  }
+  cancel() {
+    this._isCanceled = true;
+    this._cancelToken.cancel();
+  }
+  isCanceled() {
+    return this._isCanceled;
+  }
+  getToken() {
+    return this._cancelToken.token;
+  }
+  static instance() {
+    return new CancelProcessing();
+  }
+}
+
+class ExternalApiProvider {
+  /**
+   * 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
+   */
+  constructor(endpoint, httpMethod, timeout, apiGroup, specificHeaders = {}, 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 != null ? maxPageLength : Number.MAX_SAFE_INTEGER;
+    this.niceFactor = 1;
+    this.specificHeaders = specificHeaders != null ? specificHeaders : {};
+  }
+  getRps() {
+    var _this$apiGroup$rps;
+    return (_this$apiGroup$rps = this.apiGroup.rps) != null ? _this$apiGroup$rps : 2;
+  }
+  isRpsExceeded() {
+    return this.apiGroup.isRpsExceeded();
+  }
+  actualizeLastCalledTimestamp() {
+    this.apiGroup.actualizeLastCalledTimestamp();
+  }
+  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
+   */
+  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
+   */
+  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
+   */
+  composeQueryString(params, subRequestIndex = 0) {
+    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}
+   */
+  composeBody(params, subRequestIndex = 0) {
+    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}
+   */
+  getDataByResponse(response, params = [], subRequestIndex = 0, 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[]}
+   */
+  changeQueryParametersForPageNumber(params, previousResponse, pageNumber, subRequestIndex = 0) {
+    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}
+   */
+  checkWhetherResponseIsForLastPage(previousResponse, currentResponse, currentPageNumber, subRequestIndex = 0) {
+    return true;
+  }
+
+  /**
+   * Resets the nice factor to default value
+   */
+  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.
+   */
+  incorporateIterationsData(iterationsData) {
+    return iterationsData.flat();
+  }
+}
+
 class ExistingSwap {
   /**
    * @param swapId {string}
@@ -3848,5 +5040,5 @@ PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS = {
 };
 PublicSwapService._fiatDecimalsCount = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
 
-export { AmountUtils, AssetIcon, BaseSwapCreationInfo, Blockchain, Button, Cache, Coin, EmailsApi, ExistingSwap, ExistingSwapWithFiatData, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, PublicSwapService, SupportChat, SwapProvider, SwapUtils, SwapspaceSwapProvider, improveAndRethrow, safeStringify, useCallHandlingErrors, useReferredState };
+export { AmountUtils, AssetIcon, AxiosAdapter, BaseSwapCreationInfo, Blockchain, Button, Cache, CacheAndConcurrentRequestsResolver, CachedRobustExternalApiCallerService, CancelProcessing, Coin, EmailsApi, ExistingSwap, ExistingSwapWithFiatData, ExternalApiProvider, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, PublicSwapService, RobustExternalAPICallerService, SupportChat, SwapProvider, SwapUtils, SwapspaceSwapProvider, getQueryParameterSingleValue, getQueryParameterValues, handleClickOutside, improveAndRethrow, logErrorOrOutputToConsole, postponeExecution, removeQueryParameterAndValues, safeStringify, saveQueryParameterAndValues, useCallHandlingErrors, useReferredState };
 //# sourceMappingURL=index.modern.js.map