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

package/dist/index.umd.js

@@ -1,12 +1,13 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('bignumber.js'), require('axios')) :
-	typeof define === 'function' && define.amd ? define(['exports', 'react', 'bignumber.js', 'axios'], factory) :
-	(global = global || self, factory(global.uiKit = {}, global.react, global.bignumber_js, global.axios));
-})(this, (function (exports, React, bignumber_js, axios) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('bignumber.js'), require('axios'), require('eventbusjs')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'react', 'bignumber.js', 'axios', 'eventbusjs'], factory) :
+	(global = global || self, factory(global.uiKit = {}, global.react, global.bignumber_js, global.axios, global.eventbusjs));
+})(this, (function (exports, React, bignumber_js, axios, EventBusInstance) {
 	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: {} };
@@ -2506,6 +2507,40 @@
 	  return Cache;
 	}();
 
+	function _catch$3(body, recover) {
+	  try {
+	    var result = body();
+	  } catch (e) {
+	    return recover(e);
+	  }
+	  if (result && result.then) {
+	    return result.then(void 0, recover);
+	  }
+	  return result;
+	}
+	var EmailsApi = /*#__PURE__*/function () {
+	  function EmailsApi() {}
+	  EmailsApi.sendEmail = function sendEmail(subject, body) {
+	    try {
+	      var _this = this;
+	      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,
+	          body: body
+	        })).then(function () {});
+	      }, function (e) {
+	        improveAndRethrow(e, "sendEmail", subject + body);
+	      });
+	      return Promise.resolve(_temp && _temp.then ? _temp.then(function () {}) : void 0);
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  return EmailsApi;
+	}();
+	EmailsApi.serverEndpointEntity = "emails";
+
 	var ExistingSwap =
 	/**
 	 * @param swapId {string}
@@ -2547,6 +2582,81 @@
 	  this.partner = partner;
 	};
 
+	var ExistingSwapWithFiatData = /*#__PURE__*/function (_ExistingSwap) {
+	  _inheritsLoose(ExistingSwapWithFiatData, _ExistingSwap);
+	  /**
+	   * @param swapId {string}
+	   * @param status {SwapProvider.SWAP_STATUSES}
+	   * @param createdAt {number}
+	   * @param expiresAt {number}
+	   * @param confirmations {number}
+	   * @param rate {string}
+	   * @param refundAddress {string}
+	   * @param fromCoin {Coin}
+	   * @param fromAmount {string}
+	   * @param fromTransactionId {string}
+	   * @param toCoin {Coin}
+	   * @param toAmount {string}
+	   * @param toTransactionId {string|null}
+	   * @param toAddress {string}
+	   * @param partner {string}
+	   * @param fromAmountFiat {number}
+	   * @param toAmountFiat {number}
+	   * @param fiatCurrencyCode {string}
+	   * @param fiatCurrencyDecimals {number}
+	   */
+	  function ExistingSwapWithFiatData(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
+	    var _this;
+	    _this = _ExistingSwap.call(this, swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner) || this;
+	    _this.fromAmountFiat = fromAmountFiat;
+	    _this.toAmountFiat = toAmountFiat;
+	    _this.fiatCurrencyCode = fiatCurrencyCode;
+	    _this.fiatCurrencyDecimals = fiatCurrencyDecimals;
+	    return _this;
+	  }
+
+	  /**
+	   * @param existingSwap {ExistingSwap}
+	   * @param fromAmountFiat {number}
+	   * @param toAmountFiat {number}
+	   * @param fiatCurrencyCode {string}
+	   * @param fiatCurrencyDecimals {number}
+	   * @return {ExistingSwapWithFiatData}
+	   */
+	  ExistingSwapWithFiatData.fromExistingSwap = function fromExistingSwap(existingSwap, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
+	    return new ExistingSwapWithFiatData(existingSwap.swapId, existingSwap.status, existingSwap.createdAt, existingSwap.expiresAt, existingSwap.confirmations, existingSwap.rate, existingSwap.refundAddress, existingSwap.payToAddress, existingSwap.fromCoin, existingSwap.fromAmount, existingSwap.fromTransactionId, existingSwap.fromTransactionLink, existingSwap.toCoin, existingSwap.toAmount, existingSwap.toTransactionId, existingSwap.toTransactionLink, existingSwap.toAddress, existingSwap.partner, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals);
+	  };
+	  return ExistingSwapWithFiatData;
+	}(ExistingSwap);
+
+	var PublicSwapCreationInfo =
+	/**
+	 * @param fromCoin {Coin}
+	 * @param toCoin {Coin}
+	 * @param fromAmountCoins {string}
+	 * @param toAmountCoins {string}
+	 * @param rate {string}
+	 * @param rawSwapData {Object}
+	 * @param min {string}
+	 * @param fiatMin {number}
+	 * @param max {string}
+	 * @param fiatMax {number}
+	 * @param durationMinutesRange {string}
+	 */
+	function PublicSwapCreationInfo(fromCoin, toCoin, fromAmountCoins, toAmountCoins, rate, rawSwapData, min, fiatMin, max, fiatMax, durationMinutesRange) {
+	  this.fromCoin = fromCoin;
+	  this.toCoin = toCoin;
+	  this.fromAmountCoins = fromAmountCoins;
+	  this.toAmountCoins = toAmountCoins;
+	  this.rate = rate;
+	  this.rawSwapData = rawSwapData;
+	  this.min = min;
+	  this.fiatMin = fiatMin;
+	  this.max = max;
+	  this.fiatMax = fiatMax;
+	  this.durationMinutesRange = durationMinutesRange;
+	};
+
 	var SwapProvider = /*#__PURE__*/function () {
 	  function SwapProvider() {}
 	  var _proto = SwapProvider.prototype;
@@ -2750,7 +2860,7 @@
 	  FAILED: "failed" // public +
 	};
 
-	function _catch(body, recover) {
+	function _catch$2(body, recover) {
 	  try {
 	    var result = body();
 	  } catch (e) {
@@ -2794,7 +2904,7 @@
 	    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);
@@ -2828,7 +2938,7 @@
 	    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);
@@ -2885,7 +2995,7 @@
 	    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) {
@@ -2958,7 +3068,7 @@
 	    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
@@ -3020,7 +3130,7 @@
 	    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));
 	        }
@@ -3150,7 +3260,7 @@
 	      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);
 	        }
@@ -3269,7 +3379,7 @@
 	    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";
 	        })) {
@@ -3277,7 +3387,7 @@
 	        }
 	        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;
@@ -3359,20 +3469,885 @@
 	  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;
 	exports.Button = Button;
 	exports.Cache = Cache;
 	exports.Coin = Coin;
+	exports.EmailsApi = EmailsApi;
 	exports.ExistingSwap = ExistingSwap;
+	exports.ExistingSwapWithFiatData = ExistingSwapWithFiatData;
 	exports.FiatCurrenciesService = FiatCurrenciesService;
 	exports.LoadingDots = LoadingDots;
 	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;