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

package/dist/index.modern.js

@@ -1,6 +1,7 @@
 import React, { useState, useRef, useEffect } from 'react';
 import { BigNumber } from 'bignumber.js';
 import axios from 'axios';
+import EventBusInstance from 'eventbusjs';
 
 function createCommonjsModule(fn) {
   var module = { exports: {} };
@@ -2312,6 +2313,21 @@ class Cache {
   }
 }
 
+class EmailsApi {
+  static async sendEmail(subject, body) {
+    try {
+      const url = `${window.location.protocol + "//" + window.location.host}/api/v1/${this.serverEndpointEntity}`;
+      await axios.post(url, {
+        subject,
+        body
+      });
+    } catch (e) {
+      improveAndRethrow(e, "sendEmail", subject + body);
+    }
+  }
+}
+EmailsApi.serverEndpointEntity = "emails";
+
 class ExistingSwap {
   /**
    * @param swapId {string}
@@ -2354,6 +2370,78 @@ class ExistingSwap {
   }
 }
 
+class ExistingSwapWithFiatData extends 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}
+   */
+  constructor(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
+    super(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress, partner);
+    this.fromAmountFiat = fromAmountFiat;
+    this.toAmountFiat = toAmountFiat;
+    this.fiatCurrencyCode = fiatCurrencyCode;
+    this.fiatCurrencyDecimals = fiatCurrencyDecimals;
+  }
+
+  /**
+   * @param existingSwap {ExistingSwap}
+   * @param fromAmountFiat {number}
+   * @param toAmountFiat {number}
+   * @param fiatCurrencyCode {string}
+   * @param fiatCurrencyDecimals {number}
+   * @return {ExistingSwapWithFiatData}
+   */
+  static fromExistingSwap(existingSwap, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals) {
+    return new ExistingSwapWithFiatData(existingSwap.swapId, existingSwap.status, existingSwap.createdAt, existingSwap.expiresAt, existingSwap.confirmations, existingSwap.rate, existingSwap.refundAddress, existingSwap.payToAddress, existingSwap.fromCoin, existingSwap.fromAmount, existingSwap.fromTransactionId, existingSwap.fromTransactionLink, existingSwap.toCoin, existingSwap.toAmount, existingSwap.toTransactionId, existingSwap.toTransactionLink, existingSwap.toAddress, existingSwap.partner, fromAmountFiat, toAmountFiat, fiatCurrencyCode, fiatCurrencyDecimals);
+  }
+}
+
+class 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}
+   */
+  constructor(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;
+  }
+}
+
 class SwapProvider {
   /**
    * @return {Promise<void>}
@@ -2998,5 +3086,573 @@ class SwapspaceSwapProvider extends SwapProvider {
   }
 }
 
-export { AmountUtils, AssetIcon, Blockchain, Button, Cache, Coin, ExistingSwap, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, SupportChat, SwapProvider, SwapspaceSwapProvider, improveAndRethrow, safeStringify };
+class 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
+   *         }>}
+   */
+  static async getInitialSwapData(swapProvider, fromCoin, toCoin) {
+    const loggerSource = "getInitialSwapData";
+    try {
+      /* 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.
+       */
+      const defaultAmountUsd = BigNumber("300");
+      const coinUsdRate = await swapProvider.getCoinToUSDTRate(fromCoin);
+      const 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);
+      const details = await swapProvider.getSwapInfo(fromCoin, toCoin, coinAmountForDefaultUsdAmount);
+      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));
+        }
+      }
+      let fiatMin = null;
+      let fiatMax = null;
+      if ((coinUsdRate == null ? void 0 : coinUsdRate.rate) != null) {
+        const usdDecimals = FiatCurrenciesService.getCurrencyDecimalCountByCode("USD");
+        fiatMin = BigNumber(details == null ? void 0 : details.smallestMin).times(coinUsdRate.rate).toFixed(usdDecimals);
+        fiatMax = BigNumber(details == null ? void 0 : details.greatestMax).times(coinUsdRate.rate).toFixed(usdDecimals);
+      }
+      const 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;
+    } catch (e) {
+      Logger.log(`Failed to init swap: ${safeStringify(e)}`, loggerSource);
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+  static safeHandleRequestsLimitExceeding() {
+    (async function () {
+      try {
+        await EmailsApi.sendEmail("AUTOMATIC EMAIL - SWAPSPACE REQUESTS LIMIT EXCEEDED", "Requests limit exceeded. Urgently ask swaps provider support for limit increasing");
+      } catch (e) {
+        Logger.log(`Failed to handle limit exceeding ${safeStringify(e)}`, "_safeHandleRequestsLimitExceeding");
+      }
+    })();
+  }
+
+  /**
+   * 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
+   *         }>}
+   */
+  static async getExistingSwapsDetailsWithFiatAmounts(swapProvider, swapIds) {
+    try {
+      const result = await swapProvider.getExistingSwapsDetailsAndStatus(swapIds);
+      if (result.result) {
+        const extendedSwaps = [];
+        for (let swap of result.swaps) {
+          if (swap.status === SwapProvider.SWAP_STATUSES.REFUNDED) {
+            const rate = await swapProvider.getCoinToUSDTRate(swap.fromCoin);
+            extendedSwaps.push(ExistingSwapWithFiatData.fromExistingSwap(swap, (rate == null ? void 0 : rate.rate) != null ? BigNumber(swap.fromAmount).times(rate.rate).toNumber() : null, (rate == null ? void 0 : rate.rate) != null ? BigNumber(swap.toAmount).times(rate.rate).toNumber() : null, "USD", FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")));
+          } else {
+            const [fromCoinFiatRate, toConFiatRate] = await Promise.all([swapProvider.getCoinToUSDTRate(swap.fromCoin), swapProvider.getCoinToUSDTRate(swap.toCoin)]);
+            extendedSwaps.push(ExistingSwapWithFiatData.fromExistingSwap(swap, (fromCoinFiatRate == null ? void 0 : fromCoinFiatRate.rate) != null ? BigNumber(swap.fromAmount).times(fromCoinFiatRate.rate).toNumber() : null, (toConFiatRate == null ? void 0 : toConFiatRate.rate) != null ? BigNumber(swap.toAmount).times(toConFiatRate.rate).toNumber() : null, "USD", FiatCurrenciesService.getCurrencyDecimalCountByCode("USD")));
+          }
+        }
+        result.swaps = extendedSwaps;
+      }
+      return result;
+    } catch (e) {
+      improveAndRethrow(e, "getExistingSwapsDetailsWithFiatAmounts");
+    }
+  }
+}
+
+const API_KEYS_PROXY_URL = `${window.location.protocol + "//" + window.location.host}/api/v1/proxy`;
+const cache = new Cache(EventBusInstance);
+class PublicSwapService {
+  static async initialize() {
+    try {
+      await this._swapProvider.initialize();
+      SwapUtils.safeHandleRequestsLimitExceeding();
+    } catch (e) {
+      Logger.logError(e, "PublicSwapService.initialize");
+    }
+  }
+  static async getCurrenciesListForPublicSwap(currencyThatShouldNotBeFirst = null) {
+    const loggerSource = "getCurrenciesListForPublicSwap";
+    try {
+      var _result$coins;
+      // TODO: [dev] this is temporary hack, change it to use dedicated lists inside UI and also here
+      const result = currencyThatShouldNotBeFirst ? await this._swapProvider.getWithdrawalCurrencies(currencyThatShouldNotBeFirst) : await this._swapProvider.getDepositCurrencies();
+      if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+        SwapUtils.safeHandleRequestsLimitExceeding();
+        return {
+          result: false,
+          reason: this.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) {
+        let temp = result.coins[0];
+        result.coins[0] = result.coins[1];
+        result.coins[1] = temp;
+      }
+      return {
+        result: true,
+        coins: result.coins
+      };
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+
+  /**
+   * 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
+   *         }>}
+   */
+  static async getInitialPublicSwapData(fromCoin, toCoin) {
+    try {
+      const result = await SwapUtils.getInitialSwapData(this._swapProvider, fromCoin, toCoin);
+      if (!result.result) {
+        if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+          SwapUtils.safeHandleRequestsLimitExceeding();
+          return {
+            result: false,
+            reason: this.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+          };
+        }
+        if (result.reason === SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED) {
+          return {
+            result: false,
+            reason: this.PUBLIC_SWAP_DETAILS_FAIL_REASONS.PAIR_NOT_SUPPORTED
+          };
+        }
+      }
+      return result;
+    } catch (e) {
+      improveAndRethrow(e, "getInitialPublicSwapData");
+    }
+  }
+
+  /**
+   * 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
+   *         }>}
+   */
+  static async getPublicSwapDetails(fromCoin, toCoin, fromAmountCoins) {
+    const loggerSource = "getPublicSwapDetails";
+    try {
+      var _await$this$_swapProv, _await$this$_swapProv2, _result$swapCreationI, _result$swapCreationI2;
+      const coinUsdtRate = (_await$this$_swapProv = (_await$this$_swapProv2 = await this._swapProvider.getCoinToUSDTRate(fromCoin)) == null ? void 0 : _await$this$_swapProv2.rate) != null ? _await$this$_swapProv : null;
+      const details = await this._swapProvider.getSwapInfo(fromCoin, toCoin, fromAmountCoins, coinUsdtRate);
+      const min = details.result ? details.min : details.smallestMin;
+      const max = details.result ? details.max : details.greatestMax;
+      let fiatMin = null,
+        fiatMax = null;
+      if (coinUsdtRate != null) {
+        if (min != null) {
+          fiatMin = BigNumber(min).times(coinUsdtRate).toFixed(this._fiatDecimalsCount);
+        }
+        if (max != null) {
+          fiatMax = BigNumber(max).times(coinUsdtRate).toFixed(this._fiatDecimalsCount);
+        }
+      }
+      const 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(this.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(this.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+        }
+      }
+      const fromAmountBigNumber = BigNumber(fromAmountCoins);
+      if (typeof min === "string" && fromAmountBigNumber.lt(min)) {
+        return composeFailResult(this.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_LESS_THAN_MIN_SWAPPABLE);
+      } else if (typeof max === "string" && fromAmountBigNumber.gt(max)) {
+        return composeFailResult(this.PUBLIC_SWAP_DETAILS_FAIL_REASONS.AMOUNT_HIGHER_THAN_MAX_SWAPPABLE);
+      }
+      const toAmountCoins = AmountUtils.trim(fromAmountBigNumber.times(details.rate), fromCoin.digits);
+      const 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;
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+
+  /**
+   * 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
+   *         }>}
+   */
+  static async createPublicSwap(fromCoin, toCoin, fromAmount, swapCreationInfo, toAddress, refundAddress, clientIp) {
+    const loggerSource = "createPublicSwap";
+    try {
+      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);
+      const result = await this._swapProvider.createSwap(fromCoin, toCoin, fromAmount, toAddress, refundAddress, swapCreationInfo.rawSwapData, clientIp);
+      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: this.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,
+          // };
+        }
+      }
+      if (result.result && result != null && result.swapId) {
+        let fromAmountFiat = null,
+          toAmountFiat = null;
+        try {
+          var _await$this$_swapProv3, _await$this$_swapProv4, _await$this$_swapProv5, _await$this$_swapProv6;
+          const fromCoinUsdtRate = (_await$this$_swapProv3 = (_await$this$_swapProv4 = await this._swapProvider.getCoinToUSDTRate(fromCoin)) == null ? void 0 : _await$this$_swapProv4.rate) != null ? _await$this$_swapProv3 : null;
+          const toCoinUsdtRate = (_await$this$_swapProv5 = (_await$this$_swapProv6 = await this._swapProvider.getCoinToUSDTRate(fromCoin)) == null ? void 0 : _await$this$_swapProv6.rate) != null ? _await$this$_swapProv5 : null;
+          if (fromCoinUsdtRate != null && result.fromAmount != null) {
+            fromAmountFiat = BigNumber(result.fromAmount).times(fromCoinUsdtRate).toFixed(this._fiatDecimalsCount);
+          }
+          if (toCoinUsdtRate != null && result.toAmount != null) {
+            toAmountFiat = BigNumber(result.toAmount).times(toCoinUsdtRate).toFixed(this._fiatDecimalsCount);
+          }
+        } catch (e) {
+          Logger.logError(e, loggerSource, "Failed to calculate fiat amounts for result");
+        }
+        EventBusInstance.dispatch(this.PUBLIC_SWAP_CREATED_EVENT, null, fromCoin.ticker, toCoin.ticker, fromAmountFiat);
+        const toReturn = {
+          result: true,
+          swapId: result.swapId,
+          fromCoin: fromCoin,
+          toCoin: toCoin,
+          fromAmount: result.fromAmount,
+          toAmount: result.toAmount,
+          fromAmountFiat: fromAmountFiat,
+          toAmountFiat: toAmountFiat,
+          fiatCurrencyCode: "USD",
+          fiatCurrencyDecimals: this._fiatDecimalsCount,
+          rate: result.rate,
+          durationMinutesRange: swapCreationInfo.durationMinutesRange,
+          address: result.fromAddress // CRITICAL: this is the address to send coins to swaps provider
+        };
+        this._savePublicSwapIdLocally(result.swapId);
+        Logger.log(`Returning: ${safeStringify(_extends({}, toReturn, {
+          fromCoin: fromCoin == null ? void 0 : fromCoin.ticker,
+          toCoin: toCoin == null ? void 0 : toCoin.ticker
+        }))}`, loggerSource);
+        return toReturn;
+      }
+      throw new Error(`Unexpected result from provider ${safeStringify(result)}`);
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+
+  /**
+   * 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
+   */
+  static async getPublicExistingSwapDetailsAndStatus(swapIds) {
+    const loggerSource = "getPublicExistingSwapDetailsAndStatus";
+    try {
+      const result = await SwapUtils.getExistingSwapsDetailsWithFiatAmounts(this._swapProvider, swapIds);
+      if (!(result != null && result.result)) {
+        if (result.reason === SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED) {
+          SwapUtils.safeHandleRequestsLimitExceeding();
+          return {
+            result: false,
+            reason: this.PUBLIC_SWAPS_COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+          };
+        }
+        throw new Error("Unknown reason: " + (result == null ? void 0 : result.reason));
+      }
+      return result;
+    } catch (e) {
+      improveAndRethrow(e, loggerSource);
+    }
+  }
+
+  /**
+   * Retrieves the whole available swaps history by ids saved locally.
+   *
+   * @return {Promise<{
+   *             result: true,
+   *             swaps: ExistingSwapWithFiatData[]
+   *         }|{
+   *             result: false,
+   *             reason: string
+   *         }>}
+   */
+  static async getPublicSwapsHistory() {
+    try {
+      const swapIds = this._getPublicSwapIdsSavedLocally();
+      if (swapIds.length) {
+        return await this.getPublicExistingSwapDetailsAndStatus(swapIds);
+      }
+      return {
+        result: true,
+        swaps: []
+      };
+    } catch (e) {
+      improveAndRethrow(e, "getPublicSwapsHistory");
+    }
+  }
+
+  /**
+   * @param swapId {string}
+   * @private
+   */
+  static _savePublicSwapIdLocally(swapId) {
+    if (typeof window !== "undefined") {
+      try {
+        const saved = localStorage.getItem("publicSwapIds");
+        const 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[]}
+   */
+  static _getPublicSwapIdsSavedLocally() {
+    if (typeof window !== "undefined") {
+      try {
+        const 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)
+   */
+  static getAssetIconUrl(coinOrTicker) {
+    return this._swapProvider.getIconUrl(coinOrTicker);
+  }
+
+  /**
+   * @param ticker {string}
+   * @return {Coin|null}
+   */
+  static 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>}
+   */
+  static async getAssetToUsdtRate(asset) {
+    try {
+      var _result$rate;
+      const result = await this._swapProvider.getCoinToUSDTRate(asset);
+      return (_result$rate = result == null ? void 0 : result.rate) != null ? _result$rate : null;
+    } catch (e) {
+      improveAndRethrow(e, "getAssetToUsdtRate");
+    }
+  }
+
+  /**
+   * @param asset {Coin}
+   * @param address {string}
+   * @return {boolean}
+   */
+  static 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");
+  //     }
+  // }
+}
+PublicSwapService.PUBLIC_SWAP_CREATED_EVENT = "publicSwapCreatedEvent";
+PublicSwapService._swapProvider = new SwapspaceSwapProvider(API_KEYS_PROXY_URL, cache, () => 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");
+
+export { AmountUtils, AssetIcon, Blockchain, Button, Cache, Coin, EmailsApi, ExistingSwap, ExistingSwapWithFiatData, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, PublicSwapCreationInfo, PublicSwapService, SupportChat, SwapProvider, SwapUtils, SwapspaceSwapProvider, improveAndRethrow, safeStringify };
 //# sourceMappingURL=index.modern.js.map