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

package/dist/index.cjs

@@ -1,9 +1,11 @@
 var React = require('react');
 var bignumber_js = require('bignumber.js');
+var axios = require('axios');
 
 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);
 
 function createCommonjsModule(fn) {
   var module = { exports: {} };
@@ -1572,6 +1574,18 @@ function _extends() {
   };
   return _extends.apply(this, arguments);
 }
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
 function _unsupportedIterableToArray(o, minLen) {
   if (!o) return;
   if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -2491,6 +2505,40 @@ var Cache = /*#__PURE__*/function () {
   return Cache;
 }();
 
+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 EmailsApi = /*#__PURE__*/function () {
+  function EmailsApi() {}
+  EmailsApi.sendEmail = function sendEmail(subject, body) {
+    try {
+      var _this = this;
+      var _temp = _catch$1(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}
@@ -2532,6 +2580,81 @@ partner) {
   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;
@@ -2735,20 +2858,633 @@ SwapProvider.SWAP_STATUSES = {
   FAILED: "failed" // public +
 };
 
+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 BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
+var FALLBACK_ICON_URL = "https://rabbit.io/asset-icons/fallback.svg";
+var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
+  _inheritsLoose(SwapspaceSwapProvider, _SwapProvider);
+  function SwapspaceSwapProvider(apiKeysProxyUrl, cache, customCoinBuilder, useRestrictedCoinsSet) {
+    var _this;
+    if (customCoinBuilder === void 0) {
+      customCoinBuilder = function customCoinBuilder(coin, network) {
+        return null;
+      };
+    }
+    if (useRestrictedCoinsSet === void 0) {
+      useRestrictedCoinsSet = true;
+    }
+    _this = _SwapProvider.call(this) || this;
+    _this._supportedCoins = [];
+    _this._URL = apiKeysProxyUrl + "/swapspace";
+    _this._maxRateDigits = 20;
+    _this.useRestrictedCoinsSet = useRestrictedCoinsSet;
+    _this._customCoinBuilder = customCoinBuilder;
+    _this._cache = cache;
+    return _this;
+  }
+  var _proto = SwapspaceSwapProvider.prototype;
+  _proto.getSwapCreationInfoTtlMs = function getSwapCreationInfoTtlMs() {
+    /* Actually 2 minutes and only relevant for some partners, but we use it
+     * (and even a bit smaller value) for better consistency */
+    return 110000;
+  };
+  _proto.getDepositCurrencies = function getDepositCurrencies() {
+    try {
+      var _this2 = this;
+      var loggerSource = "getDepositCurrencies";
+      return Promise.resolve(_catch(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);
+          return {
+            result: true,
+            coins: _this2._supportedCoins.filter(function (item) {
+              return item.deposit;
+            }).map(function (item) {
+              return item.coin;
+            })
+          };
+        });
+      }, function (e) {
+        var _e$response;
+        if ((e == null || (_e$response = e.response) == null ? void 0 : _e$response.status) === 429) {
+          return {
+            result: false,
+            reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+          };
+        }
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getWithdrawalCurrencies = function getWithdrawalCurrencies(exceptCurrency) {
+    if (exceptCurrency === void 0) {
+      exceptCurrency = null;
+    }
+    try {
+      var _this3 = this;
+      var loggerSource = "getWithdrawalCurrencies";
+      return Promise.resolve(_catch(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);
+          return {
+            result: true,
+            coins: _this3._supportedCoins.filter(function (item) {
+              return item.withdrawal && (!exceptCurrency || item.coin !== exceptCurrency);
+            }).map(function (item) {
+              return item.coin;
+            })
+          };
+        });
+      }, function (e) {
+        var _e$response2;
+        if ((e == null || (_e$response2 = e.response) == null ? void 0 : _e$response2.status) === 429) {
+          return {
+            result: false,
+            reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+          };
+        }
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.initialize = function initialize() {
+    try {
+      var _this4 = this;
+      return Promise.resolve(_this4._fetchSupportedCurrenciesIfNeeded()).then(function () {});
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getIconUrl = function getIconUrl(coinOrTicker) {
+    var loggerSource = "getIconUrl";
+    try {
+      var _this$_supportedCoins2, _this$_supportedCoins3;
+      var coin = coinOrTicker;
+      if (!(coinOrTicker instanceof Coin)) {
+        var _this$_supportedCoins;
+        coin = (_this$_supportedCoins = this._supportedCoins.find(function (i) {
+          return i.coin.ticker === coinOrTicker;
+        })) == null ? void 0 : _this$_supportedCoins.coin;
+      }
+      return (_this$_supportedCoins2 = (_this$_supportedCoins3 = this._supportedCoins.find(function (item) {
+        return item.coin === coin;
+      })) == null ? void 0 : _this$_supportedCoins3.iconURL) != null ? _this$_supportedCoins2 : FALLBACK_ICON_URL;
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  };
+  _proto._fetchSupportedCurrenciesIfNeeded = function _fetchSupportedCurrenciesIfNeeded() {
+    try {
+      var _this5 = this;
+      var loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+      return Promise.resolve(_catch(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) {
+              var _rawResponse$data, _rawResponse$data2;
+              Logger.log("Retrieved " + (rawResponse == null || (_rawResponse$data = rawResponse.data) == null ? void 0 : _rawResponse$data.length) + " currencies", loggerSource);
+              _this5._supportedCoins = ((_rawResponse$data2 = rawResponse == null ? void 0 : rawResponse.data) != null ? _rawResponse$data2 : []).map(function (item) {
+                var coin = _this5._customCoinBuilder(item.code, item.network);
+                if (!coin && !_this5.useRestrictedCoinsSet) {
+                  /** Building coin object for coin that isn't supported OOB in Rabbit.
+                   * We are doing this way to be able to use extended coins set for swaps.
+                   * These temporary built coins are only for in-swap use, and we omit some usual
+                   * coin details here.
+                   * Ideally we should add some new abstractions e.g. BaseCoin:
+                   * Coin will extend BaseCoin, SwapCoin will extend BaseCoin etc.
+                   * But for now it is reasonable to use this simpler approach.
+                   */
+                  var code = item.code.toUpperCase();
+                  var network = item.network.toUpperCase();
+                  var ticker = "" + code + (code === network ? "" : network);
+                  var defaultDecimalPlacesForCoinNotSupportedOOB = 8;
+                  var defaultMinConfirmationsForCoinNotSupportedOOB = 1;
+                  coin = new Coin(item.name, ticker, code, defaultDecimalPlacesForCoinNotSupportedOOB, null, "", null, null, defaultMinConfirmationsForCoinNotSupportedOOB, null, [], 60000, null,
+                  // We cannot recognize blockchain from swapspace data
+                  new Protocol(network),
+                  // TODO: [dev] maybe we should recognize standard protocols?
+                  item.contractAddress || null, false);
+                }
+                if (coin) {
+                  var _item$deposit, _item$withdrawal, _item$validationRegex;
+                  return {
+                    coin: coin,
+                    code: item.code,
+                    network: item.network,
+                    extraId: item.extraIdName,
+                    isPopular: !!(item != null && 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,
+                    validationRegexp: (_item$validationRegex = item.validationRegexp) != null ? _item$validationRegex : null
+                  };
+                }
+                return [];
+              }).flat();
+              _this5._putPopularCoinsFirst();
+            });
+          }
+        }();
+        if (_temp && _temp.then) return _temp.then(function () {});
+      }, function (e) {
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /**
+   * This method sort internal list putting popular (as swapspace thinks) coins to the top.
+   * This is just for users of this API if they don't care about the sorting - we just improve a list a bit this way.
+   * @private
+   */
+  ;
+  _proto._putPopularCoinsFirst = function _putPopularCoinsFirst() {
+    this._supportedCoins.sort(function (i1, i2) {
+      if (i1.isPopular && !i2.isPopular) return -1;
+      if (i2.isPopular && !i1.isPopular) return 1;
+      return i1.coin.ticker > i2.coin.ticker ? 1 : i1.coin.ticker < i2.coin.ticker ? -1 : 0;
+    });
+  };
+  _proto.getCoinToUSDTRate = function getCoinToUSDTRate(coin) {
+    try {
+      var _this6 = this;
+      var loggerSource = "getCoinToUSDTRate";
+      return Promise.resolve(_catch(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
+          var usdtTrc20 = (_this6$_supportedCoin = _this6._supportedCoins.find(function (i) {
+            return i.code === "usdt" && i.network === "trc20";
+          })) == null ? void 0 : _this6$_supportedCoin.coin;
+          if (!usdtTrc20) {
+            return {
+              result: false
+            };
+          }
+          var cached = _this6._cache.get("swapspace_usdt_rate_" + coin.ticker);
+          if (cached != null) {
+            return {
+              result: true,
+              rate: cached
+            };
+          }
+          Logger.log("Loading USDT -> coin rate as not found in cache:", coin == null ? void 0 : coin.ticker);
+          return Promise.resolve(_this6.getSwapInfo(usdtTrc20, coin, "5000")).then(function (result) {
+            if (!result.result) {
+              return {
+                result: false
+              };
+            }
+
+            // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
+            var standardSwapspaceFeeMultiplier = 1.002; // usually 0.2%
+            var rate = bignumber_js.BigNumber(1).div(bignumber_js.BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
+            _this6._cache.put("swapspace_usdt_rate_" + coin.ticker, rate, 15 * 60000);
+            return {
+              result: true,
+              rate: rate
+            };
+          });
+        });
+      }, function (e) {
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.getCoinByTickerIfPresent = function getCoinByTickerIfPresent(ticker) {
+    try {
+      var _item$coin;
+      var item = this._supportedCoins.find(function (i) {
+        return i.coin.ticker === ticker;
+      });
+      return (_item$coin = item == null ? void 0 : item.coin) != null ? _item$coin : null;
+    } catch (e) {
+      improveAndRethrow(e, "getCoinByTickerIfPresent");
+    }
+  };
+  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate) {
+    if (fromCoinToUsdRate === void 0) {
+      fromCoinToUsdRate = null;
+    }
+    try {
+      var _this7 = this;
+      var loggerSource = "getSwapInfo";
+      return Promise.resolve(_catch(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));
+        }
+        var fromCoinSwapspaceDetails = _this7._supportedCoins.find(function (i) {
+          return i.coin === fromCoin;
+        });
+        var toCoinSwapspaceDetails = _this7._supportedCoins.find(function (i) {
+          return i.coin === toCoin;
+        });
+        if (!fromCoinSwapspaceDetails || !toCoinSwapspaceDetails) {
+          throw new Error("Failed to find swapspace coin details for: " + fromCoin.ticker + " -> " + toCoin.ticker);
+        }
+        /* Here we use not documented parameter 'estimated=false'. This parameter controls whether we want to use
+         * 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.
+         */
+        return Promise.resolve(axios__default["default"].get(_this7._URL + "/api/v2/amounts?fromCurrency=" + fromCoinSwapspaceDetails.code + "&fromNetwork=" + fromCoinSwapspaceDetails.network + "&toNetwork=" + toCoinSwapspaceDetails.network + "&toCurrency=" + toCoinSwapspaceDetails.code + "&amount=" + amountCoins + "&float=true&estimated=false")).then(function (response) {
+          var _response$data;
+          Logger.log("Retrieved " + (response == null || (_response$data = response.data) == null ? void 0 : _response$data.length) + " options", loggerSource);
+          var options = Array.isArray(response.data) ? response.data : [];
+          var exchangesSupportingThePair = options.filter(function (exchange) {
+            return (exchange == null ? void 0 : exchange.exists) && !BANNED_PARTNERS.find(function (bannedPartner) {
+              return bannedPartner === (exchange == null ? void 0 : exchange.partner);
+            }) && (exchange == null ? void 0 : exchange.fixed) === false && (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min || (typeof exchange.min !== "number" || typeof exchange.max !== "number") && exchange.toAmount > 0);
+          });
+          Logger.log((exchangesSupportingThePair == null ? void 0 : exchangesSupportingThePair.length) + " of them have exist=true", loggerSource);
+          if (!exchangesSupportingThePair.length) {
+            return {
+              result: false,
+              reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+            };
+          }
+          var availableExchanges = exchangesSupportingThePair.filter(function (exchange) {
+            return typeof (exchange == null ? void 0 : exchange.toAmount) === "number" && exchange.toAmount > 0;
+          });
+          Logger.log("Available (having amountTo): " + safeStringify(availableExchanges), loggerSource);
+          // min=0 or max=0 means there is no limit for the partner
+          var smallestMin = null;
+          if (exchangesSupportingThePair.find(function (ex) {
+            return bignumber_js.BigNumber(ex.min).isZero();
+          }) == null) {
+            smallestMin = exchangesSupportingThePair.reduce(function (prev, cur) {
+              if (typeof cur.min === "number" && (prev === null || bignumber_js.BigNumber(cur.min).lt(prev))) return bignumber_js.BigNumber(cur.min);
+              return prev;
+            }, null);
+          }
+          var greatestMax = null;
+          if (exchangesSupportingThePair.find(function (ex) {
+            return bignumber_js.BigNumber(ex.max).isZero();
+          }) == null) {
+            greatestMax = exchangesSupportingThePair.reduce(function (prev, cur) {
+              if (typeof cur.max === "number" && (prev === null || bignumber_js.BigNumber(cur.max).gt(prev))) return bignumber_js.BigNumber(cur.max);
+              return prev;
+            }, null);
+          }
+          var extraCoinsToFitMinMax = "0";
+          if (typeof fromCoinToUsdRate === "string" && bignumber_js.BigNumber(fromCoinToUsdRate).gt("0")) {
+            var extraUsdToFitMinMax = bignumber_js.BigNumber("1"); // We correct the limits as the exact limit can fluctuate and cause failed swap creation
+            extraCoinsToFitMinMax = AmountUtils.trim(extraUsdToFitMinMax.div(fromCoinToUsdRate), fromCoin.digits);
+          }
+          if (smallestMin instanceof bignumber_js.BigNumber) {
+            smallestMin = AmountUtils.trim(smallestMin.plus(extraCoinsToFitMinMax), fromCoin.digits);
+          }
+          if (greatestMax instanceof bignumber_js.BigNumber) {
+            if (greatestMax > extraCoinsToFitMinMax) {
+              greatestMax = AmountUtils.trim(greatestMax.minus(extraCoinsToFitMinMax), fromCoin.digits);
+            } else {
+              greatestMax = "0";
+            }
+          }
+          if (availableExchanges.length) {
+            var _bestOpt$duration;
+            var sorted = availableExchanges.sort(function (op1, op2) {
+              return op2.toAmount - op1.toAmount;
+            });
+            var bestOpt = sorted[0];
+            Logger.log("Returning first option after sorting: " + safeStringify(bestOpt), loggerSource);
+            var max = null;
+            var min = null;
+            if (extraCoinsToFitMinMax != null) {
+              if (typeof bestOpt.max === "number" && bestOpt.max !== 0) {
+                max = bignumber_js.BigNumber(bestOpt.max).minus(extraCoinsToFitMinMax);
+                max = AmountUtils.trim(max.lt(0) ? "0" : max, fromCoin.digits);
+              }
+              if (typeof bestOpt.min === "number" && bestOpt.min !== 0) {
+                min = AmountUtils.trim(bignumber_js.BigNumber(bestOpt.min).plus(extraCoinsToFitMinMax), fromCoin.digits);
+              }
+            }
+            var rate = bestOpt.toAmount && bestOpt.fromAmount ? bignumber_js.BigNumber(bestOpt.toAmount).div(bestOpt.fromAmount) : null;
+            return {
+              result: true,
+              min: min,
+              max: max,
+              smallestMin: smallestMin,
+              greatestMax: greatestMax,
+              rate: rate != null ? AmountUtils.trim(rate, _this7._maxRateDigits) : null,
+              durationMinutesRange: (_bestOpt$duration = bestOpt.duration) != null ? _bestOpt$duration : null,
+              rawSwapData: bestOpt
+            };
+          }
+          var result = {
+            result: false,
+            reason: smallestMin && bignumber_js.BigNumber(amountCoins).lt(smallestMin) ? SwapProvider.NO_SWAPS_REASONS.TOO_LOW : greatestMax && bignumber_js.BigNumber(amountCoins).gt(greatestMax) ? SwapProvider.NO_SWAPS_REASONS.TOO_HIGH : SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+            smallestMin: smallestMin,
+            greatestMax: greatestMax
+          };
+          Logger.log("Returning result " + safeStringify(result), loggerSource);
+          return result;
+        });
+      }, function (e) {
+        var _e$response3;
+        if ((e == null || (_e$response3 = e.response) == null ? void 0 : _e$response3.status) === 429) {
+          return {
+            result: false,
+            reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+          };
+        }
+        Logger.log("Internal swapspace/rabbit error when getting swap options " + safeStringify(e), loggerSource);
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress) {
+    try {
+      var _this8 = this;
+      var loggerSource = "createSwap";
+      var partner = rawSwapData == null ? void 0 : rawSwapData.partner;
+      return Promise.resolve(_catch(function () {
+        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amount !== "string" || typeof toAddress !== "string" || typeof refundAddress !== "string") {
+          throw new Error("Invalid input: " + fromCoin + " " + toCoin + " " + amount + " " + toAddress + " " + refundAddress);
+        }
+        if (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));
+        }
+        return Promise.resolve(_this8._fetchSupportedCurrenciesIfNeeded()).then(function () {
+          var _this8$_supportedCoin, _this8$_supportedCoin2;
+          var toCurrencyExtraId = (_this8$_supportedCoin = (_this8$_supportedCoin2 = _this8._supportedCoins.find(function (item) {
+            return item.coin === toCoin;
+          })) == null ? void 0 : _this8$_supportedCoin2.extraId) != null ? _this8$_supportedCoin : "";
+          var requestData = {
+            partner: partner,
+            fromCurrency: rawSwapData == null ? void 0 : rawSwapData.fromCurrency,
+            fromNetwork: rawSwapData == null ? void 0 : rawSwapData.fromNetwork,
+            toCurrency: rawSwapData == null ? void 0 : rawSwapData.toCurrency,
+            toNetwork: rawSwapData == null ? void 0 : rawSwapData.toNetwork,
+            address: toAddress,
+            amount: amount,
+            fixed: false,
+            extraId: toCurrencyExtraId != null ? toCurrencyExtraId : "",
+            rateId: rawSwapData == null ? void 0 : rawSwapData.id,
+            userIp: clientIpAddress,
+            refund: refundAddress
+          };
+          Logger.log("Sending create request: " + safeStringify(requestData), loggerSource);
+          return Promise.resolve(axios__default["default"].post(_this8._URL + "/api/v2/exchange", requestData)).then(function (response) {
+            var result = response.data;
+            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;
+              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);
+              /* We use the returned rate preferably but if the retrieved
+               * rate 0/null/undefined we calculate it manually */
+              var rate = result.rate;
+              if (typeof rate !== "number" || bignumber_js.BigNumber(rate).isZero()) {
+                var _result$to3, _result$from3;
+                rate = bignumber_js.BigNumber(result == null || (_result$to3 = result.to) == null ? void 0 : _result$to3.amount).div(result == null || (_result$from3 = result.from) == null ? void 0 : _result$from3.amount);
+              } else {
+                rate = bignumber_js.BigNumber(rate);
+              }
+              return {
+                result: true,
+                swapId: result == null ? void 0 : result.id,
+                fromCoin: fromCoin,
+                fromAmount: AmountUtils.trim(result == null || (_result$from4 = result.from) == null ? void 0 : _result$from4.amount, fromCoin.digits),
+                fromAddress: result == null || (_result$from5 = result.from) == null ? void 0 : _result$from5.address,
+                toCoin: toCoin,
+                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,
+                rate: AmountUtils.trim(rate, _this8._maxRateDigits)
+              };
+            }
+            var errorMessage = "Swap creation succeeded but the response is wrong: " + safeStringify(response);
+            Logger.log(errorMessage, loggerSource);
+            throw new Error(errorMessage);
+          });
+        });
+      }, function (e) {
+        var _e$response4, _e$response5;
+        Logger.log("Failed to create swap. Error is: " + safeStringify(e), loggerSource);
+        var composeFailResult = function composeFailResult(reason) {
+          return {
+            result: false,
+            reason: reason,
+            partner: partner
+          };
+        };
+        var status = e == null || (_e$response4 = e.response) == null ? void 0 : _e$response4.status;
+        var data = e == null || (_e$response5 = e.response) == null ? void 0 : _e$response5.data;
+        if (status === 429) {
+          Logger.log("Returning fail - RPS limit exceeded " + data, loggerSource);
+          return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        }
+        var texts422 = ["Pair cannot be processed by", "Currency not found", "Amount maximum is", "Amount minimum is"];
+        var text403 = "IP address is forbidden";
+        if (typeof data === "string" && (status === 403 && data.includes(text403) || status === 422 && texts422.find(function (text) {
+          return data.includes(text);
+        }))) {
+          Logger.log("Returning retriable fail: " + status + " - " + data + ", " + partner, loggerSource);
+          return composeFailResult(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+        }
+        Logger.log("Internal swapspace/rabbit error for " + partner + ": " + safeStringify(e), loggerSource);
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto._mapSwapspaceStatusToRabbitStatus = function _mapSwapspaceStatusToRabbitStatus(status) {
+    switch (status) {
+      case "waiting":
+        return SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT;
+      case "confirming":
+        return SwapProvider.SWAP_STATUSES.CONFIRMING;
+      case "exchanging":
+        return SwapProvider.SWAP_STATUSES.EXCHANGING;
+      case "sending":
+        return SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED;
+      case "finished":
+        return SwapProvider.SWAP_STATUSES.COMPLETED;
+      case "verifying":
+        return SwapProvider.SWAP_STATUSES.EXCHANGING;
+      case "refunded":
+        return SwapProvider.SWAP_STATUSES.REFUNDED;
+      case "expired":
+        return SwapProvider.SWAP_STATUSES.EXPIRED;
+      case "failed":
+        return SwapProvider.SWAP_STATUSES.FAILED;
+      default:
+        throw new Error("Unknown swapspace status: " + status);
+    }
+  };
+  _proto.getExistingSwapsDetailsAndStatus = function getExistingSwapsDetailsAndStatus(swapIds) {
+    try {
+      var _this9 = this;
+      var loggerSource = "getExistingSwapsDetailsAndStatus";
+      return Promise.resolve(_catch(function () {
+        if (swapIds.find(function (id) {
+          return typeof id !== "string";
+        })) {
+          throw new Error("Swap id is not string: " + safeStringify(swapIds));
+        }
+        var getNotFailingOn404 = function getNotFailingOn404(swapId) {
+          try {
+            return Promise.resolve(_catch(function () {
+              return Promise.resolve(axios__default["default"].get(_this9._URL + "/api/v2/exchange/" + swapId));
+            }, function (error) {
+              var _error$response;
+              if ((error == null || (_error$response = error.response) == null ? void 0 : _error$response.status) === 404) return [];
+              throw error;
+            }));
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        };
+        return Promise.resolve(Promise.all(swapIds.map(function (swapId) {
+          return getNotFailingOn404(swapId);
+        }))).then(function (responses) {
+          var wo404 = responses.flat();
+          var swaps = wo404.map(function (r) {
+            return r.data;
+          }).map(function (swap, index) {
+            var _this9$_supportedCoin, _this9$_supportedCoin2;
+            var fromCoin = (_this9$_supportedCoin = _this9._supportedCoins.find(function (i) {
+              return i.code === swap.from.code && i.network === swap.from.network;
+            })) == null ? void 0 : _this9$_supportedCoin.coin;
+            var toCoin = (_this9$_supportedCoin2 = _this9._supportedCoins.find(function (i) {
+              return i.code === swap.to.code && i.network === swap.to.network;
+            })) == null ? void 0 : _this9$_supportedCoin2.coin;
+            if (!fromCoin || !toCoin) {
+              return []; // We skip swaps with not supported coins for now
+            }
+            var status = _this9._mapSwapspaceStatusToRabbitStatus(swap.status);
+            var toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+            var addressToSendCoinsToSwapspace = swap.from.address;
+            var toUtcTimestamp = function toUtcTimestamp(timeStr) {
+              return Date.parse(timeStr.match(/.+[Zz]$/) ? timeStr : timeStr + "Z");
+            };
+            return new ExistingSwap(swapIds[index], status, toUtcTimestamp(swap.timestamps.createdAt), toUtcTimestamp(swap.timestamps.expiresAt), swap.confirmations, AmountUtils.trim(swap.rate, _this9._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);
+          }).flat();
+          Logger.log("Swap details result " + safeStringify(swaps), loggerSource);
+          return {
+            result: true,
+            swaps: swaps
+          };
+        });
+      }, function (e) {
+        var _e$response6, _e$response7;
+        Logger.log("Failed to get swap details. Error is: " + safeStringify(e), loggerSource);
+        var composeFailResult = function composeFailResult(reason) {
+          return {
+            result: false,
+            reason: reason
+          };
+        };
+        var status = e == null || (_e$response6 = e.response) == null ? void 0 : _e$response6.status;
+        var data = e == null || (_e$response7 = e.response) == null ? void 0 : _e$response7.data;
+        if (status === 429) {
+          Logger.log("Returning fail - RPS limit exceeded " + data, loggerSource);
+          return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        }
+        improveAndRethrow(e, loggerSource);
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  _proto.isAddressValidForAsset = function isAddressValidForAsset(asset, address) {
+    try {
+      var assetData = this._supportedCoins.find(function (i) {
+        return i.coin === asset;
+      });
+      if (assetData) {
+        var corrected = assetData.validationRegexp.trim();
+        corrected = corrected[0] === "/" ? corrected.slice(1) : corrected;
+        corrected = corrected[corrected.length - 1] === "/" ? corrected.slice(0, corrected.length - 1) : corrected;
+        return address.match(corrected) != null;
+      }
+    } catch (e) {
+      Logger.logError(e, "isAddressValidForAsset");
+    }
+    return false;
+  };
+  return SwapspaceSwapProvider;
+}(SwapProvider);
+
 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.SupportChat = SupportChat;
 exports.SwapProvider = SwapProvider;
+exports.SwapspaceSwapProvider = SwapspaceSwapProvider;
 exports.improveAndRethrow = improveAndRethrow;
 exports.safeStringify = safeStringify;
 //# sourceMappingURL=index.cjs.map