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

package/dist/index.modern.js

@@ -1,5 +1,6 @@
 import React, { useState, useRef, useEffect } from 'react';
 import { BigNumber } from 'bignumber.js';
+import axios from 'axios';
 
 function createCommonjsModule(fn) {
   var module = { exports: {} };
@@ -2525,5 +2526,477 @@ SwapProvider.SWAP_STATUSES = {
   FAILED: "failed" // public +
 };
 
-export { AmountUtils, AssetIcon, Blockchain, Button, Cache, Coin, ExistingSwap, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, SupportChat, SwapProvider, improveAndRethrow, safeStringify };
+const BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
+const FALLBACK_ICON_URL = "https://rabbit.io/asset-icons/fallback.svg";
+class SwapspaceSwapProvider extends SwapProvider {
+  constructor(apiKeysProxyUrl, cache, customCoinBuilder = (coin, network) => null, useRestrictedCoinsSet = true) {
+    super();
+    this._supportedCoins = [];
+    this._URL = `${apiKeysProxyUrl}/swapspace`;
+    this._maxRateDigits = 20;
+    this.useRestrictedCoinsSet = useRestrictedCoinsSet;
+    this._customCoinBuilder = customCoinBuilder;
+    this._cache = cache;
+  }
+  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;
+  }
+  async getDepositCurrencies() {
+    const loggerSource = "getDepositCurrencies";
+    try {
+      var _this$_supportedCoins;
+      await this._fetchSupportedCurrenciesIfNeeded();
+      Logger.log(`We have ${(_this$_supportedCoins = this._supportedCoins) == null ? void 0 : _this$_supportedCoins.length} supported coins, getting depositable`, loggerSource);
+      return {
+        result: true,
+        coins: this._supportedCoins.filter(item => item.deposit).map(item => item.coin)
+      };
+    } catch (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);
+    }
+  }
+  async getWithdrawalCurrencies(exceptCurrency = null) {
+    const loggerSource = "getWithdrawalCurrencies";
+    try {
+      var _this$_supportedCoins2;
+      await this._fetchSupportedCurrenciesIfNeeded();
+      Logger.log(`We have ${(_this$_supportedCoins2 = this._supportedCoins) == null ? void 0 : _this$_supportedCoins2.length} supported coins, getting withdrawable`, loggerSource);
+      return {
+        result: true,
+        coins: this._supportedCoins.filter(item => item.withdrawal && (!exceptCurrency || item.coin !== exceptCurrency)).map(item => item.coin)
+      };
+    } catch (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);
+    }
+  }
+  async initialize() {
+    await this._fetchSupportedCurrenciesIfNeeded();
+  }
+  getIconUrl(coinOrTicker) {
+    const loggerSource = "getIconUrl";
+    try {
+      var _this$_supportedCoins4, _this$_supportedCoins5;
+      let coin = coinOrTicker;
+      if (!(coinOrTicker instanceof Coin)) {
+        var _this$_supportedCoins3;
+        coin = (_this$_supportedCoins3 = this._supportedCoins.find(i => i.coin.ticker === coinOrTicker)) == null ? void 0 : _this$_supportedCoins3.coin;
+      }
+      return (_this$_supportedCoins4 = (_this$_supportedCoins5 = this._supportedCoins.find(item => item.coin === coin)) == null ? void 0 : _this$_supportedCoins5.iconURL) != null ? _this$_supportedCoins4 : FALLBACK_ICON_URL;
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+  async _fetchSupportedCurrenciesIfNeeded() {
+    const loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+    try {
+      var _this$_supportedCoins6;
+      if (!((_this$_supportedCoins6 = this._supportedCoins) != null && _this$_supportedCoins6.length)) {
+        var _rawResponse$data, _rawResponse$data2;
+        const rawResponse = await axios.get(`${this._URL}/api/v2/currencies`);
+        Logger.log(`Retrieved ${rawResponse == null || (_rawResponse$data = rawResponse.data) == null ? void 0 : _rawResponse$data.length} currencies`, loggerSource);
+        this._supportedCoins = ((_rawResponse$data2 = rawResponse == null ? void 0 : rawResponse.data) != null ? _rawResponse$data2 : []).map(item => {
+          let coin = this._customCoinBuilder(item.code, item.network);
+          if (!coin && !this.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.
+             */
+            const code = item.code.toUpperCase();
+            const network = item.network.toUpperCase();
+            const ticker = `${code}${code === network ? "" : network}`;
+            const defaultDecimalPlacesForCoinNotSupportedOOB = 8;
+            const 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();
+        this._putPopularCoinsFirst();
+      }
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+
+  /**
+   * 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
+   */
+  _putPopularCoinsFirst() {
+    this._supportedCoins.sort((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;
+    });
+  }
+  async getCoinToUSDTRate(coin) {
+    const loggerSource = "getCoinToUSDTRate";
+    try {
+      var _this$_supportedCoins7;
+      await this._fetchSupportedCurrenciesIfNeeded();
+
+      // Using USDT TRC20 as usually fee in this network is smaller than ERC20 and this network is widely used for USDT
+      const usdtTrc20 = (_this$_supportedCoins7 = this._supportedCoins.find(i => i.code === "usdt" && i.network === "trc20")) == null ? void 0 : _this$_supportedCoins7.coin;
+      if (!usdtTrc20) {
+        return {
+          result: false
+        };
+      }
+      const cached = this._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);
+      const result = await this.getSwapInfo(usdtTrc20, coin, "5000");
+      if (!result.result) {
+        return {
+          result: false
+        };
+      }
+
+      // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
+      const standardSwapspaceFeeMultiplier = 1.002; // usually 0.2%
+      const rate = BigNumber(1).div(BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
+      this._cache.put("swapspace_usdt_rate_" + coin.ticker, rate, 15 * 60000);
+      return {
+        result: true,
+        rate: rate
+      };
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+  getCoinByTickerIfPresent(ticker) {
+    try {
+      var _item$coin;
+      const item = this._supportedCoins.find(i => i.coin.ticker === ticker);
+      return (_item$coin = item == null ? void 0 : item.coin) != null ? _item$coin : null;
+    } catch (e) {
+      improveAndRethrow(e, "getCoinByTickerIfPresent");
+    }
+  }
+  async getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate = null) {
+    const loggerSource = "getSwapInfo";
+    try {
+      var _response$data;
+      if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || BigNumber(amountCoins).lt("0")) {
+        throw new Error(`Wrong input params: ${amountCoins} ${fromCoin.ticker} -> ${toCoin.ticker}` + (fromCoin instanceof Coin) + (toCoin instanceof Coin));
+      }
+      const fromCoinSwapspaceDetails = this._supportedCoins.find(i => i.coin === fromCoin);
+      const toCoinSwapspaceDetails = this._supportedCoins.find(i => 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.
+       */
+      const response = await axios.get(`${this._URL}/api/v2/amounts?fromCurrency=${fromCoinSwapspaceDetails.code}&fromNetwork=${fromCoinSwapspaceDetails.network}&toNetwork=${toCoinSwapspaceDetails.network}&toCurrency=${toCoinSwapspaceDetails.code}&amount=${amountCoins}&float=true&estimated=false`);
+      Logger.log(`Retrieved ${response == null || (_response$data = response.data) == null ? void 0 : _response$data.length} options`, loggerSource);
+      const options = Array.isArray(response.data) ? response.data : [];
+      const exchangesSupportingThePair = options.filter(exchange => (exchange == null ? void 0 : exchange.exists) && !BANNED_PARTNERS.find(bannedPartner => bannedPartner === (exchange == null ? void 0 : exchange.partner)) && (exchange == null ? void 0 : exchange.fixed) === false && (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min || (typeof exchange.min !== "number" || typeof exchange.max !== "number") && exchange.toAmount > 0));
+      Logger.log(`${exchangesSupportingThePair == null ? void 0 : exchangesSupportingThePair.length} of them have exist=true`, loggerSource);
+      if (!exchangesSupportingThePair.length) {
+        return {
+          result: false,
+          reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+        };
+      }
+      const availableExchanges = exchangesSupportingThePair.filter(exchange => 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
+      let smallestMin = null;
+      if (exchangesSupportingThePair.find(ex => BigNumber(ex.min).isZero()) == null) {
+        smallestMin = exchangesSupportingThePair.reduce((prev, cur) => {
+          if (typeof cur.min === "number" && (prev === null || BigNumber(cur.min).lt(prev))) return BigNumber(cur.min);
+          return prev;
+        }, null);
+      }
+      let greatestMax = null;
+      if (exchangesSupportingThePair.find(ex => BigNumber(ex.max).isZero()) == null) {
+        greatestMax = exchangesSupportingThePair.reduce((prev, cur) => {
+          if (typeof cur.max === "number" && (prev === null || BigNumber(cur.max).gt(prev))) return BigNumber(cur.max);
+          return prev;
+        }, null);
+      }
+      let extraCoinsToFitMinMax = "0";
+      if (typeof fromCoinToUsdRate === "string" && BigNumber(fromCoinToUsdRate).gt("0")) {
+        const extraUsdToFitMinMax = 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) {
+        smallestMin = AmountUtils.trim(smallestMin.plus(extraCoinsToFitMinMax), fromCoin.digits);
+      }
+      if (greatestMax instanceof BigNumber) {
+        if (greatestMax > extraCoinsToFitMinMax) {
+          greatestMax = AmountUtils.trim(greatestMax.minus(extraCoinsToFitMinMax), fromCoin.digits);
+        } else {
+          greatestMax = "0";
+        }
+      }
+      if (availableExchanges.length) {
+        var _bestOpt$duration;
+        const sorted = availableExchanges.sort((op1, op2) => op2.toAmount - op1.toAmount);
+        const bestOpt = sorted[0];
+        Logger.log(`Returning first option after sorting: ${safeStringify(bestOpt)}`, loggerSource);
+        let max = null;
+        let min = null;
+        if (extraCoinsToFitMinMax != null) {
+          if (typeof bestOpt.max === "number" && bestOpt.max !== 0) {
+            max = 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(bestOpt.min).plus(extraCoinsToFitMinMax), fromCoin.digits);
+          }
+        }
+        const rate = bestOpt.toAmount && bestOpt.fromAmount ? BigNumber(bestOpt.toAmount).div(bestOpt.fromAmount) : null;
+        return {
+          result: true,
+          min: min,
+          max: max,
+          smallestMin: smallestMin,
+          greatestMax: greatestMax,
+          rate: rate != null ? AmountUtils.trim(rate, this._maxRateDigits) : null,
+          durationMinutesRange: (_bestOpt$duration = bestOpt.duration) != null ? _bestOpt$duration : null,
+          rawSwapData: bestOpt
+        };
+      }
+      const result = {
+        result: false,
+        reason: smallestMin && BigNumber(amountCoins).lt(smallestMin) ? SwapProvider.NO_SWAPS_REASONS.TOO_LOW : greatestMax && 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;
+    } catch (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);
+    }
+  }
+  async createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress) {
+    const loggerSource = "createSwap";
+    const partner = rawSwapData == null ? void 0 : rawSwapData.partner;
+    try {
+      var _this$_supportedCoins8, _this$_supportedCoins9;
+      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)}`);
+      }
+      await this._fetchSupportedCurrenciesIfNeeded();
+      const toCurrencyExtraId = (_this$_supportedCoins8 = (_this$_supportedCoins9 = this._supportedCoins.find(item => item.coin === toCoin)) == null ? void 0 : _this$_supportedCoins9.extraId) != null ? _this$_supportedCoins8 : "";
+      const 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);
+      const response = await axios.post(`${this._URL}/api/v2/exchange`, requestData);
+      const 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 */
+        let rate = result.rate;
+        if (typeof rate !== "number" || BigNumber(rate).isZero()) {
+          var _result$to3, _result$from3;
+          rate = 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(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, this._maxRateDigits)
+        };
+      }
+      const errorMessage = `Swap creation succeeded but the response is wrong: ${safeStringify(response)}`;
+      Logger.log(errorMessage, loggerSource);
+      throw new Error(errorMessage);
+    } catch (e) {
+      var _e$response4, _e$response5;
+      Logger.log(`Failed to create swap. Error is: ${safeStringify(e)}`, loggerSource);
+      const composeFailResult = reason => ({
+        result: false,
+        reason: reason,
+        partner: partner
+      });
+      const status = e == null || (_e$response4 = e.response) == null ? void 0 : _e$response4.status;
+      const 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);
+      }
+      const texts422 = ["Pair cannot be processed by", "Currency not found", "Amount maximum is", "Amount minimum is"];
+      const text403 = "IP address is forbidden";
+      if (typeof data === "string" && (status === 403 && data.includes(text403) || status === 422 && texts422.find(text => 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);
+    }
+  }
+  _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}`);
+    }
+  }
+  async getExistingSwapsDetailsAndStatus(swapIds) {
+    var _this = this;
+    const loggerSource = "getExistingSwapsDetailsAndStatus";
+    try {
+      if (swapIds.find(id => typeof id !== "string")) {
+        throw new Error("Swap id is not string: " + safeStringify(swapIds));
+      }
+      const getNotFailingOn404 = async function getNotFailingOn404(swapId) {
+        try {
+          return await axios.get(`${_this._URL}/api/v2/exchange/${swapId}`);
+        } catch (error) {
+          var _error$response;
+          if ((error == null || (_error$response = error.response) == null ? void 0 : _error$response.status) === 404) return [];
+          throw error;
+        }
+      };
+      const responses = await Promise.all(swapIds.map(swapId => getNotFailingOn404(swapId)));
+      const wo404 = responses.flat();
+      const swaps = wo404.map(r => r.data).map((swap, index) => {
+        var _this$_supportedCoins10, _this$_supportedCoins11;
+        const fromCoin = (_this$_supportedCoins10 = this._supportedCoins.find(i => i.code === swap.from.code && i.network === swap.from.network)) == null ? void 0 : _this$_supportedCoins10.coin;
+        const toCoin = (_this$_supportedCoins11 = this._supportedCoins.find(i => i.code === swap.to.code && i.network === swap.to.network)) == null ? void 0 : _this$_supportedCoins11.coin;
+        if (!fromCoin || !toCoin) {
+          return []; // We skip swaps with not supported coins for now
+        }
+        const status = this._mapSwapspaceStatusToRabbitStatus(swap.status);
+        const toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+        const addressToSendCoinsToSwapspace = swap.from.address;
+        const toUtcTimestamp = timeStr => 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, this._maxRateDigits), swap.refundAddress, addressToSendCoinsToSwapspace, fromCoin, AmountUtils.trim(swap.from.amount, fromCoin.digits), swap.from.transactionHash, swap.blockExplorerTransactionUrl.from, toCoin, AmountUtils.trim(swap.to.amount, toDigits), swap.to.transactionHash, swap.blockExplorerTransactionUrl.to, swap.to.address, swap.partner);
+      }).flat();
+      Logger.log(`Swap details result ${safeStringify(swaps)}`, loggerSource);
+      return {
+        result: true,
+        swaps: swaps
+      };
+    } catch (e) {
+      var _e$response6, _e$response7;
+      Logger.log(`Failed to get swap details. Error is: ${safeStringify(e)}`, loggerSource);
+      const composeFailResult = reason => ({
+        result: false,
+        reason: reason
+      });
+      const status = e == null || (_e$response6 = e.response) == null ? void 0 : _e$response6.status;
+      const 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);
+    }
+  }
+  isAddressValidForAsset(asset, address) {
+    try {
+      const assetData = this._supportedCoins.find(i => i.coin === asset);
+      if (assetData) {
+        let 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;
+  }
+}
+
+export { AmountUtils, AssetIcon, Blockchain, Button, Cache, Coin, ExistingSwap, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, SupportChat, SwapProvider, SwapspaceSwapProvider, improveAndRethrow, safeStringify };
 //# sourceMappingURL=index.modern.js.map