@rabbitio/ui-kit 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/index.cjs

@@ -1,11 +1,13 @@
 var React = require('react');
 var bignumber_js = require('bignumber.js');
 var axios = require('axios');
+var EventBusInstance = require('eventbusjs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+var EventBusInstance__default = /*#__PURE__*/_interopDefaultLegacy(EventBusInstance);
 
 function createCommonjsModule(fn) {
   var module = { exports: {} };
@@ -2505,7 +2507,7 @@ var Cache = /*#__PURE__*/function () {
   return Cache;
 }();
 
-function _catch$1(body, recover) {
+function _catch$3(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -2521,7 +2523,7 @@ var EmailsApi = /*#__PURE__*/function () {
   EmailsApi.sendEmail = function sendEmail(subject, body) {
     try {
       var _this = this;
-      var _temp = _catch$1(function () {
+      var _temp = _catch$3(function () {
         var url = window.location.protocol + "//" + window.location.host + "/api/v1/" + _this.serverEndpointEntity;
         return Promise.resolve(axios__default["default"].post(url, {
           subject: subject,
@@ -2858,7 +2860,7 @@ SwapProvider.SWAP_STATUSES = {
   FAILED: "failed" // public +
 };
 
-function _catch(body, recover) {
+function _catch$2(body, recover) {
   try {
     var result = body();
   } catch (e) {
@@ -2902,7 +2904,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
     try {
       var _this2 = this;
       var loggerSource = "getDepositCurrencies";
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         return Promise.resolve(_this2._fetchSupportedCurrenciesIfNeeded()).then(function () {
           var _this2$_supportedCoin;
           Logger.log("We have " + ((_this2$_supportedCoin = _this2._supportedCoins) == null ? void 0 : _this2$_supportedCoin.length) + " supported coins, getting depositable", loggerSource);
@@ -2936,7 +2938,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
     try {
       var _this3 = this;
       var loggerSource = "getWithdrawalCurrencies";
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         return Promise.resolve(_this3._fetchSupportedCurrenciesIfNeeded()).then(function () {
           var _this3$_supportedCoin;
           Logger.log("We have " + ((_this3$_supportedCoin = _this3._supportedCoins) == null ? void 0 : _this3$_supportedCoin.length) + " supported coins, getting withdrawable", loggerSource);
@@ -2993,7 +2995,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
     try {
       var _this5 = this;
       var loggerSource = "_fetchSupportedCurrenciesIfNeeded";
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         var _temp = function (_this5$_supportedCoin) {
           if (!((_this5$_supportedCoin = _this5._supportedCoins) != null && _this5$_supportedCoin.length)) {
             return Promise.resolve(axios__default["default"].get(_this5._URL + "/api/v2/currencies")).then(function (rawResponse) {
@@ -3066,7 +3068,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
     try {
       var _this6 = this;
       var loggerSource = "getCoinToUSDTRate";
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         return Promise.resolve(_this6._fetchSupportedCurrenciesIfNeeded()).then(function () {
           var _this6$_supportedCoin;
           // Using USDT TRC20 as usually fee in this network is smaller than ERC20 and this network is widely used for USDT
@@ -3128,7 +3130,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
     try {
       var _this7 = this;
       var loggerSource = "getSwapInfo";
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || bignumber_js.BigNumber(amountCoins).lt("0")) {
           throw new Error("Wrong input params: " + amountCoins + " " + fromCoin.ticker + " -> " + toCoin.ticker + (fromCoin instanceof Coin) + (toCoin instanceof Coin));
         }
@@ -3258,7 +3260,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
       var _this8 = this;
       var loggerSource = "createSwap";
       var partner = rawSwapData == null ? void 0 : rawSwapData.partner;
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amount !== "string" || typeof toAddress !== "string" || typeof refundAddress !== "string") {
           throw new Error("Invalid input: " + fromCoin + " " + toCoin + " " + amount + " " + toAddress + " " + refundAddress);
         }
@@ -3377,7 +3379,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
     try {
       var _this9 = this;
       var loggerSource = "getExistingSwapsDetailsAndStatus";
-      return Promise.resolve(_catch(function () {
+      return Promise.resolve(_catch$2(function () {
         if (swapIds.find(function (id) {
           return typeof id !== "string";
         })) {
@@ -3385,7 +3387,7 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
         }
         var getNotFailingOn404 = function getNotFailingOn404(swapId) {
           try {
-            return Promise.resolve(_catch(function () {
+            return Promise.resolve(_catch$2(function () {
               return Promise.resolve(axios__default["default"].get(_this9._URL + "/api/v2/exchange/" + swapId));
             }, function (error) {
               var _error$response;
@@ -3467,6 +3469,866 @@ var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
   return SwapspaceSwapProvider;
 }(SwapProvider);
 
+function _catch$1(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+var _iteratorSymbol = typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator")) : "@@iterator";
+function _settle(pact, state, value) {
+  if (!pact.s) {
+    if (value instanceof _Pact) {
+      if (value.s) {
+        if (state & 1) {
+          state = value.s;
+        }
+        value = value.v;
+      } else {
+        value.o = _settle.bind(null, pact, state);
+        return;
+      }
+    }
+    if (value && value.then) {
+      value.then(_settle.bind(null, pact, state), _settle.bind(null, pact, 2));
+      return;
+    }
+    pact.s = state;
+    pact.v = value;
+    var observer = pact.o;
+    if (observer) {
+      observer(pact);
+    }
+  }
+}
+var _Pact = /*#__PURE__*/function () {
+  function _Pact() {}
+  _Pact.prototype.then = function (onFulfilled, onRejected) {
+    var result = new _Pact();
+    var state = this.s;
+    if (state) {
+      var callback = state & 1 ? onFulfilled : onRejected;
+      if (callback) {
+        try {
+          _settle(result, 1, callback(this.v));
+        } catch (e) {
+          _settle(result, 2, e);
+        }
+        return result;
+      } else {
+        return this;
+      }
+    }
+    this.o = function (_this) {
+      try {
+        var value = _this.v;
+        if (_this.s & 1) {
+          _settle(result, 1, onFulfilled ? onFulfilled(value) : value);
+        } else if (onRejected) {
+          _settle(result, 1, onRejected(value));
+        } else {
+          _settle(result, 2, value);
+        }
+      } catch (e) {
+        _settle(result, 2, e);
+      }
+    };
+    return result;
+  };
+  return _Pact;
+}();
+function _isSettledPact(thenable) {
+  return thenable instanceof _Pact && thenable.s & 1;
+}
+function _forTo(array, body, check) {
+  var i = -1,
+    pact,
+    reject;
+  function _cycle(result) {
+    try {
+      while (++i < array.length && (!check || !check())) {
+        result = body(i);
+        if (result && result.then) {
+          if (_isSettledPact(result)) {
+            result = result.v;
+          } else {
+            result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+            return;
+          }
+        }
+      }
+      if (pact) {
+        _settle(pact, 1, result);
+      } else {
+        pact = result;
+      }
+    } catch (e) {
+      _settle(pact || (pact = new _Pact()), 2, e);
+    }
+  }
+  _cycle();
+  return pact;
+}
+function _forOf(target, body, check) {
+  if (typeof target[_iteratorSymbol] === "function") {
+    var _cycle = function _cycle(result) {
+      try {
+        while (!(step = iterator.next()).done && (!check || !check())) {
+          result = body(step.value);
+          if (result && result.then) {
+            if (_isSettledPact(result)) {
+              result = result.v;
+            } else {
+              result.then(_cycle, reject || (reject = _settle.bind(null, pact = new _Pact(), 2)));
+              return;
+            }
+          }
+        }
+        if (pact) {
+          _settle(pact, 1, result);
+        } else {
+          pact = result;
+        }
+      } catch (e) {
+        _settle(pact || (pact = new _Pact()), 2, e);
+      }
+    };
+    var iterator = target[_iteratorSymbol](),
+      step,
+      pact,
+      reject;
+    _cycle();
+    if (iterator["return"]) {
+      var _fixup = function _fixup(value) {
+        try {
+          if (!step.done) {
+            iterator["return"]();
+          }
+        } catch (e) {}
+        return value;
+      };
+      if (pact && pact.then) {
+        return pact.then(_fixup, function (e) {
+          throw _fixup(e);
+        });
+      }
+      _fixup();
+    }
+    return pact;
+  }
+  // No support for Symbol.iterator
+  if (!("length" in target)) {
+    throw new TypeError("Object is not iterable");
+  }
+  // Handle live collections properly
+  var values = [];
+  for (var i = 0; i < target.length; i++) {
+    values.push(target[i]);
+  }
+  return _forTo(values, function (i) {
+    return body(values[i]);
+  }, check);
+}
+var SwapUtils = /*#__PURE__*/function () {
+  function SwapUtils() {}
+  /**
+   * Retrieves min and max limits for swapping giving currencies.
+   * Returns also conversion rate if possible with predefined amount logic.
+   * Rate is how many "to" coins does 1 "from" coin contain.
+   *
+   * In case of errors returns one of reasons
+   *   - SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+   *   - one of SwapProvider.COMMON_ERRORS.*
+   *
+   * @param swapProvider {SwapProvider}
+   * @param fromCoin {Coin} enabled coin (to swap amount from)
+   * @param toCoin {Coin}
+   * @return {Promise<{
+   *             result: true,
+   *             min: string,
+   *             fiatMin: (number|null),
+   *             max: string,
+   *             fiatMax: (number|null),
+   *             rate: (string|null),
+   *         }|{
+   *             result: false,
+   *             reason: string
+   *         }>}
+   */
+  SwapUtils.getInitialSwapData = function getInitialSwapData(swapProvider, fromCoin, toCoin) {
+    try {
+      var loggerSource = "getInitialSwapData";
+      return Promise.resolve(_catch$1(function () {
+        /* We use some amount here that should fit at least some of the limits of the swap providers.
+         * So we are going to get some rate to be used as the default for the on-flight calculations before we get
+         * the exact rate (that should be retrieved by getSwapCreationInfo method) for a specific amount.
+         */
+        var defaultAmountUsd = bignumber_js.BigNumber("300");
+        return Promise.resolve(swapProvider.getCoinToUSDTRate(fromCoin)).then(function (coinUsdRate) {
+          var coinAmountForDefaultUsdAmount = AmountUtils.trim(coinUsdRate.result ? defaultAmountUsd.div(coinUsdRate == null ? void 0 : coinUsdRate.rate) : defaultAmountUsd, fromCoin.digits);
+          Logger.log("Init: " + coinAmountForDefaultUsdAmount + " " + fromCoin.ticker + "->" + toCoin.ticker, loggerSource);
+          return Promise.resolve(swapProvider.getSwapInfo(fromCoin, toCoin, coinAmountForDefaultUsdAmount)).then(function (details) {
+            if (!details) {
+              throw new Error("The details are empty: " + safeStringify(details));
+            }
+            if (!details.result) {
+              Logger.log("Failed with reason: " + details.reason + ". " + fromCoin.ticker + "->" + toCoin.ticker, loggerSource);
+              if ((details == null ? void 0 : details.reason) === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED || (details == null ? void 0 : details.reason) === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+                return {
+                  result: false,
+                  reason: details.reason
+                };
+              } else {
+                throw new Error("Unhandled error case: " + (details == null ? void 0 : details.reason));
+              }
+            }
+            var fiatMin = null;
+            var fiatMax = null;
+            if ((coinUsdRate == null ? void 0 : coinUsdRate.rate) != null) {
+              var usdDecimals = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+              fiatMin = bignumber_js.BigNumber(details == null ? void 0 : details.smallestMin).times(coinUsdRate.rate).toFixed(usdDecimals);
+              fiatMax = bignumber_js.BigNumber(details == null ? void 0 : details.greatestMax).times(coinUsdRate.rate).toFixed(usdDecimals);
+            }
+            var result = {
+              result: true,
+              min: details == null ? void 0 : details.smallestMin,
+              fiatMin: fiatMin,
+              max: details == null ? void 0 : details.greatestMax,
+              fiatMax: fiatMax,
+              rate: AmountUtils.trim(details.rate, 30)
+            };
+            Logger.log("Returning: " + safeStringify(result), loggerSource);
+            return result;
+          });
+        });
+      }, function (e) {
+        Logger.log("Failed to init swap: " + safeStringify(e), loggerSource);
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  SwapUtils.safeHandleRequestsLimitExceeding = function safeHandleRequestsLimitExceeding() {
+    (function () {
+      try {
+        var _temp = _catch$1(function () {
+          return Promise.resolve(EmailsApi.sendEmail("AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED", "Requests limit exceeded. Urgently ask swaps provider support for limit increasing")).then(function () {});
+        }, function (e) {
+          Logger.log("Failed to handle limit exceeding " + safeStringify(e), "_safeHandleRequestsLimitExceeding");
+        });
+        return _temp && _temp.then ? _temp.then(function () {}) : void 0;
+      } catch (e) {
+        Promise.reject(e);
+      }
+    })();
+  }
+
+  /**
+   * If some swap is not found by id then there is no item in return list.
+   *
+   * @param swapProvider {SwapProvider}
+   * @param swapIds {string[]}
+   * @return {Promise<{
+   *             result: true,
+   *             swaps: ExistingSwapWithFiatData[]
+   *         }|{
+   *             result: false,
+   *             reason: string
+   *         }>}
+   */;
+  SwapUtils.getExistingSwapsDetailsWithFiatAmounts = function getExistingSwapsDetailsWithFiatAmounts(swapProvider, swapIds) {
+    try {
+      return Promise.resolve(_catch$1(function () {
+        return Promise.resolve(swapProvider.getExistingSwapsDetailsAndStatus(swapIds)).then(function (result) {
+          var _temp5 = function () {
+            if (result.result) {
+              var _temp4 = function _temp4() {
+                result.swaps = _extendedSwaps;
+              };
+              var _extendedSwaps = [];
+              var _temp3 = _forOf(result.swaps, function (swap) {
+                var _temp2 = function () {
+                  if (swap.status === SwapProvider.SWAP_STATUSES.REFUNDED) {
+                    return Promise.resolve(swapProvider.getCoinToUSDTRate(swap.fromCoin)).then(function (rate) {
+                      _extendedSwaps.push(ExistingSwapWithFiatData.fromExistingSwap(swap, (rate == null ? void 0 : rate.rate) != null ? bignumber_js.BigNumber(swap.fromAmount).times(rate.rate).toNumber() : null, (rate == null ? void 0 : rate.rate) != null ? bignumber_js.BigNumber(swap.toAmount).times(rate.rate).toNumber() : null, "USD", FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")));
+                    });
+                  } else {
+                    return Promise.resolve(Promise.all([swapProvider.getCoinToUSDTRate(swap.fromCoin), swapProvider.getCoinToUSDTRate(swap.toCoin)])).then(function (_ref) {
+                      var fromCoinFiatRate = _ref[0],
+                        toConFiatRate = _ref[1];
+                      _extendedSwaps.push(ExistingSwapWithFiatData.fromExistingSwap(swap, (fromCoinFiatRate == null ? void 0 : fromCoinFiatRate.rate) != null ? bignumber_js.BigNumber(swap.fromAmount).times(fromCoinFiatRate.rate).toNumber() : null, (toConFiatRate == null ? void 0 : toConFiatRate.rate) != null ? bignumber_js.BigNumber(swap.toAmount).times(toConFiatRate.rate).toNumber() : null, "USD", FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")));
+                    });
+                  }
+                }();
+                if (_temp2 && _temp2.then) return _temp2.then(function () {});
+              });
+              return _temp3 && _temp3.then ? _temp3.then(_temp4) : _temp4(_temp3);
+            }
+          }();
+          return _temp5 && _temp5.then ? _temp5.then(function () {
+            return result;
+          }) : result;
+        });
+      }, function (e) {
+        improveAndRethrow(e, "getExistingSwapsDetailsWithFiatAmounts");
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  return SwapUtils;
+}();
+
+function _catch(body, recover) {
+  try {
+    var result = body();
+  } catch (e) {
+    return recover(e);
+  }
+  if (result && result.then) {
+    return result.then(void 0, recover);
+  }
+  return result;
+}
+var API_KEYS_PROXY_URL = window.location.protocol + "//" + window.location.host + "/api/v1/proxy";
+var cache = new Cache(EventBusInstance__default["default"]);
+var PublicSwapService = /*#__PURE__*/function () {
+  function PublicSwapService() {}
+  PublicSwapService.initialize = function initialize() {
+    try {
+      var _this = this;
+      var _temp = _catch(function () {
+        return Promise.resolve(_this._swapProvider.initialize()).then(function () {
+          SwapUtils.safeHandleRequestsLimitExceeding();
+        });
+      }, function (e) {
+        Logger.logError(e, "PublicSwapService.initialize");
+      });
+      return Promise.resolve(_temp && _temp.then ? _temp.then(function () {}) : void 0);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  PublicSwapService.getCurrenciesListForPublicSwap = function getCurrenciesListForPublicSwap(currencyThatShouldNotBeFirst) {
+    if (currencyThatShouldNotBeFirst === void 0) {
+      currencyThatShouldNotBeFirst = null;
+    }
+    try {
+      var _this2 = this;
+      var loggerSource = "getCurrenciesListForPublicSwap";
+      return Promise.resolve(_catch(function () {
+        // TODO: [dev] this is temporary hack, change it to use dedicated lists inside UI and also here
+        return Promise.resolve(currencyThatShouldNotBeFirst ? _this2._swapProvider.getWithdrawalCurrencies(currencyThatShouldNotBeFirst) : _this2._swapProvider.getDepositCurrencies()).then(function (result) {
+          var _result$coins;
+          if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+            SwapUtils.safeHandleRequestsLimitExceeding();
+            return {
+              result: false,
+              reason: _this2.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+            };
+          }
+          Logger.log("Retrieved " + (result == null || (_result$coins = result.coins) == null ? void 0 : _result$coins.length) + " supported currencies for swap", loggerSource);
+          if (result.coins[0] === currencyThatShouldNotBeFirst && result.coins.length > 1) {
+            var temp = result.coins[0];
+            result.coins[0] = result.coins[1];
+            result.coins[1] = temp;
+          }
+          return {
+            result: true,
+            coins: result.coins
+          };
+        });
+      }, function (e) {
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Retrieves initial data for swapping two coins.
+   *
+   * @param fromCoin {Coin}
+   * @param toCoin {Coin}
+   * @return {Promise<{
+   *             result: true,
+   *             min: string,
+   *             fiatMin: (number|null),
+   *             max: string,
+   *             fiatMax: (number|null),
+   *             rate: (string|null)
+   *         }|{
+   *             result: false,
+   *             reason: string
+   *         }>}
+   */
+  ;
+  PublicSwapService.getInitialPublicSwapData = function getInitialPublicSwapData(fromCoin, toCoin) {
+    try {
+      var _this3 = this;
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(SwapUtils.getInitialSwapData(_this3._swapProvider, fromCoin, toCoin)).then(function (result) {
+          if (!result.result) {
+            if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+              SwapUtils.safeHandleRequestsLimitExceeding();
+              return {
+                result: false,
+                reason: _this3.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+              };
+            }
+            if (result.reason === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) {
+              return {
+                result: false,
+                reason: _this3.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED
+              };
+            }
+          }
+          return result;
+        });
+      }, function (e) {
+        improveAndRethrow(e, "getInitialPublicSwapData");
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Retrieves swap details that can be used to create swap.
+   *
+   * @param fromCoin {Coin}
+   * @param toCoin {Coin}
+   * @param fromAmountCoins {string}
+   * @return {Promise<{
+   *             result: false,
+   *             reason: string,
+   *             min: (string|null),
+   *             max: (string|null),
+   *             rate: (string|undefined),
+   *             fiatMin: (number|null),
+   *             fiatMax: (number|null)
+   *         }|{
+   *             result: true,
+   *             swapCreationInfo: PublicSwapCreationInfo
+   *         }>}
+   */
+  ;
+  PublicSwapService.getPublicSwapDetails = function getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins) {
+    try {
+      var _this4 = this;
+      var loggerSource = "getPublicSwapDetails";
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(_this4._swapProvider.getCoinToUSDTRate(fromCoin)).then(function (_this4$_swapProvider$) {
+          var _this4$_swapProvider$2;
+          var coinUsdtRate = (_this4$_swapProvider$2 = _this4$_swapProvider$ == null ? void 0 : _this4$_swapProvider$.rate) != null ? _this4$_swapProvider$2 : null;
+          return Promise.resolve(_this4._swapProvider.getSwapInfo(fromCoin, toCoin, fromAmountCoins, coinUsdtRate)).then(function (details) {
+            var _result$swapCreationI, _result$swapCreationI2;
+            var min = details.result ? details.min : details.smallestMin;
+            var max = details.result ? details.max : details.greatestMax;
+            var fiatMin = null,
+              fiatMax = null;
+            if (coinUsdtRate != null) {
+              if (min != null) {
+                fiatMin = bignumber_js.BigNumber(min).times(coinUsdtRate).toFixed(_this4._fiatDecimalsCount);
+              }
+              if (max != null) {
+                fiatMax = bignumber_js.BigNumber(max).times(coinUsdtRate).toFixed(_this4._fiatDecimalsCount);
+              }
+            }
+            var composeFailResult = function composeFailResult(reason) {
+              var _details$rate;
+              return {
+                result: false,
+                reason: reason,
+                min: min != null ? min : null,
+                fiatMin: fiatMin,
+                max: max != null ? max : null,
+                fiatMax: fiatMax,
+                rate: (_details$rate = details.rate) != null ? _details$rate : null
+              };
+            };
+            if (!details.result) {
+              if ((details == null ? void 0 : details.reason) === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) return composeFailResult(_this4.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(_this4.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+              }
+            }
+            var fromAmountBigNumber = bignumber_js.BigNumber(fromAmountCoins);
+            if (typeof min === "string" && fromAmountBigNumber.lt(min)) {
+              return composeFailResult(_this4.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_LESS_THAN_MIN_SWAPPABLE);
+            } else if (typeof max === "string" && fromAmountBigNumber.gt(max)) {
+              return composeFailResult(_this4.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_HIGHER_THAN_MAX_SWAPPABLE);
+            }
+            var toAmountCoins = AmountUtils.trim(fromAmountBigNumber.times(details.rate), fromCoin.digits);
+            var result = {
+              result: true,
+              swapCreationInfo: new PublicSwapCreationInfo(fromCoin, toCoin, fromAmountCoins, toAmountCoins, details.rate, details.rawSwapData, min, fiatMin, max, fiatMax, details.durationMinutesRange)
+            };
+            Logger.log("Result: " + safeStringify({
+              result: result.result,
+              swapCreationInfo: _extends({}, result.swapCreationInfo, {
+                fromCoin: result == null || (_result$swapCreationI = result.swapCreationInfo) == null || (_result$swapCreationI = _result$swapCreationI.fromCoin) == null ? void 0 : _result$swapCreationI.ticker,
+                toCoin: result == null || (_result$swapCreationI2 = result.swapCreationInfo) == null || (_result$swapCreationI2 = _result$swapCreationI2.toCoin) == null ? void 0 : _result$swapCreationI2.ticker
+              })
+            }), loggerSource);
+            return result;
+          });
+        });
+      }, function (e) {
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Creates swap by given params.
+   *
+   * @param fromCoin {Coin}
+   * @param toCoin {Coin}
+   * @param fromAmount {string}
+   * @param swapCreationInfo {PublicSwapCreationInfo}
+   * @param toAddress {string}
+   * @param refundAddress {string}
+   * @return {Promise<{
+   *             result: true,
+   *             fiatCurrencyCode: string,
+   *             toCoin: Coin,
+   *             fromAmountFiat: (number|null),
+   *             address: string,
+   *             durationMinutesRange: string,
+   *             fromAmount: string,
+   *             toAmount: string,
+   *             toAmountFiat: (number|null),
+   *             fiatCurrencyDecimals: number,
+   *             fromCoin: Coin,
+   *             rate: string,
+   *             swapId: string
+   *         }|{
+   *             result: false,
+   *             reason: string
+   *         }>}
+   */
+  ;
+  PublicSwapService.createPublicSwap = function createPublicSwap(fromCoin, toCoin, fromAmount, swapCreationInfo, toAddress, refundAddress, clientIp) {
+    try {
+      var _this5 = this;
+      var loggerSource = "createPublicSwap";
+      return Promise.resolve(_catch(function () {
+        var _swapCreationInfo$fro, _swapCreationInfo$toC;
+        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof fromAmount !== "string" || typeof toAddress !== "string" || typeof refundAddress !== "string" || !(swapCreationInfo instanceof PublicSwapCreationInfo)) {
+          throw new Error("Wrong input: " + fromCoin.ticker + " " + toCoin.ticker + " " + fromAmount + " " + swapCreationInfo);
+        }
+        Logger.log("Start: " + fromAmount + " " + fromCoin.ticker + " -> " + toCoin.ticker + ". Details: " + safeStringify(_extends({}, swapCreationInfo, {
+          fromCoin: swapCreationInfo == null || (_swapCreationInfo$fro = swapCreationInfo.fromCoin) == null ? void 0 : _swapCreationInfo$fro.ticker,
+          toCoin: swapCreationInfo == null || (_swapCreationInfo$toC = swapCreationInfo.toCoin) == null ? void 0 : _swapCreationInfo$toC.ticker
+        })), loggerSource);
+        return Promise.resolve(_this5._swapProvider.createSwap(fromCoin, toCoin, fromAmount, toAddress, refundAddress, swapCreationInfo.rawSwapData, clientIp)).then(function (result) {
+          var _exit;
+          function _temp5(_result5) {
+            if (_exit) return _result5;
+            throw new Error("Unexpected result from provider " + safeStringify(result));
+          }
+          Logger.log("Created:" + safeStringify(_extends({}, result, {
+            fromCoin: fromCoin == null ? void 0 : fromCoin.ticker,
+            toCoin: toCoin == null ? void 0 : toCoin.ticker
+          })), loggerSource);
+          if (!(result != null && result.result)) {
+            if ((result == null ? void 0 : result.reason) === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+              SwapUtils.safeHandleRequestsLimitExceeding();
+              return {
+                result: false,
+                reason: _this5.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+              };
+            }
+            if ((result == null ? void 0 : result.reason) === SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL) {
+              // TODO: [feature, high] implement retrying if one partner fail and we have another partners task_id=a07e367e488f4a4899613ac9056fa359
+              // return {
+              //     result: false,
+              //     reason: this.SWAP_CREATION_FAIL_REASONS.RETRIABLE_FAIL,
+              // };
+            }
+          }
+          var _temp4 = function () {
+            if (result.result && result != null && result.swapId) {
+              var _temp3 = function _temp3() {
+                EventBusInstance__default["default"].dispatch(_this5.PUBLIC_SWAP_CREATED_EVENT, null, fromCoin.ticker, toCoin.ticker, _fromAmountFiat);
+                var toReturn = {
+                  result: true,
+                  swapId: result.swapId,
+                  fromCoin: fromCoin,
+                  toCoin: toCoin,
+                  fromAmount: result.fromAmount,
+                  toAmount: result.toAmount,
+                  fromAmountFiat: _fromAmountFiat,
+                  toAmountFiat: _toAmountFiat,
+                  fiatCurrencyCode: "USD",
+                  fiatCurrencyDecimals: _this5._fiatDecimalsCount,
+                  rate: result.rate,
+                  durationMinutesRange: swapCreationInfo.durationMinutesRange,
+                  address: result.fromAddress // CRITICAL: this is the address to send coins to swaps provider
+                };
+                _this5._savePublicSwapIdLocally(result.swapId);
+                Logger.log("Returning: " + safeStringify(_extends({}, toReturn, {
+                  fromCoin: fromCoin == null ? void 0 : fromCoin.ticker,
+                  toCoin: toCoin == null ? void 0 : toCoin.ticker
+                })), loggerSource);
+                _exit = 1;
+                return toReturn;
+              };
+              var _fromAmountFiat = null,
+                _toAmountFiat = null;
+              var _temp2 = _catch(function () {
+                return Promise.resolve(_this5._swapProvider.getCoinToUSDTRate(fromCoin)).then(function (_this5$_swapProvider$) {
+                  var _this5$_swapProvider$3;
+                  var fromCoinUsdtRate = (_this5$_swapProvider$3 = _this5$_swapProvider$ == null ? void 0 : _this5$_swapProvider$.rate) != null ? _this5$_swapProvider$3 : null;
+                  return Promise.resolve(_this5._swapProvider.getCoinToUSDTRate(fromCoin)).then(function (_this5$_swapProvider$2) {
+                    var _this5$_swapProvider$4;
+                    var toCoinUsdtRate = (_this5$_swapProvider$4 = _this5$_swapProvider$2 == null ? void 0 : _this5$_swapProvider$2.rate) != null ? _this5$_swapProvider$4 : null;
+                    if (fromCoinUsdtRate != null && result.fromAmount != null) {
+                      _fromAmountFiat = bignumber_js.BigNumber(result.fromAmount).times(fromCoinUsdtRate).toFixed(_this5._fiatDecimalsCount);
+                    }
+                    if (toCoinUsdtRate != null && result.toAmount != null) {
+                      _toAmountFiat = bignumber_js.BigNumber(result.toAmount).times(toCoinUsdtRate).toFixed(_this5._fiatDecimalsCount);
+                    }
+                  });
+                });
+              }, function (e) {
+                Logger.logError(e, loggerSource, "Failed to calculate fiat amounts for result");
+              });
+              return _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
+            }
+          }();
+          return _temp4 && _temp4.then ? _temp4.then(_temp5) : _temp5(_temp4);
+        });
+      }, function (e) {
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Retrieves swap details and status for existing swaps by their ids.
+   *
+   * @param swapIds {string[]}
+   * @return {Promise<{
+   *              result: true,
+   *              swaps: ExistingSwapWithFiatData[]
+   *         }|{
+   *              result: false,
+   *              reason: string
+   *         }>}
+   *         error reason is one of PUBLIC_SWAPS_COMMON_ERRORS
+   */
+  ;
+  PublicSwapService.getPublicExistingSwapDetailsAndStatus = function getPublicExistingSwapDetailsAndStatus(swapIds) {
+    try {
+      var _this6 = this;
+      var loggerSource = "getPublicExistingSwapDetailsAndStatus";
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(SwapUtils.getExistingSwapsDetailsWithFiatAmounts(_this6._swapProvider, swapIds)).then(function (result) {
+          if (!(result != null && result.result)) {
+            if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+              SwapUtils.safeHandleRequestsLimitExceeding();
+              return {
+                result: false,
+                reason: _this6.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+              };
+            }
+            throw new Error("Unknown reason: " + (result == null ? void 0 : result.reason));
+          }
+          return result;
+        });
+      }, function (e) {
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * Retrieves the whole available swaps history by ids saved locally.
+   *
+   * @return {Promise<{
+   *             result: true,
+   *             swaps: ExistingSwapWithFiatData[]
+   *         }|{
+   *             result: false,
+   *             reason: string
+   *         }>}
+   */
+  ;
+  PublicSwapService.getPublicSwapsHistory = function getPublicSwapsHistory() {
+    try {
+      var _exit2;
+      var _this7 = this;
+      return Promise.resolve(_catch(function () {
+        function _temp7(_result7) {
+          return _exit2 ? _result7 : {
+            result: true,
+            swaps: []
+          };
+        }
+        var swapIds = _this7._getPublicSwapIdsSavedLocally();
+        var _temp6 = function () {
+          if (swapIds.length) {
+            return Promise.resolve(_this7.getPublicExistingSwapDetailsAndStatus(swapIds)).then(function (_await$_this7$getPubl) {
+              _exit2 = 1;
+              return _await$_this7$getPubl;
+            });
+          }
+        }();
+        return _temp6 && _temp6.then ? _temp6.then(_temp7) : _temp7(_temp6);
+      }, function (e) {
+        improveAndRethrow(e, "getPublicSwapsHistory");
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * @param swapId {string}
+   * @private
+   */
+  ;
+  PublicSwapService._savePublicSwapIdLocally = function _savePublicSwapIdLocally(swapId) {
+    if (typeof window !== "undefined") {
+      try {
+        var saved = localStorage.getItem("publicSwapIds");
+        var ids = typeof saved === "string" && saved.length > 0 ? saved.split(",") : [];
+        ids.push(swapId);
+        localStorage.setItem("publicSwapIds", ids.join(","));
+      } catch (e) {
+        improveAndRethrow(e, "_savePublicSwapIdLocally");
+      }
+    }
+  }
+
+  /**
+   * @private
+   * @return {string[]}
+   */;
+  PublicSwapService._getPublicSwapIdsSavedLocally = function _getPublicSwapIdsSavedLocally() {
+    if (typeof window !== "undefined") {
+      try {
+        var saved = localStorage.getItem("publicSwapIds");
+        return typeof saved === "string" && saved.length > 0 ? saved.split(",") : [];
+      } catch (e) {
+        improveAndRethrow(e, "_getPublicSwapIdsSavedLocally");
+      }
+    }
+  }
+
+  /**
+   * @param coinOrTicker {Coin|string}
+   * @return {string} icon URL (ready to use)
+   */;
+  PublicSwapService.getAssetIconUrl = function getAssetIconUrl(coinOrTicker) {
+    return this._swapProvider.getIconUrl(coinOrTicker);
+  }
+
+  /**
+   * @param ticker {string}
+   * @return {Coin|null}
+   */;
+  PublicSwapService.getCoinByTickerIfPresent = function getCoinByTickerIfPresent(ticker) {
+    return this._swapProvider.getCoinByTickerIfPresent(ticker);
+  }
+
+  /**
+   * TODO: [feature, moderate] add other fiat currencies support. task_id=5490e21b8b9c4f89a2247b28db3c9e0a
+   * @param asset {Coin}
+   * @return {Promise<string|null>}
+   */;
+  PublicSwapService.getAssetToUsdtRate = function getAssetToUsdtRate(asset) {
+    try {
+      var _this8 = this;
+      return Promise.resolve(_catch(function () {
+        return Promise.resolve(_this8._swapProvider.getCoinToUSDTRate(asset)).then(function (result) {
+          var _result$rate;
+          return (_result$rate = result == null ? void 0 : result.rate) != null ? _result$rate : null;
+        });
+      }, function (e) {
+        improveAndRethrow(e, "getAssetToUsdtRate");
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * @param asset {Coin}
+   * @param address {string}
+   * @return {boolean}
+   */
+  ;
+  PublicSwapService.isAddressValidForAsset = function isAddressValidForAsset(asset, address) {
+    try {
+      return this._swapProvider.isAddressValidForAsset(asset, address);
+    } catch (e) {
+      improveAndRethrow(e, "isAddressValidForAsset");
+    }
+  }
+
+  // TODO: [dev] Remove if we don't need this inside the public swap steps
+  // /**
+  //  * TODO: [feature, moderate] add other fiat currencies support. task_id=5490e21b8b9c4f89a2247b28db3c9e0a
+  //  * @param asset {Coin}
+  //  * @param amount {string}
+  //  * @return {Promise<string|null>}
+  //  */
+  // static async convertSingleCoinAmountToUsdtOrNull(asset, amount) {
+  //     try {
+  //         const result = await this._swapProvider.getCoinToUSDTRate(asset);
+  //         if (result?.rate != null) {
+  //             const decimals = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+  //             return BigNumber(amount).div(result?.rate).toFixed(decimals);
+  //         }
+  //         return null;
+  //     } catch (e) {
+  //         improveAndRethrow(e, "convertSingleCoinAmountToUsdtOrNull");
+  //     }
+  // }
+  //
+  // /**
+  //  * TODO: [feature, moderate] add other fiat currencies support. task_id=5490e21b8b9c4f89a2247b28db3c9e0a
+  //  * @param asset {Coin}
+  //  * @param amount {string}
+  //  * @return {Promise<string|null>}
+  //  */
+  // static async convertSingleUsdtAmountToCoinOrNull(asset, amount) {
+  //     try {
+  //         const result = await this._swapProvider.getCoinToUSDTRate(asset);
+  //         if (result?.rate != null) {
+  //             return BigNumber(amount).times(result?.rate).toFixed(asset.digits);
+  //         }
+  //         return null;
+  //     } catch (e) {
+  //         improveAndRethrow(e, "convertSingleUsdtAmountToCoinOrNull");
+  //     }
+  // }
+  ;
+  return PublicSwapService;
+}();
+PublicSwapService.PUBLIC_SWAP_CREATED_EVENT = "publicSwapCreatedEvent";
+PublicSwapService._swapProvider = new SwapspaceSwapProvider(API_KEYS_PROXY_URL, cache, function () {
+  return null;
+}, false);
+PublicSwapService.PUBLIC_SWAPS_COMMON_ERRORS = {
+  REQUESTS_LIMIT_EXCEEDED: "requestsLimitExceeded"
+};
+PublicSwapService.PUBLIC_SWAP_DETAILS_FAIL_REASONS = {
+  AMOUNT_LESS_THAN_MIN_SWAPPABLE: "amountLessThanMinSwappable",
+  AMOUNT_HIGHER_THAN_MAX_SWAPPABLE: "amountHigherThanMaxSwappable",
+  PAIR_NOT_SUPPORTED: "pairNotSupported"
+};
+PublicSwapService._fiatDecimalsCount = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+
 exports.AmountUtils = AmountUtils;
 exports.AssetIcon = AssetIcon;
 exports.Blockchain = Blockchain;
@@ -3482,8 +4344,10 @@ exports.Logger = Logger;
 exports.LogsStorage = LogsStorage;
 exports.Protocol = Protocol;
 exports.PublicSwapCreationInfo = PublicSwapCreationInfo;
+exports.PublicSwapService = PublicSwapService;
 exports.SupportChat = SupportChat;
 exports.SwapProvider = SwapProvider;
+exports.SwapUtils = SwapUtils;
 exports.SwapspaceSwapProvider = SwapspaceSwapProvider;
 exports.improveAndRethrow = improveAndRethrow;
 exports.safeStringify = safeStringify;