@rabbitio/ui-kit 1.0.0-beta.10 → 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: {} };
@@ -1396,7 +1397,7 @@ var s = {"container":"_DYS-g","m-0":"_85R9d","p-0":"_wi0-U","m-1":"_YoewO","p-1"
 
 const AssetIcon = ({
   assetIconSrc,
-  assetIconProtocolScr: _assetIconProtocolScr = null,
+  assetIconProtocolSrc: _assetIconProtocolSrc = null,
   fallbackSrc: _fallbackSrc = null,
   small: _small = false
 }) => {
@@ -1411,8 +1412,8 @@ const AssetIcon = ({
     className: s["asset-icon-primary"] + (_small ? " " + s["small"] : ""),
     alt: " ",
     onError: handleFailedLoad
-  }), _assetIconProtocolScr ? /*#__PURE__*/React.createElement("img", {
-    src: _assetIconProtocolScr,
+  }), _assetIconProtocolSrc ? /*#__PURE__*/React.createElement("img", {
+    src: _assetIconProtocolSrc,
     className: s["asset-icon-secondary"] + (_small ? " " + s["small"] : ""),
     alt: " ",
     onError: handleFailedLoad
@@ -1420,12 +1421,12 @@ const AssetIcon = ({
 };
 AssetIcon.propTypes = {
   assetIconSrc: PropTypes.string.isRequired,
-  assetIconProtocolScr: PropTypes.string,
+  assetIconProtocolSrc: PropTypes.string,
   fallbackSrc: PropTypes.string,
   small: PropTypes.bool
 };
 AssetIcon.defaultProps = {
-  assetIconProtocolScr: null,
+  assetIconProtocolSrc: null,
   fallbackSrc: null,
   small: false
 };
@@ -1805,5 +1806,1197 @@ AmountUtils.defaultCryptoParams = {
   periods: true // Whether we add periods ("..") as suffix for trimmed numbers
 };
 
-export { AmountUtils, AssetIcon, Button, FiatCurrenciesService, LoadingDots, SupportChat, improveAndRethrow };
+class Blockchain {
+  /**
+   * @param name {string} latin printable name of blockchain
+   * @param supportedProtocols {Protocol[]}
+   */
+  constructor(name, supportedProtocols = []) {
+    this.name = name;
+    this.supportedProtocols = supportedProtocols;
+  }
+}
+
+class Protocol {
+  constructor(protocolName) {
+    this.protocol = protocolName;
+  }
+}
+
+/**
+ * The model for cryptocurrency coins.
+ *
+ * WARNING: this class should not be instantiated directly. Use only predefined singleton Coin (or descendants) instances.
+ */
+class Coin {
+  /**
+   * Creates new coin
+   *
+   * @param latinName {string} the coin name in latin symbols like "Bitcoin"
+   * @param ticker {string} the coin symbol/ticker/code like 'BTC'. Always upper case. A unique coin identifier
+   * @param tickerPrintable {string} ticker but in printable format. Useful for tokens based on external blockchains
+   *        like ERC20 or TRC20. It is not friendly to display USDTERC20 or BUSDTRC20 - more neat options are just
+   *        USDT and BUSD. Note that you should always care about user's understanding of what coin he/she is working
+   *        with as printable ticker for USDTERC20 and USDTTRC20 are the same.
+   * @param digitsCountAfterComma {number} count of digits after the comma. E.g. 8 for bitcoin
+   * @param maxValue {number|null} max possible value for cryptocurrency. Null means that the currency has no max possible value
+   * @param atomName {string} name of the coin's atomic value. Like 'satoshi' for bitcoin
+   * @param mainnet {Network} main network for this coin
+   * @param testnet {Network} test network for this coin
+   * @param minConfirmations {number} min confirmations count to treat the coin's transaction confirmed
+   * @param payableEntityStringForFeeRate {string|null} the payable fee entity like byte for bitcoin or gas for ether if present
+   * @param feeOptionsTimeStringsSortedDesc {string[]} array of 4 strings for fee options when sending coins. Should be sorted from the highest time to the smallest
+   * @param feeRatesExpirationTimeMs {number} number of milliseconds to treat the fee rates as expired
+   * @param blockchain {Blockchain} blockchain object
+   * @param [protocol] {Protocol|null} token/coin protocol if relevant
+   * @param [tokenAddress] {string|null} address of contract of this token (if the coin is token)
+   * @param [doesUseLowerCaseAddresses] {boolean} flag to clarify whether we can use lower case addresses to ensure more robust comparisons
+   * @param [doesUseOutputs=false] {boolean} true if this coin uses inputs/outputs concept and false if it uses just balances
+   */
+  constructor(latinName, ticker, tickerPrintable, digitsCountAfterComma, maxValue, atomName, mainnet, testnet, minConfirmations, payableEntityStringForFeeRate, feeOptionsTimeStringsSortedDesc, feeRatesExpirationTimeMs, blockchain, protocol = null, tokenAddress = null, doesUseLowerCaseAddresses = true, doesUseOutputs = false) {
+    this.latinName = latinName;
+    this.ticker = ticker;
+    this.tickerPrintable = tickerPrintable;
+    this.digits = digitsCountAfterComma;
+    this.maxValue = maxValue;
+    this.atomName = atomName;
+    this.mainnet = mainnet;
+    this.testnet = testnet;
+    this.minConfirmations = minConfirmations;
+    this.payableEntityStringForFeeRate = payableEntityStringForFeeRate;
+    this.feeOptionsTimeStringsSortedDesc = feeOptionsTimeStringsSortedDesc;
+    this.feeRatesExpirationTimeMs = feeRatesExpirationTimeMs;
+    this.protocol = protocol;
+    this.blockchain = blockchain;
+    // TODO: [bug, critical] use testnet property for testnet contract address as it blocks the app work in testnets
+    this.tokenAddress = tokenAddress;
+    this.feeCoin = this;
+    this._significantDigits = 8;
+    this.doesUseLowerCaseAddresses = doesUseLowerCaseAddresses;
+    this.doesUseOutputs = doesUseOutputs;
+  }
+
+  /**
+   * Sets fee coin
+   *
+   * @param feeCoin {Coin} some tokens use another coin to charge transaction fee as they work on top of some external
+   *        blockchain. So pass here the coin the token uses for fee charging. Like for ERC20 token the fee coin is ETH.
+   *        By default, the creating coin will be set as a value for this field.
+   */
+  setFeeCoin(feeCoin) {
+    this.feeCoin = feeCoin;
+  }
+
+  /**
+   * Checks whether this coin uses another coin (blockchain) to charge fee for transactions (means works on base of
+   * some external blockchain).
+   *
+   * @return {boolean} true if this coin uses external blockchain to perform transactions and charge fee
+   */
+  doesUseDifferentCoinFee() {
+    return this.feeCoin !== this;
+  }
+
+  /**
+   * Converts the given atoms string/number to string representing the same amount in coin itself - floating point number
+   *
+   * @param atoms {string} atoms positive integer amount
+   * @return {string} coin amount floating point number as a string
+   */
+  atomsToCoinAmount(atoms) {
+    throw new Error("Not implemented in base Coin");
+  }
+
+  /**
+   * Converts the given coins amount string/number to string representing the same amount in coin atoms - integer number
+   *
+   * @param coinsAmount {string} coins positive floating point amount
+   * @return {string} coin atoms amount integer number as a string
+   */
+  coinAmountToAtoms(coinsAmount) {
+    throw new Error("Not implemented in base Coin");
+  }
+
+  /**
+   * Composes URL to view the tx with given id in the external blockchain explorer
+   *
+   * @param txId {string} id of transaction
+   * @return {string} URL string
+   */
+  composeUrlToTransactionExplorer(txId) {
+    throw new Error("Not implemented in base Coin");
+  }
+
+  /**
+   * Most of the cryptocurrencies has specific fee rate or fee price metric. This value usually has specific measure
+   * like satoshi/byte or gWei/gas. This function adds the described denomination string to the given amount
+   * as a suffix and returns the result string ready to be show to a user.
+   *
+   * @param coinAtomsString {string} coin atoms positive integer amount
+   * @return {string} string of coin amount and fee rate units
+   */
+  coinAtomsFeeRateToCommonlyUsedAmountFormatWithDenominationString(coinAtomsString) {
+    throw new Error("Not implemented in base Coin");
+  }
+
+  /**
+   * Check whether this coin support transaction prioritisation during the sending process.
+   *
+   * @return {boolean} true if support transaction prioritisation and false otherwise
+   */
+  doesSupportTransactionPrioritisation() {
+    return Array.isArray(this.feeOptionsTimeStringsSortedDesc);
+  }
+  tickerAndProtocol() {
+    try {
+      var _ref;
+      return `${this.tickerPrintable}${this.protocol ? (_ref = " " + this.protocol.protocol) != null ? _ref : "" : ""}`;
+    } catch (e) {
+      improveAndRethrow(e, "tickerAndProtocol");
+    }
+  }
+}
+
+class LogsStorage {
+  static saveLog(log) {
+    this._inMemoryStorage.push(log);
+  }
+  static getInMemoryLogs() {
+    return this._inMemoryStorage;
+  }
+  static getAllLogs() {
+    let storedLogs = "";
+    if (typeof window !== "undefined") {
+      storedLogs = localStorage.getItem(this._logsStorageId);
+    }
+    return `${storedLogs}\n${this._inMemoryStorage.join("\n")}`;
+  }
+
+  /**
+   * @param logger {Logger}
+   */
+  static saveToTheDisk(logger) {
+    try {
+      const MAX_LOCAL_STORAGE_VOLUME_BYTES = 5 * 1024 * 1024;
+      const MAX_LOGS_STORAGE_BYTES = MAX_LOCAL_STORAGE_VOLUME_BYTES * 0.65;
+      if (typeof window !== "undefined") {
+        const existingLogs = localStorage.getItem(this._logsStorageId);
+        const logsString = `${existingLogs}\n${this._inMemoryStorage.join("\n")}`;
+        const lettersCountToRemove = logsString.length - Math.round(MAX_LOGS_STORAGE_BYTES / 2);
+        if (lettersCountToRemove > 0) {
+          localStorage.setItem(this._logsStorageId, logsString.slice(lettersCountToRemove, logsString.length));
+        } else {
+          localStorage.setItem(this._logsStorageId, logsString);
+        }
+        this._inMemoryStorage = [];
+      }
+    } catch (e) {
+      logger == null || logger.logError(e, "saveToTheDisk", "Failed to save logs to disk");
+    }
+  }
+  static removeAllClientLogs() {
+    if (typeof window !== "undefined") {
+      if (localStorage.getItem("doNotRemoveClientLogsWhenSignedOut") !== "true") {
+        localStorage.removeItem(this._logsStorageId);
+      }
+    }
+    this._inMemoryStorage = [];
+  }
+  static setDoNotRemoveClientLogsWhenSignedOut(value) {
+    if (typeof window !== "undefined") {
+      localStorage.setItem("doNotRemoveClientLogsWhenSignedOut", value);
+    }
+  }
+}
+LogsStorage._inMemoryStorage = [];
+LogsStorage._logsStorageId = "clietnLogs_j203fj2D0n-d1";
+
+/**
+ * Stringify given object by use of JSON.stringify but handles circular structures and "response", "request" properties
+ * to avoid stringing redundant data when printing errors containing request/response objects.
+ *
+ * @param object - object to be stringed
+ * @param indent - custom indentation
+ * @return {string} - stringed object
+ */
+function safeStringify(object, indent = 2) {
+  let cache = [];
+  if (typeof object === "string" || typeof object === "function" || typeof object === "number" || typeof object === "undefined" || typeof object === "boolean") {
+    return String(object);
+  }
+  const retVal = JSON.stringify(object, (key, value) => {
+    if (key.toLowerCase().includes("request")) {
+      return JSON.stringify({
+        body: value == null ? void 0 : value.body,
+        query: value == null ? void 0 : value.query,
+        headers: value == null ? void 0 : value.headers
+      });
+    }
+    if (key.toLowerCase().includes("response")) {
+      return JSON.stringify({
+        statusText: value == null ? void 0 : value.statusText,
+        status: value == null ? void 0 : value.status,
+        data: value == null ? void 0 : value.data,
+        headers: value == null ? void 0 : value.headers
+      });
+    }
+    return typeof value === "object" && value !== null ? cache.includes(value) ? "duplicated reference" // Duplicated references were found, discarding this key
+    : cache.push(value) && value // Store value in our collection
+    : value;
+  }, indent);
+  cache = null;
+  return retVal;
+}
+
+class Logger {
+  /**
+   * Logs to client logs storage.
+   *
+   * WARNING! this method should ce used carefully for critical logging as we have the restriction for storing logs
+   *          on client side as we store them inside the local storage. Please see details inside storage.js
+   * @param logString {string} log string
+   * @param source {string} source of the log entry
+   */
+  static log(logString, source) {
+    const timestamp = new Date().toISOString();
+    LogsStorage.saveLog(`${timestamp}|${source}:${logString}`);
+  }
+  static logError(e, settingFunction, additionalMessage = "", onlyToConsole = false) {
+    var _e$errorDescription, _e$howToFix;
+    let message = `\nFunction call ${settingFunction != null ? settingFunction : ""} failed. Error message: ${e == null ? void 0 : e.message}. ${additionalMessage} `;
+    message += `${(_e$errorDescription = e == null ? void 0 : e.errorDescription) != null ? _e$errorDescription : ""}${(_e$howToFix = e == null ? void 0 : e.howToFix) != null ? _e$howToFix : ""}` + ((e == null ? void 0 : e.httpStatus) === 403 ? "Authentication has expired or was lost. " : "");
+    if (e != null && e.response) {
+      try {
+        const responseData = safeStringify({
+          response: e.response
+        });
+        responseData && (message += `\n${responseData}. `);
+      } catch (e) {}
+    }
+    const finalErrorText = message + ". " + safeStringify(e);
+    // eslint-disable-next-line no-console
+    console.error(finalErrorText);
+    if (!onlyToConsole) {
+      this.log(finalErrorText, "logError");
+    }
+  }
+}
+
+/**
+ * TODO: [tests, critical] Ued by payments logic
+ *
+ * Simple cache based on Map.
+ * Provides ability to store event-dependent data.
+ */
+class Cache {
+  /**
+   * @param eventBus {EventBus} EventBus.js lib instance
+   * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session"
+   */
+  constructor(eventBus, noSessionEvents = []) {
+    this._cache = new Map();
+    this._eventDependentDataKeys = [];
+    this._noSessionEvents = noSessionEvents;
+    this._eventBus = eventBus;
+  }
+  _setupIntervalClearingExpired() {
+    let _cleaner = function cleaner() {
+      try {
+        for (const key of this._cache.keys()) {
+          const item = this._cache.get(key);
+          if (item && item.ttlMs && item.addedMsTimestamp + item.ttlMs < Date.now()) {
+            this._cache.delete(key);
+          }
+        }
+      } catch (e) {
+        improveAndRethrow(e, "_intervalClearingExpiredCache");
+      }
+    };
+    _cleaner = _cleaner.bind(this);
+    setInterval(_cleaner, 1000);
+  }
+
+  /**
+   * Puts data to cache
+   *
+   * @param key {string} string key for this data
+   * @param data {any} any data
+   * @param ttlMs {number|null} optional milliseconds number for cache lifetime
+   * @throws {Error} when the data is null/undefined because these values for data are reserved for internal logic
+   */
+  put(key, data, ttlMs = null) {
+    try {
+      if (typeof key !== "string" || data == null) {
+        throw new Error(`Trying to cache corrupted data: ${key}, ${data}`);
+      }
+      this._cache.set(key, {
+        data: data,
+        addedMsTimestamp: Date.now(),
+        ttlMs: ttlMs
+      });
+    } catch (e) {
+      improveAndRethrow(e, "cache.put");
+    }
+  }
+  putSessionDependentData(key, data, ttlMs = null) {
+    this._putEventDependentData(key, data, this._noSessionEvents, ttlMs);
+  }
+
+  /**
+   * Puts data to cache and adds its key to list of keys that should be related by each of given events.
+   *
+   * @param key {string} key for cache
+   * @param data {any} any caching data
+   * @param events {string[]} list of events forcing putting data to be removed when triggered
+   * @param ttlMs {|null} optional time to live for this cache item
+   * @throws {Error} when the data is null/undefined because these values for data are reserved for internal logic
+   */
+  putEventDependentData(key, data, events, ttlMs = null) {
+    this._putEventDependentData(key, data, events, ttlMs);
+  }
+  _putEventDependentData(key, data, events, ttlMs = null) {
+    try {
+      if (typeof key !== "string" || data == null) {
+        throw new Error(`Trying to cache corrupted data: ${key}, ${data}`);
+      }
+      this._cache.set(key, {
+        data: data,
+        addedMsTimestamp: Date.now(),
+        ttlMs: ttlMs
+      });
+      for (let event of events) {
+        const eventAndKeys = this._eventDependentDataKeys.find(item => item[0] === event);
+        if (eventAndKeys) {
+          eventAndKeys.push(key);
+        } else {
+          this._eventDependentDataKeys.push([event, key]);
+          this._eventBus.addEventListener(event, () => {
+            try {
+              const keys = this._eventDependentDataKeys.find(item => item[0] === event);
+              (keys != null ? keys : [event]).slice(1).forEach(key => this._cache.delete(key));
+            } catch (e) {
+              Logger.logError(e, "cache.removing-for-event", `Event: ${event}`);
+            }
+          });
+        }
+      }
+    } catch (e) {
+      improveAndRethrow(e, "cache.putEventDependentData");
+    }
+  }
+
+  // TODO: [feature, low] add clearing of expired data by schedule
+  get(key) {
+    try {
+      const item = this._cache.get(key);
+      if (item) {
+        if (item.addedMsTimestamp && item.ttlMs !== null && item.addedMsTimestamp + item.ttlMs < Date.now()) {
+          this._cache.delete(key);
+          return null;
+        } else {
+          return item.data;
+        }
+      }
+      return null;
+    } catch (e) {
+      improveAndRethrow(e, "cache.get");
+    }
+  }
+  getLastUpdateTimestamp(key) {
+    var _this$_cache$get$adde, _this$_cache$get;
+    return (_this$_cache$get$adde = (_this$_cache$get = this._cache.get(key)) == null ? void 0 : _this$_cache$get.addedMsTimestamp) != null ? _this$_cache$get$adde : null;
+  }
+
+  /**
+   * Updates the timestamp of the last update for specified key to the provided value.
+   * Can be useful when TTL is controlled outside this class.
+   *
+   * @param key {string}
+   * @param timestamp {number}
+   * @return {boolean}
+   */
+  setLastUpdateTimestamp(key, timestamp) {
+    try {
+      const item = this._cache.get(key);
+      if (item != null && typeof timestamp === "number") {
+        this._cache.set(key, _extends({}, item, {
+          addedTimestampMs: timestamp
+        }));
+        return true;
+      }
+      return false;
+    } catch (e) {
+      improveAndRethrow("cache.setLastUpdateTimestamp");
+    }
+  }
+  invalidate(key) {
+    try {
+      this._cache.delete(key);
+    } catch (e) {
+      improveAndRethrow(e, "cache.invalidate");
+    }
+  }
+  invalidateContaining(keyPart) {
+    if (typeof keyPart !== "string" || keyPart === "") {
+      throw new Error("Trying to invalidate containing wrong key or empty key: " + keyPart);
+    }
+    try {
+      const matchedKeys = Array.from(this._cache.keys()).filter(key => typeof key === "string" && new RegExp(keyPart).test(key));
+      for (let i = 0; i < matchedKeys.length; ++i) {
+        this._cache.delete(matchedKeys[i]);
+      }
+    } catch (e) {
+      improveAndRethrow(e, "invalidateContaining");
+    }
+  }
+  clear() {
+    this._cache.clear();
+    this._sessionDependentDataKeys = [];
+  }
+
+  /**
+   * Saves given data string to persistent cache.
+   * NOTE: we have no TTL here, implement if needed.
+   *
+   * WARNING: use only when really needed and don't store big data as we use localStorage
+   * under the hood and its capacity is restricted.
+   *
+   * @param uniqueKey {string} the key should be unique
+   * @param data {string} only string data allowed
+   */
+  putClientPersistentData(uniqueKey, data) {
+    try {
+      if (typeof window !== "undefined") {
+        localStorage.setItem(uniqueKey, data);
+      }
+    } catch (e) {
+      improveAndRethrow(e, "cache.putClientPersistentData");
+    }
+  }
+
+  /**
+   * @param uniqueKey {string}
+   * @return {string|null}
+   */
+  getClientPersistentData(uniqueKey) {
+    try {
+      if (typeof window !== "undefined") {
+        return localStorage.getItem(uniqueKey);
+      }
+      return null;
+    } catch (e) {
+      improveAndRethrow(e, "cache.getClientPersistentData");
+    }
+  }
+
+  /**
+   * Only makes effect if the TTL is not null.
+   *
+   * @param key {string}
+   * @param ttlMs {number|null}
+   */
+  markCacheItemAsExpiredButDontRemove(key, ttlMs = null) {
+    try {
+      const item = this._cache.get(key);
+      const ttlFinalMs = ttlMs != null ? ttlMs : item == null ? void 0 : item.ttlMs;
+      if (item != null && ttlFinalMs) {
+        this._cache.set(key, {
+          data: item.data,
+          addedMsTimestamp: Date.now() - ttlFinalMs - 1,
+          ttlMs: ttlFinalMs
+        });
+      }
+    } catch (e) {
+      improveAndRethrow(e, "cache.markCacheItemAsExpiredButDontRemove");
+    }
+  }
+}
+
+class 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}
+   */
+  constructor(swapId, status, createdAt, expiresAt, confirmations, rate, refundAddress, payToAddress, fromCoin, fromAmount, fromTransactionId, fromTransactionLink, toCoin, toAmount, toTransactionId, toTransactionLink, toAddress,
+  // TODO: [refactoring, moderate] toAddress is not quite clear. How about recipientAddress? task_id=0815a111c99543b78d374217eadbde4f
+  partner) {
+    this.swapId = swapId;
+    this.status = status;
+    this.createdAt = createdAt;
+    this.expiresAt = expiresAt;
+    this.confirmations = confirmations;
+    this.rate = rate;
+    this.refundAddress = refundAddress;
+    this.payToAddress = payToAddress;
+    this.fromCoin = fromCoin;
+    this.fromTransactionId = fromTransactionId;
+    this.fromAmount = fromAmount;
+    this.fromTransactionLink = fromTransactionLink;
+    this.toCoin = toCoin;
+    this.toTransactionId = toTransactionId;
+    this.toTransactionLink = toTransactionLink;
+    this.toAmount = toAmount;
+    this.toAddress = toAddress;
+    this.partner = partner;
+  }
+}
+
+class SwapProvider {
+  /**
+   * @return {Promise<void>}
+   */
+  async initialize() {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * @return {number} milliseconds TTL
+   */
+  getSwapCreationInfoTtlMs() {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * Retrieves all deposit currencies supported by this swap provider.
+   * Returns one of SwapProvider.COMMON_ERRORS in case of processable fail.
+   *
+   * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
+   */
+  async getDepositCurrencies() {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * Retrieves all withdrawable currencies supported by this swap provider.
+   * Returns one of SwapProvider.COMMON_ERRORS in case of processable fail.
+   *
+   * @param [exceptCurrency=null] {Coin|null}
+   * @return {Promise<({ result: true, coins: Coin[] }|{ result: false, reason: string })>}
+   */
+  async getWithdrawalCurrencies(exceptCurrency = null) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * Retrieves URL for coin icon or fallback if not found.
+   *
+   * @param coin {Coin|string} coin or rabbit-format of coin ticker
+   * @return {string}
+   */
+  getIconUrl(coin) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * Retrieves coin to USDT rate.
+   *
+   * @param coin {Coin}
+   * @return {{result: true, rate: string}|{result: false}}
+   */
+  async getCoinToUSDTRate(coin) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * Retrieves estimation for swapping giving coins amount.
+   * null min or max signals there is no corresponding limitation. undefined means that the limits were not retrieved.
+   * For fail result on of SwapProvider.NO_SWAPS_REASONS or SwapProvider.COMMON_ERRORS reasons will be returned.
+   *
+   * @param fromCoin {Coin}
+   * @param toCoin {Coin}
+   * @param amountCoins {string}
+   * @param [fromCoinToUsdRate=null] pass if you want to increase the min amount returned
+   *        by provider with some fixed "insurance" amount to cover min amount fluctuations.
+   * @return {Promise<({
+   *            result: false,
+   *            reason: string,
+   *            smallestMin: (string|null|undefined),
+   *            greatestMax: (string|null|undefined),
+   *         }|{
+   *            result: true,
+   *            min: (string|null),
+   *            max: (string|null),
+   *            smallestMin: (string|null),
+   *            greatestMax: (string|null),
+   *            rate: (string|null),
+   *            durationMinutesRange: string,
+   *            [rawSwapData]: Object
+   *         })>}
+   */
+  async getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate = null) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * For fail result we return one of SwapProvider.CREATION_FAIL_REASONS or SwapProvider.COMMON_ERRORS.
+   *
+   * @param fromCoin {Coin}
+   * @param toCoin {Coin}
+   * @param amount {string}
+   * @param toAddress {string}
+   * @param refundAddress {string}
+   * @param rawSwapData {Object|null}
+   * @param clientIpAddress {string}
+   * @return {Promise<({
+   *                     result: true,
+   *                     swapId: string,
+   *                     fromCoin: Coin,
+   *                     fromAmount: string,
+   *                     fromAddress: string,
+   *                     toCoin: Coin,
+   *                     toAmount: string,
+   *                     toAddress: string,
+   *                     rate: string
+   *                 }|{
+   *                     result: false,
+   *                     reason: string,
+   *                     partner: string
+   *                 })>}
+   */
+  async createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData = null, clientIpAddress) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * Retrieves details and status for swaps by given ids.
+   * If some swap is not found by id then there is no item in return list.
+   *
+   * @param swapIds {string[]}
+   * @return {Promise<{result: false, reason: string}|{result:true, swaps: ExistingSwap[]}>}
+   */
+  async getExistingSwapsDetailsAndStatus(swapIds) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * @param ticker {string}
+   * @return {Coin|null}
+   */
+  getCoinByTickerIfPresent(ticker) {
+    throw new Error("Not implemented in base");
+  }
+
+  /**
+   * @param asset {Coin}
+   * @param address {string}
+   * @return {boolean}
+   */
+  isAddressValidForAsset(asset, address) {
+    throw new Error("Not implemented in base");
+  }
+}
+SwapProvider.COMMON_ERRORS = {
+  REQUESTS_LIMIT_EXCEEDED: "requestsLimitExceeded"
+};
+SwapProvider.NO_SWAPS_REASONS = {
+  TOO_LOW: "tooLow",
+  TOO_HIGH: "tooHigh",
+  NOT_SUPPORTED: "notSupported"
+};
+SwapProvider.CREATION_FAIL_REASONS = {
+  RETRIABLE_FAIL: "retriableFail"
+};
+SwapProvider.SWAP_STATUSES = {
+  WAITING_FOR_PAYMENT: "waiting_for_payment",
+  // public +
+  CONFIRMING: "confirming",
+  PAYMENT_RECEIVED: "payment_received",
+  // public +
+  EXCHANGING: "exchanging",
+  // session full // public +
+  COMPLETED: "completed",
+  // session full  // public +
+  REFUNDED: "refunded",
+  // session full  // public +
+  EXPIRED: "expired",
+  // public +
+  FAILED: "failed" // public +
+};
+
+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