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

package/dist/index.modern.js

@@ -1,9 +1,9 @@
 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';
+import Hashes from 'jshashes';
+import { v4 } from 'uuid';
 
 function createCommonjsModule(fn) {
   var module = { exports: {} };
@@ -1612,6 +1612,52 @@ const handleClickOutside = (exceptionsRefs, callback) => {
   return () => document.removeEventListener("click", handleClick);
 };
 
+class 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
+   */
+  static provideFormatOfFloatValueByInputString(inputString, digitsAfterDot = 2, maxValue = null) {
+    var _parts$2;
+    let 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
+
+    let parts = value.split(".");
+    if (parts.length > 2) {
+      // removes all after second dot and itself
+      parts = [parts[0], parts[1]];
+    }
+    if (maxValue != null) {
+      var _parts$;
+      const maxDigitsCountBeforeTheDot = 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(".");
+  }
+}
+
 const PARAMETER_VALUES_SEPARATOR = "|*|"; // Sting that with high probability will not be in the user's data
 
 /**
@@ -1919,11 +1965,13 @@ class AmountUtils {
   }
 
   /**
+   * 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}
    */
-  static intStr(amount) {
+  static toIntegerString(amount) {
     return this.trim(amount, 0);
   }
 
@@ -2004,7 +2052,7 @@ class AmountUtils {
           leftNumber = leftNumber.times(multiplier);
         }
       }
-      const leftAmountString = AmountUtils.intStr(leftNumber);
+      const leftAmountString = AmountUtils.toIntegerString(leftNumber);
       const rightAmountString = right != null ? right.toFixed(rightCurrencyDigitsAfterDots, BigNumber.ROUND_FLOOR) : null;
       return `${leftAmountString} ${leftTicker} ~ ${rightAmountString != null ? rightAmountString : "?"} ${rightTicker}`;
     } catch (e) {
@@ -2225,10 +2273,10 @@ class Coin {
  */
 class Cache {
   /**
-   * @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
    */
-  constructor(eventBus, noSessionEvents = []) {
+  constructor(eventBus = null, noSessionEvents = []) {
     this._cache = new Map();
     this._eventDependentDataKeys = [];
     this._noSessionEvents = noSessionEvents;
@@ -2303,7 +2351,7 @@ class Cache {
         const eventAndKeys = this._eventDependentDataKeys.find(item => item[0] === event);
         if (eventAndKeys) {
           eventAndKeys.push(key);
-        } else {
+        } else if (this._eventBus) {
           this._eventDependentDataKeys.push([event, key]);
           this._eventBus.addEventListener(event, () => {
             try {
@@ -2501,456 +2549,220 @@ 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 {
+class ExternalApiProvider {
   /**
-   * @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}
+   * 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(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);
+  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;
   }
 
   /**
-   * 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.
+   * 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.
    *
-   * @param cacheId {string}
-   * @return {Promise<({
-   *             canStartDataRetrieval: true,
-   *             cachedData: any,
-   *             lockId: string
-   *         }|{
-   *             canStartDataRetrieval: false,
-   *             cachedData: any
-   *         })>}
+   * @return {boolean} true if this provider requires several requests to retrieve the data
    */
-  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`);
-    }
+  doesRequireSubRequests() {
+    return false;
   }
 
   /**
-   * 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.
+   * Some endpoint support pagination. Override this method if so and implement corresponding methods.
    *
-   * @param cacheId {string}
-   * @return {any}
+   * @return {boolean} true if this provider requires several requests to retrieve the data
    */
-  getCached(cacheId) {
-    try {
-      return this._cache.get(cacheId);
-    } catch (e) {
-      improveAndRethrow(e, "getCached");
-    }
-  }
-  _getTtl() {
-    return this._removeExpiredCacheAutomatically ? this._cacheTtlMs : null;
+  doesSupportPagination() {
+    return false;
   }
 
   /**
-   * Directly acquires the lock despite on cached data availability.
-   * So if this method returns result === true you can start the data retrieval.
+   * Composes a query string to be added to the endpoint of this provider.
    *
-   * @param cacheId {string}
-   * @return {Promise<{ result: true, lockId: string }|{ result: false }>}
+   * @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
    */
-  async acquireLock(cacheId) {
-    try {
-      return await this._requestsManager.acquireLock(cacheId);
-    } catch (e) {
-      improveAndRethrow(e, "acquireLock");
-    }
+  composeQueryString(params, subRequestIndex = 0) {
+    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.
+   * Composes a body to be added to the request
    *
-   * @param cacheId {string}
-   * @param lockId {string}
-   * @param data {any}
-   * @param [sessionDependentData=true] {boolean}
-   * @param [wasDataMergedSynchronouslyWithMostRecentCacheState=false]
+   * @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}
    */
-  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`);
-    }
+  composeBody(params, subRequestIndex = 0) {
+    return "";
   }
 
   /**
-   * Should be called then and only then if you successfully acquired a lock with the lock id.
+   * Extracts data from the response and returns it
    *
-   * @param cacheId {string}
-   * @param lockId {string}
+   * @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}
    */
-  releaseLock(cacheId, lockId) {
-    try {
-      if (this._requestsManager.isTheLockActiveOne(cacheId, lockId)) {
-        this._requestsManager.finishActiveCalculation(cacheId);
-      }
-    } catch (e) {
-      improveAndRethrow(e, `${this._bio}.releaseLock`);
-    }
+  getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+    return [];
   }
 
   /**
-   * Actualized currently present cached data by key. Applies the provided function to the cached data.
+   * Function changing the query string according to page number and previous response
+   * Only for endpoints supporting pagination
    *
-   * @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 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[]}
    */
-  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);
+  changeQueryParametersForPageNumber(params, previousResponse, pageNumber, subRequestIndex = 0) {
+    return params;
   }
-}
 
-/**
- * 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
+   * 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}
    */
-  constructor(bio, maxPollsCount = 100, timeoutDuration = 1000) {
-    this.bio = bio;
-    this.maxPollsCount = maxPollsCount;
-    this.timeoutDuration = timeoutDuration;
-    this._activeCalculationsIds = new Map();
-    this._nextCalculationIds = new Map();
+  checkWhetherResponseIsForLastPage(previousResponse, currentResponse, currentPageNumber, subRequestIndex = 0) {
+    return true;
   }
 
   /**
-   * 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
+   * Resets the nice factor to default value
    */
-  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;
+  resetNiceFactor() {
+    this.niceFactor = 1;
   }
 
   /**
-   * Acquires lock to the resource by the provided hash.
+   * Internal method used for requests requiring sub-requests.
    *
-   * @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.
+   * @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.
    */
-  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");
-    }
+  incorporateIterationsData(iterationsData) {
+    return iterationsData.flat();
   }
+}
 
-  /**
-   * 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");
-    }
+/**
+ * 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.
+ */
+class ApiGroup {
+  constructor(id, rps, backendProxyIdGenerator = null) {
+    this.id = id;
+    this.rps = rps;
+    this.lastCalledTimestamp = null;
+    this.backendProxyIdGenerator = backendProxyIdGenerator;
   }
-  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");
-    }
+  isRpsExceeded() {
+    var _this$lastCalledTimes;
+    return ((_this$lastCalledTimes = this.lastCalledTimestamp) != null ? _this$lastCalledTimes : 0) + Math.floor(1000 / this.rps) > Date.now();
   }
-
-  /**
-   * @param requestHash {string}
-   * @param lockId {string}
-   * @return {boolean}
-   */
-  isTheLockActiveOne(requestHash, lockId) {
-    try {
-      return this._activeCalculationsIds.get(requestHash) === lockId;
-    } catch (e) {
-      improveAndRethrow(e, "isTheLockActiveOne");
-    }
+  actualizeLastCalledTimestamp() {
+    this.lastCalledTimestamp = Date.now();
   }
-
+}
+const ApiGroups = {
   /**
-   * @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
+   * 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.
    */
-  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;
-    }
-  }
-}
+  ETHERSCAN: new ApiGroup("etherscan", 0.17),
+  // Actually 0.2 but fails sometime, so we use smaller
+  ALCHEMY: new ApiGroup("alchemy", 0.3, networkKey => `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, networkKey => `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
 class ConcurrentCalculationsMetadataHolder {
@@ -3089,7 +2901,7 @@ class ExternalServicesStatsCollector {
  */
 class RobustExternalAPICallerService {
   static getStats() {
-    this.statsCollector.getStats();
+    return this.statsCollector.getStats();
   }
 
   /**
@@ -3109,7 +2921,9 @@ class RobustExternalAPICallerService {
     this.providers = providersData;
     providersData.forEach(provider => provider.resetNiceFactor());
     this.bio = bio;
-    this._logger = Logger.logError;
+    this._logger = (...args) => {
+      Logger.logError(...args);
+    };
   }
   /**
    * Performs data retrieval from external APIs. Tries providers till the data is retrieved.
@@ -3301,12 +3115,463 @@ class RobustExternalAPICallerService {
     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;
-}
+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
+ */
+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;
+    }
+  }
+}
 
 /**
  * Extended edit of RobustExternalApiCallerService supporting cache and management of concurrent requests
@@ -3402,244 +3667,93 @@ class CachedRobustExternalApiCallerService {
   }
 }
 
-/**
- * Utils class needed to perform cancelling of axios request inside some process.
- * Provides cancel state and axios token for HTTP requests
- */
-class CancelProcessing {
+class BigdatacloudIpAddressProvider extends ExternalApiProvider {
   constructor() {
-    this._cancelToken = axios.CancelToken.source();
-    this._isCanceled = false;
-  }
-  cancel() {
-    this._isCanceled = true;
-    this._cancelToken.cancel();
-  }
-  isCanceled() {
-    return this._isCanceled;
+    super("https://api.bigdatacloud.net/data/client-ip", "get", 15000, ApiGroups.BIGDATACLOUD);
   }
-  getToken() {
-    return this._cancelToken.token;
-  }
-  static instance() {
-    return new CancelProcessing();
+  getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+    var _response$data;
+    return (response == null ? void 0 : response.data) && ((_response$data = response.data) == null ? void 0 : _response$data.ipString);
   }
 }
-
-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();
+class TrackipIpAddressProvider extends ExternalApiProvider {
+  constructor() {
+    super("https://www.trackip.net/ip", "get", 15000, ApiGroups.TRACKIP);
   }
-  actualizeLastCalledTimestamp() {
-    this.apiGroup.actualizeLastCalledTimestamp();
+  getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+    return response == null ? void 0 : response.data;
   }
-  getApiGroupId() {
-    return this.apiGroup.id;
+}
+class IpifyV6IpAddressProvider extends ExternalApiProvider {
+  constructor() {
+    super("https://api6.ipify.org/?format=json", "get", 15000, ApiGroups.IPIFY);
   }
-
-  /**
-   * 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;
+  getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+    var _response$data2;
+    return (response == null ? void 0 : response.data) && ((_response$data2 = response.data) == null ? void 0 : _response$data2.ip);
   }
-
-  /**
-   * 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;
+}
+class IpifyIpAddressProvider extends ExternalApiProvider {
+  constructor() {
+    super("https://api.ipify.org/?format=json", "get", 15000, ApiGroups.IPIFY);
   }
-
-  /**
-   * 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 "";
+  getDataByResponse(response, params = [], subRequestIndex = 0, iterationsData = []) {
+    var _response$data3;
+    return (response == null ? void 0 : response.data) && ((_response$data3 = response.data) == null ? void 0 : _response$data3.ip);
   }
-
-  /**
-   * 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 "";
+}
+class WhatismyipaddressIpAddressProvider extends ExternalApiProvider {
+  constructor() {
+    super("http://bot.whatismyipaddress.com/", "get", 15000, ApiGroups.WHATISMYIPADDRESS);
   }
-
-  /**
-   * 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;
+    return response == null ? void 0 : response.data;
   }
-
+}
+class IpAddressProvider {
   /**
-   * Function checking whether the response is for the last page to stop requesting for a next page.
-   * Only for endpoints supporting pagination.
+   * Returns current public IP address identified by one of external services.
    *
-   * @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.
+   * 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.
    *
-   * @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.
+   * @returns {Promise<String>} IP address
+   * @throws {Error} if fails to retrieve IP address from all the services
    */
-  incorporateIterationsData(iterationsData) {
-    return iterationsData.flat();
+  static async getClientIpAddress() {
+    try {
+      return await this.externalIPAddressAPICaller.callExternalAPICached([], 7000);
+    } catch (e) {
+      improveAndRethrow(e, "getClientIpAddress");
+    }
   }
 }
+IpAddressProvider.externalIPAddressAPICaller = new CachedRobustExternalApiCallerService("externalIPAddressAPICaller", new Cache(EventBusInstance), [new BigdatacloudIpAddressProvider(), new TrackipIpAddressProvider(), new IpifyV6IpAddressProvider(), new IpifyIpAddressProvider(), new WhatismyipaddressIpAddressProvider()], 300000);
 
 /**
- * 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.
+ * Utils class needed to perform cancelling of axios request inside some process.
+ * Provides cancel state and axios token for HTTP requests
  */
-class ApiGroup {
-  constructor(id, rps, backendProxyIdGenerator = null) {
-    this.id = id;
-    this.rps = rps;
-    this.lastCalledTimestamp = null;
-    this.backendProxyIdGenerator = backendProxyIdGenerator;
+class CancelProcessing {
+  constructor() {
+    this._cancelToken = axios.CancelToken.source();
+    this._isCanceled = false;
   }
-  isRpsExceeded() {
-    var _this$lastCalledTimes;
-    return ((_this$lastCalledTimes = this.lastCalledTimestamp) != null ? _this$lastCalledTimes : 0) + Math.floor(1000 / this.rps) > Date.now();
+  cancel() {
+    this._isCanceled = true;
+    this._cancelToken.cancel();
   }
-  actualizeLastCalledTimestamp() {
-    this.lastCalledTimestamp = Date.now();
+  isCanceled() {
+    return this._isCanceled;
+  }
+  getToken() {
+    return this._cancelToken.token;
+  }
+  static instance() {
+    return new CancelProcessing();
   }
 }
-const 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, networkKey => `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, networkKey => `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
-};
 
 class ExistingSwap {
   /**
@@ -3649,6 +3763,7 @@ class ExistingSwap {
    * @param expiresAt {number}
    * @param confirmations {number}
    * @param rate {string}
+   * @param fixed {boolean}
    * @param refundAddress {string}
    * @param payToAddress {string}
    * @param fromCoin {Coin}
@@ -3665,7 +3780,7 @@ class ExistingSwap {
    * @param toExtraId {string}
    * @param refundExtraId {string}
    */
-  constructor(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress,
+  constructor(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;
@@ -3674,6 +3789,7 @@ class ExistingSwap {
     this.expiresAt = expiresAt;
     this.confirmations = confirmations;
     this.rate = rate;
+    this.fixed = fixed;
     this.refundAddress = refundAddress;
     this.payToAddress = payToAddress;
     this.fromCoin = fromCoin;
@@ -3700,6 +3816,7 @@ class ExistingSwapWithFiatData extends ExistingSwap {
    * @param expiresAt {number}
    * @param confirmations {number}
    * @param rate {string}
+   * @param fixed {boolean}
    * @param refundAddress {string}
    * @param payToAddress {string}
    * @param fromCoin {Coin}
@@ -3720,8 +3837,8 @@ class ExistingSwapWithFiatData extends ExistingSwap {
    * @param fiatCurrencyCode {string}
    * @param fiatCurrencyDecimals {number}
    */
-  constructor(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) {
-    super(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromExtraId, toExtraId, refundExtraId);
+  constructor(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) {
+    super(swapId, status, createdAt, expiresAt, confirmations, rate, fixed, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromExtraId, toExtraId, refundExtraId);
     this.fromAmountFiat = fromAmountFiat;
     this.toAmountFiat = toAmountFiat;
     this.fiatCurrencyCode = fiatCurrencyCode;
@@ -3737,7 +3854,7 @@ class ExistingSwapWithFiatData extends ExistingSwap {
    * @return {ExistingSwapWithFiatData}
    */
   static 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);
   }
 }
 
@@ -3754,8 +3871,9 @@ class BaseSwapCreationInfo {
    * @param max {string}
    * @param fiatMax {number}
    * @param durationMinutesRange {string}
+   * @param fixed {boolean}
    */
-  constructor(fromCoin, toCoin, fromAmountCoins, toAmountCoins, rate, rawSwapData, min, fiatMin, max, fiatMax, durationMinutesRange) {
+  constructor(fromCoin, toCoin, fromAmountCoins, toAmountCoins, rate, rawSwapData, min, fiatMin, max, fiatMax, durationMinutesRange, fixed) {
     this.fromCoin = fromCoin;
     this.toCoin = toCoin;
     this.fromAmountCoins = fromAmountCoins;
@@ -3767,6 +3885,7 @@ class BaseSwapCreationInfo {
     this.max = max;
     this.fiatMax = fiatMax;
     this.durationMinutesRange = durationMinutesRange;
+    this.fixed = fixed;
   }
 }
 
@@ -3845,6 +3964,7 @@ class SwapProvider {
    * @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<({
@@ -3860,15 +3980,16 @@ class SwapProvider {
    *            greatestMax: (string|null),
    *            rate: (string|null),
    *            durationMinutesRange: string,
+   *            fixed: boolean,
    *            [rawSwapData]: Object
    *         })>}
    */
-  async getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate = null) {
+  async getSwapInfo(fromCoin, toCoin, amountCoins, fixed = false, fromCoinToUsdRate = null) {
     throw new Error("Not implemented in base");
   }
 
   /**
-   * 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}
@@ -3877,6 +3998,7 @@ class SwapProvider {
    * @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<({
@@ -3889,14 +4011,15 @@ class SwapProvider {
    *                     toAmount: string,
    *                     toAddress: string,
    *                     rate: string,
-   *                     fromCurrencyExtraId: string|undefined
+   *                     fromCurrencyExtraId: string|undefined,
+   *                     fixed: boolean
    *                 }|{
    *                     result: false,
    *                     reason: string,
    *                     partner: string
    *                 })>}
    */
-  async createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData = null, clientIpAddress, toCurrencyExtraId = "", refundExtraId = "") {
+  async createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, fixed, toCurrencyExtraId = "", refundExtraId = "") {
     throw new Error("Not implemented in base");
   }
 
@@ -3942,7 +4065,9 @@ SwapProvider.COMMON_ERRORS = {
 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"
@@ -4093,7 +4218,6 @@ class SwapspaceSwapProvider extends SwapProvider {
             const ticker = `${code}${code === network ? "" : network}`;
             const defaultDecimalPlacesForCoinNotSupportedOOB = 8;
             const 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);
@@ -4106,7 +4230,7 @@ class SwapspaceSwapProvider extends SwapProvider {
               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,
@@ -4156,7 +4280,7 @@ class SwapspaceSwapProvider extends SwapProvider {
         };
       }
       Logger.log("Loading USDT->coin rate as not found in cache:", coin == null ? void 0 : coin.ticker);
-      const result = await this.getSwapInfo(usdtTrc20, coin, "5000");
+      const result = await this.getSwapInfo(usdtTrc20, coin, "5000", false);
       if (!result.result) {
         return {
           result: false
@@ -4164,7 +4288,7 @@ class SwapspaceSwapProvider extends SwapProvider {
       }
 
       // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
-      const standardSwapspaceFeeMultiplier = 1.004; // usually 0.2%
+      const standardSwapspaceFeeMultiplier = 1.004; // fee is usually 0.4%
       const rate = BigNumber(1).div(BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
       this._cache.put("swapspace_usdt_rate_" + coin.ticker, rate, 15 * 60000 // 15 minutes
       );
@@ -4185,12 +4309,12 @@ class SwapspaceSwapProvider extends SwapProvider {
       improveAndRethrow(e, "getCoinByTickerIfPresent");
     }
   }
-  async getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate = null) {
+  async getSwapInfo(fromCoin, toCoin, amountCoins, fixed = false, fromCoinToUsdRate = null) {
     const loggerSource = "getSwapInfo";
     try {
-      var _response$data;
-      if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || BigNumber(amountCoins).lt("0")) {
-        throw new Error(`Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${toCoin.ticker}` + (fromCoin instanceof Coin) + (toCoin instanceof Coin));
+      var _response$data, _exchangesSupportingT;
+      if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || 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}`);
       }
       const fromCoinSwapspaceDetails = this._supportedCoins.find(i => {
         var _i$coin;
@@ -4213,12 +4337,22 @@ class SwapspaceSwapProvider extends SwapProvider {
        * cached rate values stored in swapspace cache. Their support says they store at most for 30 sec.
        * But we are better off using the most actual rates.
        */
-      const response = await axios.get(`${this._URL}/api/v2/amounts?fromCurrency=${fromCoinSwapspaceDetails.code}&fromNetwork=${fromCoinSwapspaceDetails.network}&toNetwork=${toCoinSwapspaceDetails.network}&toCurrency=${toCoinSwapspaceDetails.code}&amount=${amountCoins}&float=true&estimated=false`);
+      const response = await axios.get(`${this._URL}/api/v2/amounts?fromCurrency=${fromCoinSwapspaceDetails.code}&fromNetwork=${fromCoinSwapspaceDetails.network}&toNetwork=${toCoinSwapspaceDetails.network}&toCurrency=${toCoinSwapspaceDetails.code}&amount=${amountCoins}&estimated=false`);
       Logger.log(`Retrieved ${response == null || (_response$data = response.data) == null ? void 0 : _response$data.length} options`, loggerSource);
       const options = Array.isArray(response.data) ? response.data : [];
-      const exchangesSupportingThePair = options.filter(exchange => (exchange == null ? void 0 : exchange.exists) && !BANNED_PARTNERS.find(bannedPartner => 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));
-      Logger.log(`${exchangesSupportingThePair == null ? void 0 : exchangesSupportingThePair.length} of them have exist=true`, loggerSource);
-      if (!exchangesSupportingThePair.length) {
+      let exchangesSupportingThePairDespiteFixedOrFloating = options.filter(exchange => (exchange == null ? void 0 : exchange.exists) && !BANNED_PARTNERS.find(bannedPartner => bannedPartner === (exchange == null ? void 0 : exchange.partner)) && ((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));
+      let exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating;
+      if (fixed != null) {
+        exchangesSupportingThePair = exchangesSupportingThePairDespiteFixedOrFloating.filter(option => 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
@@ -4281,6 +4415,7 @@ class SwapspaceSwapProvider extends SwapProvider {
           greatestMax: greatestMax,
           rate: rate != null ? AmountUtils.trim(rate, this._maxRateDigits) : null,
           durationMinutesRange: (_bestOpt$duration = bestOpt.duration) != null ? _bestOpt$duration : null,
+          fixed: bestOpt.fixed,
           rawSwapData: bestOpt
         };
       }
@@ -4304,17 +4439,18 @@ class SwapspaceSwapProvider extends SwapProvider {
       improveAndRethrow(e, loggerSource);
     }
   }
-  async createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, toCurrencyExtraId = "", refundExtraId = "") {
+  async createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress, fixed, toCurrencyExtraId = "", refundExtraId = "") {
     const loggerSource = "createSwap";
     const partner = rawSwapData == null ? void 0 : rawSwapData.partner;
     try {
-      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)}`);
       }
+      const [fromCurrencyHasExtraId, toCurrencyHasExtraId] = this._supportedCoins.reduce((prev, coinData) => [coinData.coin.ticker === fromCoin.ticker ? coinData.hasExtraId : prev[0], coinData.coin.ticker === toCoin.ticker ? coinData.hasExtraId : prev[1]], [false, false]);
       await this._fetchSupportedCurrenciesIfNeeded();
       const requestData = {
         partner: partner,
@@ -4324,10 +4460,10 @@ class SwapspaceSwapProvider extends SwapProvider {
         toNetwork: rawSwapData == null ? void 0 : rawSwapData.toNetwork,
         address: toAddress,
         amount: amount,
-        fixed: false,
-        extraId: toCurrencyExtraId != null ? toCurrencyExtraId : "",
-        refundExtraId: refundExtraId != null ? refundExtraId : "",
+        fixed: fixed,
+        extraId: toCurrencyHasExtraId ? toCurrencyExtraId != null ? toCurrencyExtraId : "" : "",
         // This param is not documented. But the refund is usually manual so this is not critical.
+        refundExtraId: fromCurrencyHasExtraId ? refundExtraId != null ? refundExtraId : "" : "",
         rateId: rawSwapData == null ? void 0 : rawSwapData.id,
         userIp: clientIpAddress,
         refund: refundAddress
@@ -4338,7 +4474,7 @@ class SwapspaceSwapProvider extends SwapProvider {
       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 */
         let rate = result.rate;
@@ -4358,7 +4494,8 @@ class SwapspaceSwapProvider extends SwapProvider {
           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, this._maxRateDigits)
+          rate: AmountUtils.trim(rate, this._maxRateDigits),
+          fixed: result.fixed
         };
       }
       const errorMessage = `Swap creation succeeded but the response is wrong: ${safeStringify(response)}`;
@@ -4447,7 +4584,7 @@ class SwapspaceSwapProvider extends SwapProvider {
         const status = this._mapSwapspaceStatusToRabbitStatus(swap.status, isExpiredByTime);
         const toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
         const addressToSendCoinsToSwapspace = swap.from.address;
-        return new ExistingSwap(swapIds[index], status, toUtcTimestamp(swap.timestamps.createdAt), expiresAt, swap.confirmations, AmountUtils.trim(swap.rate, this._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, this._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 {
@@ -4744,6 +4881,7 @@ class PublicSwapService {
    * @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,
@@ -4758,12 +4896,12 @@ class PublicSwapService {
    *             swapCreationInfo: BaseSwapCreationInfo
    *         }>}
    */
-  async getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins, withoutFiat = false) {
+  async getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins, fixed = false, withoutFiat = false) {
     const loggerSource = "getPublicSwapDetails";
     try {
       var _await$this$_swapProv, _await$this$_swapProv2, _result$swapCreationI, _result$swapCreationI2;
       const coinUsdtRate = withoutFiat ? null : (_await$this$_swapProv = (_await$this$_swapProv2 = await this._swapProvider.getCoinToUSDTRate(fromCoin)) == null ? void 0 : _await$this$_swapProv2.rate) != null ? _await$this$_swapProv : null;
-      const details = await this._swapProvider.getSwapInfo(fromCoin, toCoin, fromAmountCoins, coinUsdtRate);
+      const details = await this._swapProvider.getSwapInfo(fromCoin, toCoin, fromAmountCoins, fixed, coinUsdtRate);
       const min = details.result ? details.min : details.smallestMin;
       const max = details.result ? details.max : details.greatestMax;
       let fiatMin = null,
@@ -4789,9 +4927,15 @@ class PublicSwapService {
         };
       };
       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);
         }
       }
       const fromAmountBigNumber = BigNumber(fromAmountCoins);
@@ -4803,7 +4947,7 @@ class PublicSwapService {
       const toAmountCoins = AmountUtils.trim(fromAmountBigNumber.times(details.rate), fromCoin.digits);
       const 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,
@@ -4844,7 +4988,8 @@ class PublicSwapService {
    *             fromCoin: Coin,
    *             rate: string,
    *             swapId: string,
-   *             fromCurrencyExtraId: string
+   *             fromCurrencyExtraId: string,
+   *             fixed: boolean
    *         }|{
    *             result: false,
    *             reason: string
@@ -4861,7 +5006,7 @@ class PublicSwapService {
         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);
-      const result = await this._swapProvider.createSwap(fromCoin, toCoin, fromAmount, toAddress, refundAddress, swapCreationInfo.rawSwapData, clientIp, toCurrencyExtraId, refundExtraId);
+      const result = await this._swapProvider.createSwap(fromCoin, toCoin, fromAmount, toAddress, refundAddress, swapCreationInfo.rawSwapData, clientIp, swapCreationInfo.fixed, toCurrencyExtraId, refundExtraId);
       Logger.log(`Created:${safeStringify(_extends({}, result, {
         fromCoin: fromCoin == null ? void 0 : fromCoin.ticker,
         toCoin: toCoin == null ? void 0 : toCoin.ticker
@@ -4899,6 +5044,8 @@ class PublicSwapService {
         } catch (e) {
           Logger.logError(e, loggerSource, "Failed to calculate fiat amounts for result");
         }
+
+        // TODO: feature, cirtical] add GA event. task_id=tbd
         EventBusInstance.dispatch(PublicSwapService.PUBLIC_SWAP_CREATED_EVENT, null, fromCoin.ticker, toCoin.ticker, fromAmountFiat);
         const toReturn = {
           result: true,
@@ -4915,7 +5062,9 @@ class PublicSwapService {
           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
         };
         this._savePublicSwapIdLocally(result.swapId);
         Logger.log(`Returning: ${safeStringify(_extends({}, toReturn, {
@@ -5104,9 +5253,11 @@ PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS = {
 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");
 
-export { AmountUtils, ApiGroup, ApiGroups, AssetIcon, AxiosAdapter, BaseSwapCreationInfo, Blockchain, Button, Cache, CacheAndConcurrentRequestsResolver, CachedRobustExternalApiCallerService, CancelProcessing, Coin, ConcurrentCalculationsMetadataHolder, 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 };
+export { AmountUtils, ApiGroup, ApiGroups, AssetIcon, AxiosAdapter, BaseSwapCreationInfo, Blockchain, Button, Cache, CacheAndConcurrentRequestsResolver, CachedRobustExternalApiCallerService, CancelProcessing, Coin, ConcurrentCalculationsMetadataHolder, EmailsApi, ExistingSwap, ExistingSwapWithFiatData, ExternalApiProvider, FiatCurrenciesService, InputValuesProviders, IpAddressProvider, 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