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

package/dist/index.umd.js

@@ -1,11 +1,12 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('bignumber.js')) :
-	typeof define === 'function' && define.amd ? define(['exports', 'react', 'bignumber.js'], factory) :
-	(global = global || self, factory(global.uiKit = {}, global.react, global.bignumber_js));
-})(this, (function (exports, React, bignumber_js) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('bignumber.js'), require('axios')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'react', 'bignumber.js', 'axios'], factory) :
+	(global = global || self, factory(global.uiKit = {}, global.react, global.bignumber_js, global.axios));
+})(this, (function (exports, React, bignumber_js, axios) {
 	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 	var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+	var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 
 	function createCommonjsModule(fn) {
 	  var module = { exports: {} };
@@ -1443,8 +1444,8 @@
 
 	var AssetIcon = function AssetIcon(_ref) {
 	  var assetIconSrc = _ref.assetIconSrc,
-	    _ref$assetIconProtoco = _ref.assetIconProtocolScr,
-	    assetIconProtocolScr = _ref$assetIconProtoco === void 0 ? null : _ref$assetIconProtoco,
+	    _ref$assetIconProtoco = _ref.assetIconProtocolSrc,
+	    assetIconProtocolSrc = _ref$assetIconProtoco === void 0 ? null : _ref$assetIconProtoco,
 	    _ref$fallbackSrc = _ref.fallbackSrc,
 	    fallbackSrc = _ref$fallbackSrc === void 0 ? null : _ref$fallbackSrc,
 	    _ref$small = _ref.small,
@@ -1460,8 +1461,8 @@
 	    className: s["asset-icon-primary"] + (small ? " " + s["small"] : ""),
 	    alt: " ",
 	    onError: handleFailedLoad
-	  }), assetIconProtocolScr ? /*#__PURE__*/React__default["default"].createElement("img", {
-	    src: assetIconProtocolScr,
+	  }), assetIconProtocolSrc ? /*#__PURE__*/React__default["default"].createElement("img", {
+	    src: assetIconProtocolSrc,
 	    className: s["asset-icon-secondary"] + (small ? " " + s["small"] : ""),
 	    alt: " ",
 	    onError: handleFailedLoad
@@ -1469,12 +1470,12 @@
 	};
 	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
 	};
@@ -1574,6 +1575,49 @@
 	  };
 	  return _extends.apply(this, arguments);
 	}
+	function _inheritsLoose(subClass, superClass) {
+	  subClass.prototype = Object.create(superClass.prototype);
+	  subClass.prototype.constructor = subClass;
+	  _setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+	  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+	    o.__proto__ = p;
+	    return o;
+	  };
+	  return _setPrototypeOf(o, p);
+	}
+	function _unsupportedIterableToArray(o, minLen) {
+	  if (!o) return;
+	  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+	  var n = Object.prototype.toString.call(o).slice(8, -1);
+	  if (n === "Object" && o.constructor) n = o.constructor.name;
+	  if (n === "Map" || n === "Set") return Array.from(o);
+	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+	}
+	function _arrayLikeToArray(arr, len) {
+	  if (len == null || len > arr.length) len = arr.length;
+	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+	  return arr2;
+	}
+	function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+	  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+	  if (it) return (it = it.call(o)).next.bind(it);
+	  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+	    if (it) o = it;
+	    var i = 0;
+	    return function () {
+	      if (i >= o.length) return {
+	        done: true
+	      };
+	      return {
+	        done: false,
+	        value: o[i++]
+	      };
+	    };
+	  }
+	  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
 
 	// TODO: [dev] return addCommasToAmountString internal method to encapsulate commas adding
 
@@ -1893,13 +1937,1445 @@
 	  periods: true // Whether we add periods ("..") as suffix for trimmed numbers
 	};
 
+	var Blockchain =
+	/**
+	 * @param name {string} latin printable name of blockchain
+	 * @param supportedProtocols {Protocol[]}
+	 */
+	function Blockchain(name, supportedProtocols) {
+	  if (supportedProtocols === void 0) {
+	    supportedProtocols = [];
+	  }
+	  this.name = name;
+	  this.supportedProtocols = supportedProtocols;
+	};
+
+	var Protocol = function Protocol(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.
+	 */
+	var Coin = /*#__PURE__*/function () {
+	  /**
+	   * 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
+	   */
+	  function Coin(latinName, ticker, tickerPrintable, digitsCountAfterComma, maxValue, atomName, mainnet, testnet, minConfirmations, payableEntityStringForFeeRate, feeOptionsTimeStringsSortedDesc, feeRatesExpirationTimeMs, blockchain, protocol, tokenAddress, doesUseLowerCaseAddresses, doesUseOutputs) {
+	    if (protocol === void 0) {
+	      protocol = null;
+	    }
+	    if (tokenAddress === void 0) {
+	      tokenAddress = null;
+	    }
+	    if (doesUseLowerCaseAddresses === void 0) {
+	      doesUseLowerCaseAddresses = true;
+	    }
+	    if (doesUseOutputs === void 0) {
+	      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.
+	   */
+	  var _proto = Coin.prototype;
+	  _proto.setFeeCoin = function 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
+	   */;
+	  _proto.doesUseDifferentCoinFee = function 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
+	   */;
+	  _proto.atomsToCoinAmount = function 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
+	   */;
+	  _proto.coinAmountToAtoms = function 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
+	   */;
+	  _proto.composeUrlToTransactionExplorer = function 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
+	   */;
+	  _proto.coinAtomsFeeRateToCommonlyUsedAmountFormatWithDenominationString = function 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
+	   */;
+	  _proto.doesSupportTransactionPrioritisation = function doesSupportTransactionPrioritisation() {
+	    return Array.isArray(this.feeOptionsTimeStringsSortedDesc);
+	  };
+	  _proto.tickerAndProtocol = function tickerAndProtocol() {
+	    try {
+	      var _ref;
+	      return "" + this.tickerPrintable + (this.protocol ? (_ref = " " + this.protocol.protocol) != null ? _ref : "" : "");
+	    } catch (e) {
+	      improveAndRethrow(e, "tickerAndProtocol");
+	    }
+	  };
+	  return Coin;
+	}();
+
+	var LogsStorage = /*#__PURE__*/function () {
+	  function LogsStorage() {}
+	  LogsStorage.saveLog = function saveLog(log) {
+	    this._inMemoryStorage.push(log);
+	  };
+	  LogsStorage.getInMemoryLogs = function getInMemoryLogs() {
+	    return this._inMemoryStorage;
+	  };
+	  LogsStorage.getAllLogs = function getAllLogs() {
+	    var storedLogs = "";
+	    if (typeof window !== "undefined") {
+	      storedLogs = localStorage.getItem(this._logsStorageId);
+	    }
+	    return storedLogs + "\n" + this._inMemoryStorage.join("\n");
+	  }
+
+	  /**
+	   * @param logger {Logger}
+	   */;
+	  LogsStorage.saveToTheDisk = function saveToTheDisk(logger) {
+	    try {
+	      var MAX_LOCAL_STORAGE_VOLUME_BYTES = 5 * 1024 * 1024;
+	      var MAX_LOGS_STORAGE_BYTES = MAX_LOCAL_STORAGE_VOLUME_BYTES * 0.65;
+	      if (typeof window !== "undefined") {
+	        var existingLogs = localStorage.getItem(this._logsStorageId);
+	        var logsString = existingLogs + "\n" + this._inMemoryStorage.join("\n");
+	        var 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");
+	    }
+	  };
+	  LogsStorage.removeAllClientLogs = function removeAllClientLogs() {
+	    if (typeof window !== "undefined") {
+	      if (localStorage.getItem("doNotRemoveClientLogsWhenSignedOut") !== "true") {
+	        localStorage.removeItem(this._logsStorageId);
+	      }
+	    }
+	    this._inMemoryStorage = [];
+	  };
+	  LogsStorage.setDoNotRemoveClientLogsWhenSignedOut = function setDoNotRemoveClientLogsWhenSignedOut(value) {
+	    if (typeof window !== "undefined") {
+	      localStorage.setItem("doNotRemoveClientLogsWhenSignedOut", value);
+	    }
+	  };
+	  return LogsStorage;
+	}();
+	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) {
+	  if (indent === void 0) {
+	    indent = 2;
+	  }
+	  var cache = [];
+	  if (typeof object === "string" || typeof object === "function" || typeof object === "number" || typeof object === "undefined" || typeof object === "boolean") {
+	    return String(object);
+	  }
+	  var retVal = JSON.stringify(object, function (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;
+	}
+
+	var Logger = /*#__PURE__*/function () {
+	  function 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
+	   */
+	  Logger.log = function log(logString, source) {
+	    var timestamp = new Date().toISOString();
+	    LogsStorage.saveLog(timestamp + "|" + source + ":" + logString);
+	  };
+	  Logger.logError = function logError(e, settingFunction, additionalMessage, onlyToConsole) {
+	    var _e$errorDescription, _e$howToFix;
+	    if (additionalMessage === void 0) {
+	      additionalMessage = "";
+	    }
+	    if (onlyToConsole === void 0) {
+	      onlyToConsole = false;
+	    }
+	    var 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 {
+	        var responseData = safeStringify({
+	          response: e.response
+	        });
+	        responseData && (message += "\n" + responseData + ". ");
+	      } catch (e) {}
+	    }
+	    var finalErrorText = message + ". " + safeStringify(e);
+	    // eslint-disable-next-line no-console
+	    console.error(finalErrorText);
+	    if (!onlyToConsole) {
+	      this.log(finalErrorText, "logError");
+	    }
+	  };
+	  return Logger;
+	}();
+
+	/**
+	 * TODO: [tests, critical] Ued by payments logic
+	 *
+	 * Simple cache based on Map.
+	 * Provides ability to store event-dependent data.
+	 */
+	var Cache = /*#__PURE__*/function () {
+	  /**
+	   * @param eventBus {EventBus} EventBus.js lib instance
+	   * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session"
+	   */
+	  function Cache(eventBus, noSessionEvents) {
+	    if (noSessionEvents === void 0) {
+	      noSessionEvents = [];
+	    }
+	    this._cache = new Map();
+	    this._eventDependentDataKeys = [];
+	    this._noSessionEvents = noSessionEvents;
+	    this._eventBus = eventBus;
+	  }
+	  var _proto = Cache.prototype;
+	  _proto._setupIntervalClearingExpired = function _setupIntervalClearingExpired() {
+	    var cleaner = function cleaner() {
+	      try {
+	        for (var _iterator = _createForOfIteratorHelperLoose(this._cache.keys()), _step; !(_step = _iterator()).done;) {
+	          var key = _step.value;
+	          var 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
+	   */;
+	  _proto.put = function put(key, data, ttlMs) {
+	    if (ttlMs === void 0) {
+	      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");
+	    }
+	  };
+	  _proto.putSessionDependentData = function putSessionDependentData(key, data, ttlMs) {
+	    if (ttlMs === void 0) {
+	      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
+	   */;
+	  _proto.putEventDependentData = function putEventDependentData(key, data, events, ttlMs) {
+	    if (ttlMs === void 0) {
+	      ttlMs = null;
+	    }
+	    this._putEventDependentData(key, data, events, ttlMs);
+	  };
+	  _proto._putEventDependentData = function _putEventDependentData(key, data, events, ttlMs) {
+	    var _this = this;
+	    if (ttlMs === void 0) {
+	      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
+	      });
+	      var _loop = function _loop() {
+	        var event = _step2.value;
+	        var eventAndKeys = _this._eventDependentDataKeys.find(function (item) {
+	          return item[0] === event;
+	        });
+	        if (eventAndKeys) {
+	          eventAndKeys.push(key);
+	        } else {
+	          _this._eventDependentDataKeys.push([event, key]);
+	          _this._eventBus.addEventListener(event, function () {
+	            try {
+	              var keys = _this._eventDependentDataKeys.find(function (item) {
+	                return item[0] === event;
+	              });
+	              (keys != null ? keys : [event]).slice(1).forEach(function (key) {
+	                return _this._cache["delete"](key);
+	              });
+	            } catch (e) {
+	              Logger.logError(e, "cache.removing-for-event", "Event: " + event);
+	            }
+	          });
+	        }
+	      };
+	      for (var _iterator2 = _createForOfIteratorHelperLoose(events), _step2; !(_step2 = _iterator2()).done;) {
+	        _loop();
+	      }
+	    } catch (e) {
+	      improveAndRethrow(e, "cache.putEventDependentData");
+	    }
+	  }
+
+	  // TODO: [feature, low] add clearing of expired data by schedule
+	  ;
+	  _proto.get = function get(key) {
+	    try {
+	      var 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");
+	    }
+	  };
+	  _proto.getLastUpdateTimestamp = function 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}
+	   */;
+	  _proto.setLastUpdateTimestamp = function setLastUpdateTimestamp(key, timestamp) {
+	    try {
+	      var 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");
+	    }
+	  };
+	  _proto.invalidate = function invalidate(key) {
+	    try {
+	      this._cache["delete"](key);
+	    } catch (e) {
+	      improveAndRethrow(e, "cache.invalidate");
+	    }
+	  };
+	  _proto.invalidateContaining = function invalidateContaining(keyPart) {
+	    if (typeof keyPart !== "string" || keyPart === "") {
+	      throw new Error("Trying to invalidate containing wrong key or empty key: " + keyPart);
+	    }
+	    try {
+	      var matchedKeys = Array.from(this._cache.keys()).filter(function (key) {
+	        return typeof key === "string" && new RegExp(keyPart).test(key);
+	      });
+	      for (var i = 0; i < matchedKeys.length; ++i) {
+	        this._cache["delete"](matchedKeys[i]);
+	      }
+	    } catch (e) {
+	      improveAndRethrow(e, "invalidateContaining");
+	    }
+	  };
+	  _proto.clear = function 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
+	   */;
+	  _proto.putClientPersistentData = function putClientPersistentData(uniqueKey, data) {
+	    try {
+	      if (typeof window !== "undefined") {
+	        localStorage.setItem(uniqueKey, data);
+	      }
+	    } catch (e) {
+	      improveAndRethrow(e, "cache.putClientPersistentData");
+	    }
+	  }
+
+	  /**
+	   * @param uniqueKey {string}
+	   * @return {string|null}
+	   */;
+	  _proto.getClientPersistentData = function 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}
+	   */;
+	  _proto.markCacheItemAsExpiredButDontRemove = function markCacheItemAsExpiredButDontRemove(key, ttlMs) {
+	    if (ttlMs === void 0) {
+	      ttlMs = null;
+	    }
+	    try {
+	      var _ttlMs;
+	      var item = this._cache.get(key);
+	      var ttlFinalMs = (_ttlMs = 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");
+	    }
+	  };
+	  return Cache;
+	}();
+
+	var 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}
+	 */
+	function ExistingSwap(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;
+	};
+
+	var SwapProvider = /*#__PURE__*/function () {
+	  function SwapProvider() {}
+	  var _proto = SwapProvider.prototype;
+	  /**
+	   * @return {Promise<void>}
+	   */
+	  _proto.initialize = function initialize() {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * @return {number} milliseconds TTL
+	   */
+	  ;
+	  _proto.getSwapCreationInfoTtlMs = function 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 })>}
+	   */;
+	  _proto.getDepositCurrencies = function getDepositCurrencies() {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * 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 })>}
+	   */
+	  ;
+	  _proto.getWithdrawalCurrencies = function getWithdrawalCurrencies(exceptCurrency) {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * Retrieves URL for coin icon or fallback if not found.
+	   *
+	   * @param coin {Coin|string} coin or rabbit-format of coin ticker
+	   * @return {string}
+	   */
+	  ;
+	  _proto.getIconUrl = function getIconUrl(coin) {
+	    throw new Error("Not implemented in base");
+	  }
+
+	  /**
+	   * Retrieves coin to USDT rate.
+	   *
+	   * @param coin {Coin}
+	   * @return {{result: true, rate: string}|{result: false}}
+	   */;
+	  _proto.getCoinToUSDTRate = function getCoinToUSDTRate(coin) {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * 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
+	   *         })>}
+	   */
+	  ;
+	  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate) {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * 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
+	   *                 })>}
+	   */
+	  ;
+	  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress) {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * 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[]}>}
+	   */
+	  ;
+	  _proto.getExistingSwapsDetailsAndStatus = function getExistingSwapsDetailsAndStatus(swapIds) {
+	    try {
+	      throw new Error("Not implemented in base");
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * @param ticker {string}
+	   * @return {Coin|null}
+	   */
+	  ;
+	  _proto.getCoinByTickerIfPresent = function getCoinByTickerIfPresent(ticker) {
+	    throw new Error("Not implemented in base");
+	  }
+
+	  /**
+	   * @param asset {Coin}
+	   * @param address {string}
+	   * @return {boolean}
+	   */;
+	  _proto.isAddressValidForAsset = function isAddressValidForAsset(asset, address) {
+	    throw new Error("Not implemented in base");
+	  };
+	  return SwapProvider;
+	}();
+	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 +
+	};
+
+	function _catch(body, recover) {
+	  try {
+	    var result = body();
+	  } catch (e) {
+	    return recover(e);
+	  }
+	  if (result && result.then) {
+	    return result.then(void 0, recover);
+	  }
+	  return result;
+	}
+	var BANNED_PARTNERS = ["stealthex", "changee", "coincraddle"];
+	var FALLBACK_ICON_URL = "https://rabbit.io/asset-icons/fallback.svg";
+	var SwapspaceSwapProvider = /*#__PURE__*/function (_SwapProvider) {
+	  _inheritsLoose(SwapspaceSwapProvider, _SwapProvider);
+	  function SwapspaceSwapProvider(apiKeysProxyUrl, cache, customCoinBuilder, useRestrictedCoinsSet) {
+	    var _this;
+	    if (customCoinBuilder === void 0) {
+	      customCoinBuilder = function customCoinBuilder(coin, network) {
+	        return null;
+	      };
+	    }
+	    if (useRestrictedCoinsSet === void 0) {
+	      useRestrictedCoinsSet = true;
+	    }
+	    _this = _SwapProvider.call(this) || this;
+	    _this._supportedCoins = [];
+	    _this._URL = apiKeysProxyUrl + "/swapspace";
+	    _this._maxRateDigits = 20;
+	    _this.useRestrictedCoinsSet = useRestrictedCoinsSet;
+	    _this._customCoinBuilder = customCoinBuilder;
+	    _this._cache = cache;
+	    return _this;
+	  }
+	  var _proto = SwapspaceSwapProvider.prototype;
+	  _proto.getSwapCreationInfoTtlMs = function getSwapCreationInfoTtlMs() {
+	    /* Actually 2 minutes and only relevant for some partners, but we use it
+	     * (and even a bit smaller value) for better consistency */
+	    return 110000;
+	  };
+	  _proto.getDepositCurrencies = function getDepositCurrencies() {
+	    try {
+	      var _this2 = this;
+	      var loggerSource = "getDepositCurrencies";
+	      return Promise.resolve(_catch(function () {
+	        return Promise.resolve(_this2._fetchSupportedCurrenciesIfNeeded()).then(function () {
+	          var _this2$_supportedCoin;
+	          Logger.log("We have " + ((_this2$_supportedCoin = _this2._supportedCoins) == null ? void 0 : _this2$_supportedCoin.length) + " supported coins, getting depositable", loggerSource);
+	          return {
+	            result: true,
+	            coins: _this2._supportedCoins.filter(function (item) {
+	              return item.deposit;
+	            }).map(function (item) {
+	              return item.coin;
+	            })
+	          };
+	        });
+	      }, function (e) {
+	        var _e$response;
+	        if ((e == null || (_e$response = e.response) == null ? void 0 : _e$response.status) === 429) {
+	          return {
+	            result: false,
+	            reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+	          };
+	        }
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto.getWithdrawalCurrencies = function getWithdrawalCurrencies(exceptCurrency) {
+	    if (exceptCurrency === void 0) {
+	      exceptCurrency = null;
+	    }
+	    try {
+	      var _this3 = this;
+	      var loggerSource = "getWithdrawalCurrencies";
+	      return Promise.resolve(_catch(function () {
+	        return Promise.resolve(_this3._fetchSupportedCurrenciesIfNeeded()).then(function () {
+	          var _this3$_supportedCoin;
+	          Logger.log("We have " + ((_this3$_supportedCoin = _this3._supportedCoins) == null ? void 0 : _this3$_supportedCoin.length) + " supported coins, getting withdrawable", loggerSource);
+	          return {
+	            result: true,
+	            coins: _this3._supportedCoins.filter(function (item) {
+	              return item.withdrawal && (!exceptCurrency || item.coin !== exceptCurrency);
+	            }).map(function (item) {
+	              return item.coin;
+	            })
+	          };
+	        });
+	      }, function (e) {
+	        var _e$response2;
+	        if ((e == null || (_e$response2 = e.response) == null ? void 0 : _e$response2.status) === 429) {
+	          return {
+	            result: false,
+	            reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+	          };
+	        }
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto.initialize = function initialize() {
+	    try {
+	      var _this4 = this;
+	      return Promise.resolve(_this4._fetchSupportedCurrenciesIfNeeded()).then(function () {});
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto.getIconUrl = function getIconUrl(coinOrTicker) {
+	    var loggerSource = "getIconUrl";
+	    try {
+	      var _this$_supportedCoins2, _this$_supportedCoins3;
+	      var coin = coinOrTicker;
+	      if (!(coinOrTicker instanceof Coin)) {
+	        var _this$_supportedCoins;
+	        coin = (_this$_supportedCoins = this._supportedCoins.find(function (i) {
+	          return i.coin.ticker === coinOrTicker;
+	        })) == null ? void 0 : _this$_supportedCoins.coin;
+	      }
+	      return (_this$_supportedCoins2 = (_this$_supportedCoins3 = this._supportedCoins.find(function (item) {
+	        return item.coin === coin;
+	      })) == null ? void 0 : _this$_supportedCoins3.iconURL) != null ? _this$_supportedCoins2 : FALLBACK_ICON_URL;
+	    } catch (e) {
+	      improveAndRethrow(e, loggerSource);
+	    }
+	  };
+	  _proto._fetchSupportedCurrenciesIfNeeded = function _fetchSupportedCurrenciesIfNeeded() {
+	    try {
+	      var _this5 = this;
+	      var loggerSource = "_fetchSupportedCurrenciesIfNeeded";
+	      return Promise.resolve(_catch(function () {
+	        var _temp = function (_this5$_supportedCoin) {
+	          if (!((_this5$_supportedCoin = _this5._supportedCoins) != null && _this5$_supportedCoin.length)) {
+	            return Promise.resolve(axios__default["default"].get(_this5._URL + "/api/v2/currencies")).then(function (rawResponse) {
+	              var _rawResponse$data, _rawResponse$data2;
+	              Logger.log("Retrieved " + (rawResponse == null || (_rawResponse$data = rawResponse.data) == null ? void 0 : _rawResponse$data.length) + " currencies", loggerSource);
+	              _this5._supportedCoins = ((_rawResponse$data2 = rawResponse == null ? void 0 : rawResponse.data) != null ? _rawResponse$data2 : []).map(function (item) {
+	                var coin = _this5._customCoinBuilder(item.code, item.network);
+	                if (!coin && !_this5.useRestrictedCoinsSet) {
+	                  /** Building coin object for coin that isn't supported OOB in Rabbit.
+	                   * We are doing this way to be able to use extended coins set for swaps.
+	                   * These temporary built coins are only for in-swap use, and we omit some usual
+	                   * coin details here.
+	                   * Ideally we should add some new abstractions e.g. BaseCoin:
+	                   * Coin will extend BaseCoin, SwapCoin will extend BaseCoin etc.
+	                   * But for now it is reasonable to use this simpler approach.
+	                   */
+	                  var code = item.code.toUpperCase();
+	                  var network = item.network.toUpperCase();
+	                  var ticker = "" + code + (code === network ? "" : network);
+	                  var defaultDecimalPlacesForCoinNotSupportedOOB = 8;
+	                  var defaultMinConfirmationsForCoinNotSupportedOOB = 1;
+	                  coin = new Coin(item.name, ticker, code, defaultDecimalPlacesForCoinNotSupportedOOB, null, "", null, null, defaultMinConfirmationsForCoinNotSupportedOOB, null, [], 60000, null,
+	                  // We cannot recognize blockchain from swapspace data
+	                  new Protocol(network),
+	                  // TODO: [dev] maybe we should recognize standard protocols?
+	                  item.contractAddress || null, false);
+	                }
+	                if (coin) {
+	                  var _item$deposit, _item$withdrawal, _item$validationRegex;
+	                  return {
+	                    coin: coin,
+	                    code: item.code,
+	                    network: item.network,
+	                    extraId: item.extraIdName,
+	                    isPopular: !!(item != null && item.popular),
+	                    iconURL: item.icon ? "https://storage.swapspace.co" + item.icon : FALLBACK_ICON_URL,
+	                    deposit: (_item$deposit = item.deposit) != null ? _item$deposit : false,
+	                    withdrawal: (_item$withdrawal = item.withdrawal) != null ? _item$withdrawal : false,
+	                    validationRegexp: (_item$validationRegex = item.validationRegexp) != null ? _item$validationRegex : null
+	                  };
+	                }
+	                return [];
+	              }).flat();
+	              _this5._putPopularCoinsFirst();
+	            });
+	          }
+	        }();
+	        if (_temp && _temp.then) return _temp.then(function () {});
+	      }, function (e) {
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  }
+	  /**
+	   * This method sort internal list putting popular (as swapspace thinks) coins to the top.
+	   * This is just for users of this API if they don't care about the sorting - we just improve a list a bit this way.
+	   * @private
+	   */
+	  ;
+	  _proto._putPopularCoinsFirst = function _putPopularCoinsFirst() {
+	    this._supportedCoins.sort(function (i1, i2) {
+	      if (i1.isPopular && !i2.isPopular) return -1;
+	      if (i2.isPopular && !i1.isPopular) return 1;
+	      return i1.coin.ticker > i2.coin.ticker ? 1 : i1.coin.ticker < i2.coin.ticker ? -1 : 0;
+	    });
+	  };
+	  _proto.getCoinToUSDTRate = function getCoinToUSDTRate(coin) {
+	    try {
+	      var _this6 = this;
+	      var loggerSource = "getCoinToUSDTRate";
+	      return Promise.resolve(_catch(function () {
+	        return Promise.resolve(_this6._fetchSupportedCurrenciesIfNeeded()).then(function () {
+	          var _this6$_supportedCoin;
+	          // Using USDT TRC20 as usually fee in this network is smaller than ERC20 and this network is widely used for USDT
+	          var usdtTrc20 = (_this6$_supportedCoin = _this6._supportedCoins.find(function (i) {
+	            return i.code === "usdt" && i.network === "trc20";
+	          })) == null ? void 0 : _this6$_supportedCoin.coin;
+	          if (!usdtTrc20) {
+	            return {
+	              result: false
+	            };
+	          }
+	          var cached = _this6._cache.get("swapspace_usdt_rate_" + coin.ticker);
+	          if (cached != null) {
+	            return {
+	              result: true,
+	              rate: cached
+	            };
+	          }
+	          Logger.log("Loading USDT -> coin rate as not found in cache:", coin == null ? void 0 : coin.ticker);
+	          return Promise.resolve(_this6.getSwapInfo(usdtTrc20, coin, "5000")).then(function (result) {
+	            if (!result.result) {
+	              return {
+	                result: false
+	              };
+	            }
+
+	            // This calculation is not precise as we cannot recognize the actual fee and network fee. Just approximate.
+	            var standardSwapspaceFeeMultiplier = 1.002; // usually 0.2%
+	            var rate = bignumber_js.BigNumber(1).div(bignumber_js.BigNumber(result.rate).times(standardSwapspaceFeeMultiplier)).toString();
+	            _this6._cache.put("swapspace_usdt_rate_" + coin.ticker, rate, 15 * 60000);
+	            return {
+	              result: true,
+	              rate: rate
+	            };
+	          });
+	        });
+	      }, function (e) {
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto.getCoinByTickerIfPresent = function getCoinByTickerIfPresent(ticker) {
+	    try {
+	      var _item$coin;
+	      var item = this._supportedCoins.find(function (i) {
+	        return i.coin.ticker === ticker;
+	      });
+	      return (_item$coin = item == null ? void 0 : item.coin) != null ? _item$coin : null;
+	    } catch (e) {
+	      improveAndRethrow(e, "getCoinByTickerIfPresent");
+	    }
+	  };
+	  _proto.getSwapInfo = function getSwapInfo(fromCoin, toCoin, amountCoins, fromCoinToUsdRate) {
+	    if (fromCoinToUsdRate === void 0) {
+	      fromCoinToUsdRate = null;
+	    }
+	    try {
+	      var _this7 = this;
+	      var loggerSource = "getSwapInfo";
+	      return Promise.resolve(_catch(function () {
+	        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amountCoins !== "string" || bignumber_js.BigNumber(amountCoins).lt("0")) {
+	          throw new Error("Wrong input params: " + amountCoins + " " + fromCoin.ticker + " -> " + toCoin.ticker + (fromCoin instanceof Coin) + (toCoin instanceof Coin));
+	        }
+	        var fromCoinSwapspaceDetails = _this7._supportedCoins.find(function (i) {
+	          return i.coin === fromCoin;
+	        });
+	        var toCoinSwapspaceDetails = _this7._supportedCoins.find(function (i) {
+	          return i.coin === toCoin;
+	        });
+	        if (!fromCoinSwapspaceDetails || !toCoinSwapspaceDetails) {
+	          throw new Error("Failed to find swapspace coin details for: " + fromCoin.ticker + " -> " + toCoin.ticker);
+	        }
+	        /* Here we use not documented parameter 'estimated=false'. This parameter controls whether we want to use
+	         * cached rate values stored in swapspace cache. Their support says they store at most for 30 sec.
+	         * But we are better off using the most actual rates.
+	         */
+	        return Promise.resolve(axios__default["default"].get(_this7._URL + "/api/v2/amounts?fromCurrency=" + fromCoinSwapspaceDetails.code + "&fromNetwork=" + fromCoinSwapspaceDetails.network + "&toNetwork=" + toCoinSwapspaceDetails.network + "&toCurrency=" + toCoinSwapspaceDetails.code + "&amount=" + amountCoins + "&float=true&estimated=false")).then(function (response) {
+	          var _response$data;
+	          Logger.log("Retrieved " + (response == null || (_response$data = response.data) == null ? void 0 : _response$data.length) + " options", loggerSource);
+	          var options = Array.isArray(response.data) ? response.data : [];
+	          var exchangesSupportingThePair = options.filter(function (exchange) {
+	            return (exchange == null ? void 0 : exchange.exists) && !BANNED_PARTNERS.find(function (bannedPartner) {
+	              return bannedPartner === (exchange == null ? void 0 : exchange.partner);
+	            }) && (exchange == null ? void 0 : exchange.fixed) === false && (exchange.min === 0 || exchange.max === 0 || exchange.max > exchange.min || (typeof exchange.min !== "number" || typeof exchange.max !== "number") && exchange.toAmount > 0);
+	          });
+	          Logger.log((exchangesSupportingThePair == null ? void 0 : exchangesSupportingThePair.length) + " of them have exist=true", loggerSource);
+	          if (!exchangesSupportingThePair.length) {
+	            return {
+	              result: false,
+	              reason: SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED
+	            };
+	          }
+	          var availableExchanges = exchangesSupportingThePair.filter(function (exchange) {
+	            return typeof (exchange == null ? void 0 : exchange.toAmount) === "number" && exchange.toAmount > 0;
+	          });
+	          Logger.log("Available (having amountTo): " + safeStringify(availableExchanges), loggerSource);
+	          // min=0 or max=0 means there is no limit for the partner
+	          var smallestMin = null;
+	          if (exchangesSupportingThePair.find(function (ex) {
+	            return bignumber_js.BigNumber(ex.min).isZero();
+	          }) == null) {
+	            smallestMin = exchangesSupportingThePair.reduce(function (prev, cur) {
+	              if (typeof cur.min === "number" && (prev === null || bignumber_js.BigNumber(cur.min).lt(prev))) return bignumber_js.BigNumber(cur.min);
+	              return prev;
+	            }, null);
+	          }
+	          var greatestMax = null;
+	          if (exchangesSupportingThePair.find(function (ex) {
+	            return bignumber_js.BigNumber(ex.max).isZero();
+	          }) == null) {
+	            greatestMax = exchangesSupportingThePair.reduce(function (prev, cur) {
+	              if (typeof cur.max === "number" && (prev === null || bignumber_js.BigNumber(cur.max).gt(prev))) return bignumber_js.BigNumber(cur.max);
+	              return prev;
+	            }, null);
+	          }
+	          var extraCoinsToFitMinMax = "0";
+	          if (typeof fromCoinToUsdRate === "string" && bignumber_js.BigNumber(fromCoinToUsdRate).gt("0")) {
+	            var extraUsdToFitMinMax = bignumber_js.BigNumber("1"); // We correct the limits as the exact limit can fluctuate and cause failed swap creation
+	            extraCoinsToFitMinMax = AmountUtils.trim(extraUsdToFitMinMax.div(fromCoinToUsdRate), fromCoin.digits);
+	          }
+	          if (smallestMin instanceof bignumber_js.BigNumber) {
+	            smallestMin = AmountUtils.trim(smallestMin.plus(extraCoinsToFitMinMax), fromCoin.digits);
+	          }
+	          if (greatestMax instanceof bignumber_js.BigNumber) {
+	            if (greatestMax > extraCoinsToFitMinMax) {
+	              greatestMax = AmountUtils.trim(greatestMax.minus(extraCoinsToFitMinMax), fromCoin.digits);
+	            } else {
+	              greatestMax = "0";
+	            }
+	          }
+	          if (availableExchanges.length) {
+	            var _bestOpt$duration;
+	            var sorted = availableExchanges.sort(function (op1, op2) {
+	              return op2.toAmount - op1.toAmount;
+	            });
+	            var bestOpt = sorted[0];
+	            Logger.log("Returning first option after sorting: " + safeStringify(bestOpt), loggerSource);
+	            var max = null;
+	            var min = null;
+	            if (extraCoinsToFitMinMax != null) {
+	              if (typeof bestOpt.max === "number" && bestOpt.max !== 0) {
+	                max = bignumber_js.BigNumber(bestOpt.max).minus(extraCoinsToFitMinMax);
+	                max = AmountUtils.trim(max.lt(0) ? "0" : max, fromCoin.digits);
+	              }
+	              if (typeof bestOpt.min === "number" && bestOpt.min !== 0) {
+	                min = AmountUtils.trim(bignumber_js.BigNumber(bestOpt.min).plus(extraCoinsToFitMinMax), fromCoin.digits);
+	              }
+	            }
+	            var rate = bestOpt.toAmount && bestOpt.fromAmount ? bignumber_js.BigNumber(bestOpt.toAmount).div(bestOpt.fromAmount) : null;
+	            return {
+	              result: true,
+	              min: min,
+	              max: max,
+	              smallestMin: smallestMin,
+	              greatestMax: greatestMax,
+	              rate: rate != null ? AmountUtils.trim(rate, _this7._maxRateDigits) : null,
+	              durationMinutesRange: (_bestOpt$duration = bestOpt.duration) != null ? _bestOpt$duration : null,
+	              rawSwapData: bestOpt
+	            };
+	          }
+	          var result = {
+	            result: false,
+	            reason: smallestMin && bignumber_js.BigNumber(amountCoins).lt(smallestMin) ? SwapProvider.NO_SWAPS_REASONS.TOO_LOW : greatestMax && bignumber_js.BigNumber(amountCoins).gt(greatestMax) ? SwapProvider.NO_SWAPS_REASONS.TOO_HIGH : SwapProvider.NO_SWAPS_REASONS.NOT_SUPPORTED,
+	            smallestMin: smallestMin,
+	            greatestMax: greatestMax
+	          };
+	          Logger.log("Returning result " + safeStringify(result), loggerSource);
+	          return result;
+	        });
+	      }, function (e) {
+	        var _e$response3;
+	        if ((e == null || (_e$response3 = e.response) == null ? void 0 : _e$response3.status) === 429) {
+	          return {
+	            result: false,
+	            reason: SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED
+	          };
+	        }
+	        Logger.log("Internal swapspace/rabbit error when getting swap options " + safeStringify(e), loggerSource);
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto.createSwap = function createSwap(fromCoin, toCoin, amount, toAddress, refundAddress, rawSwapData, clientIpAddress) {
+	    try {
+	      var _this8 = this;
+	      var loggerSource = "createSwap";
+	      var partner = rawSwapData == null ? void 0 : rawSwapData.partner;
+	      return Promise.resolve(_catch(function () {
+	        if (!(fromCoin instanceof Coin) || !(toCoin instanceof Coin) || typeof amount !== "string" || typeof toAddress !== "string" || typeof refundAddress !== "string") {
+	          throw new Error("Invalid input: " + fromCoin + " " + toCoin + " " + amount + " " + toAddress + " " + refundAddress);
+	        }
+	        if (typeof partner !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.fromCurrency) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.fromNetwork) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.toCurrency) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.toNetwork) !== "string" || typeof (rawSwapData == null ? void 0 : rawSwapData.id) !== "string" // can be just empty
+	        ) {
+	          throw new Error("Invalid raw swap data: " + safeStringify(rawSwapData));
+	        }
+	        return Promise.resolve(_this8._fetchSupportedCurrenciesIfNeeded()).then(function () {
+	          var _this8$_supportedCoin, _this8$_supportedCoin2;
+	          var toCurrencyExtraId = (_this8$_supportedCoin = (_this8$_supportedCoin2 = _this8._supportedCoins.find(function (item) {
+	            return item.coin === toCoin;
+	          })) == null ? void 0 : _this8$_supportedCoin2.extraId) != null ? _this8$_supportedCoin : "";
+	          var requestData = {
+	            partner: partner,
+	            fromCurrency: rawSwapData == null ? void 0 : rawSwapData.fromCurrency,
+	            fromNetwork: rawSwapData == null ? void 0 : rawSwapData.fromNetwork,
+	            toCurrency: rawSwapData == null ? void 0 : rawSwapData.toCurrency,
+	            toNetwork: rawSwapData == null ? void 0 : rawSwapData.toNetwork,
+	            address: toAddress,
+	            amount: amount,
+	            fixed: false,
+	            extraId: toCurrencyExtraId != null ? toCurrencyExtraId : "",
+	            rateId: rawSwapData == null ? void 0 : rawSwapData.id,
+	            userIp: clientIpAddress,
+	            refund: refundAddress
+	          };
+	          Logger.log("Sending create request: " + safeStringify(requestData), loggerSource);
+	          return Promise.resolve(axios__default["default"].post(_this8._URL + "/api/v2/exchange", requestData)).then(function (response) {
+	            var result = response.data;
+	            Logger.log("Creation result " + safeStringify(result), loggerSource);
+	            if (result != null && result.id) {
+	              var _result$from, _result$from2, _result$to, _result$to2, _result$from4, _result$from5, _result$to4, _result$to5;
+	              if (typeof (result == null || (_result$from = result.from) == null ? void 0 : _result$from.amount) !== "number" || typeof (result == null || (_result$from2 = result.from) == null ? void 0 : _result$from2.address) !== "string" || typeof (result == null || (_result$to = result.to) == null ? void 0 : _result$to.amount) !== "number" || typeof (result == null || (_result$to2 = result.to) == null ? void 0 : _result$to2.address) !== "string") throw new Error("Wrong swap creation result " + result);
+	              /* We use the returned rate preferably but if the retrieved
+	               * rate 0/null/undefined we calculate it manually */
+	              var rate = result.rate;
+	              if (typeof rate !== "number" || bignumber_js.BigNumber(rate).isZero()) {
+	                var _result$to3, _result$from3;
+	                rate = bignumber_js.BigNumber(result == null || (_result$to3 = result.to) == null ? void 0 : _result$to3.amount).div(result == null || (_result$from3 = result.from) == null ? void 0 : _result$from3.amount);
+	              } else {
+	                rate = bignumber_js.BigNumber(rate);
+	              }
+	              return {
+	                result: true,
+	                swapId: result == null ? void 0 : result.id,
+	                fromCoin: fromCoin,
+	                fromAmount: AmountUtils.trim(result == null || (_result$from4 = result.from) == null ? void 0 : _result$from4.amount, fromCoin.digits),
+	                fromAddress: result == null || (_result$from5 = result.from) == null ? void 0 : _result$from5.address,
+	                toCoin: toCoin,
+	                toAmount: AmountUtils.trim(result == null || (_result$to4 = result.to) == null ? void 0 : _result$to4.amount, toCoin.digits),
+	                toAddress: result == null || (_result$to5 = result.to) == null ? void 0 : _result$to5.address,
+	                rate: AmountUtils.trim(rate, _this8._maxRateDigits)
+	              };
+	            }
+	            var errorMessage = "Swap creation succeeded but the response is wrong: " + safeStringify(response);
+	            Logger.log(errorMessage, loggerSource);
+	            throw new Error(errorMessage);
+	          });
+	        });
+	      }, function (e) {
+	        var _e$response4, _e$response5;
+	        Logger.log("Failed to create swap. Error is: " + safeStringify(e), loggerSource);
+	        var composeFailResult = function composeFailResult(reason) {
+	          return {
+	            result: false,
+	            reason: reason,
+	            partner: partner
+	          };
+	        };
+	        var status = e == null || (_e$response4 = e.response) == null ? void 0 : _e$response4.status;
+	        var data = e == null || (_e$response5 = e.response) == null ? void 0 : _e$response5.data;
+	        if (status === 429) {
+	          Logger.log("Returning fail - RPS limit exceeded " + data, loggerSource);
+	          return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+	        }
+	        var texts422 = ["Pair cannot be processed by", "Currency not found", "Amount maximum is", "Amount minimum is"];
+	        var text403 = "IP address is forbidden";
+	        if (typeof data === "string" && (status === 403 && data.includes(text403) || status === 422 && texts422.find(function (text) {
+	          return data.includes(text);
+	        }))) {
+	          Logger.log("Returning retriable fail: " + status + " - " + data + ", " + partner, loggerSource);
+	          return composeFailResult(SwapProvider.CREATION_FAIL_REASONS.RETRIABLE_FAIL);
+	        }
+	        Logger.log("Internal swapspace/rabbit error for " + partner + ": " + safeStringify(e), loggerSource);
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto._mapSwapspaceStatusToRabbitStatus = function _mapSwapspaceStatusToRabbitStatus(status) {
+	    switch (status) {
+	      case "waiting":
+	        return SwapProvider.SWAP_STATUSES.WAITING_FOR_PAYMENT;
+	      case "confirming":
+	        return SwapProvider.SWAP_STATUSES.CONFIRMING;
+	      case "exchanging":
+	        return SwapProvider.SWAP_STATUSES.EXCHANGING;
+	      case "sending":
+	        return SwapProvider.SWAP_STATUSES.PAYMENT_RECEIVED;
+	      case "finished":
+	        return SwapProvider.SWAP_STATUSES.COMPLETED;
+	      case "verifying":
+	        return SwapProvider.SWAP_STATUSES.EXCHANGING;
+	      case "refunded":
+	        return SwapProvider.SWAP_STATUSES.REFUNDED;
+	      case "expired":
+	        return SwapProvider.SWAP_STATUSES.EXPIRED;
+	      case "failed":
+	        return SwapProvider.SWAP_STATUSES.FAILED;
+	      default:
+	        throw new Error("Unknown swapspace status: " + status);
+	    }
+	  };
+	  _proto.getExistingSwapsDetailsAndStatus = function getExistingSwapsDetailsAndStatus(swapIds) {
+	    try {
+	      var _this9 = this;
+	      var loggerSource = "getExistingSwapsDetailsAndStatus";
+	      return Promise.resolve(_catch(function () {
+	        if (swapIds.find(function (id) {
+	          return typeof id !== "string";
+	        })) {
+	          throw new Error("Swap id is not string: " + safeStringify(swapIds));
+	        }
+	        var getNotFailingOn404 = function getNotFailingOn404(swapId) {
+	          try {
+	            return Promise.resolve(_catch(function () {
+	              return Promise.resolve(axios__default["default"].get(_this9._URL + "/api/v2/exchange/" + swapId));
+	            }, function (error) {
+	              var _error$response;
+	              if ((error == null || (_error$response = error.response) == null ? void 0 : _error$response.status) === 404) return [];
+	              throw error;
+	            }));
+	          } catch (e) {
+	            return Promise.reject(e);
+	          }
+	        };
+	        return Promise.resolve(Promise.all(swapIds.map(function (swapId) {
+	          return getNotFailingOn404(swapId);
+	        }))).then(function (responses) {
+	          var wo404 = responses.flat();
+	          var swaps = wo404.map(function (r) {
+	            return r.data;
+	          }).map(function (swap, index) {
+	            var _this9$_supportedCoin, _this9$_supportedCoin2;
+	            var fromCoin = (_this9$_supportedCoin = _this9._supportedCoins.find(function (i) {
+	              return i.code === swap.from.code && i.network === swap.from.network;
+	            })) == null ? void 0 : _this9$_supportedCoin.coin;
+	            var toCoin = (_this9$_supportedCoin2 = _this9._supportedCoins.find(function (i) {
+	              return i.code === swap.to.code && i.network === swap.to.network;
+	            })) == null ? void 0 : _this9$_supportedCoin2.coin;
+	            if (!fromCoin || !toCoin) {
+	              return []; // We skip swaps with not supported coins for now
+	            }
+	            var status = _this9._mapSwapspaceStatusToRabbitStatus(swap.status);
+	            var toDigits = status === SwapProvider.SWAP_STATUSES.REFUNDED ? fromCoin.digits : toCoin.digits;
+	            var addressToSendCoinsToSwapspace = swap.from.address;
+	            var toUtcTimestamp = function toUtcTimestamp(timeStr) {
+	              return Date.parse(timeStr.match(/.+[Zz]$/) ? timeStr : timeStr + "Z");
+	            };
+	            return new ExistingSwap(swapIds[index], status, toUtcTimestamp(swap.timestamps.createdAt), toUtcTimestamp(swap.timestamps.expiresAt), swap.confirmations, AmountUtils.trim(swap.rate, _this9._maxRateDigits), swap.refundAddress, addressToSendCoinsToSwapspace, fromCoin, AmountUtils.trim(swap.from.amount, fromCoin.digits), swap.from.transactionHash, swap.blockExplorerTransactionUrl.from, toCoin, AmountUtils.trim(swap.to.amount, toDigits), swap.to.transactionHash, swap.blockExplorerTransactionUrl.to, swap.to.address, swap.partner);
+	          }).flat();
+	          Logger.log("Swap details result " + safeStringify(swaps), loggerSource);
+	          return {
+	            result: true,
+	            swaps: swaps
+	          };
+	        });
+	      }, function (e) {
+	        var _e$response6, _e$response7;
+	        Logger.log("Failed to get swap details. Error is: " + safeStringify(e), loggerSource);
+	        var composeFailResult = function composeFailResult(reason) {
+	          return {
+	            result: false,
+	            reason: reason
+	          };
+	        };
+	        var status = e == null || (_e$response6 = e.response) == null ? void 0 : _e$response6.status;
+	        var data = e == null || (_e$response7 = e.response) == null ? void 0 : _e$response7.data;
+	        if (status === 429) {
+	          Logger.log("Returning fail - RPS limit exceeded " + data, loggerSource);
+	          return composeFailResult(SwapProvider.COMMON_ERRORS.REQUESTS_LIMIT_EXCEEDED);
+	        }
+	        improveAndRethrow(e, loggerSource);
+	      }));
+	    } catch (e) {
+	      return Promise.reject(e);
+	    }
+	  };
+	  _proto.isAddressValidForAsset = function isAddressValidForAsset(asset, address) {
+	    try {
+	      var assetData = this._supportedCoins.find(function (i) {
+	        return i.coin === asset;
+	      });
+	      if (assetData) {
+	        var corrected = assetData.validationRegexp.trim();
+	        corrected = corrected[0] === "/" ? corrected.slice(1) : corrected;
+	        corrected = corrected[corrected.length - 1] === "/" ? corrected.slice(0, corrected.length - 1) : corrected;
+	        return address.match(corrected) != null;
+	      }
+	    } catch (e) {
+	      Logger.logError(e, "isAddressValidForAsset");
+	    }
+	    return false;
+	  };
+	  return SwapspaceSwapProvider;
+	}(SwapProvider);
+
 	exports.AmountUtils = AmountUtils;
 	exports.AssetIcon = AssetIcon;
+	exports.Blockchain = Blockchain;
 	exports.Button = Button;
+	exports.Cache = Cache;
+	exports.Coin = Coin;
+	exports.ExistingSwap = ExistingSwap;
 	exports.FiatCurrenciesService = FiatCurrenciesService;
 	exports.LoadingDots = LoadingDots;
+	exports.Logger = Logger;
+	exports.LogsStorage = LogsStorage;
+	exports.Protocol = Protocol;
 	exports.SupportChat = SupportChat;
+	exports.SwapProvider = SwapProvider;
+	exports.SwapspaceSwapProvider = SwapspaceSwapProvider;
 	exports.improveAndRethrow = improveAndRethrow;
+	exports.safeStringify = safeStringify;
 
 }));
 //# sourceMappingURL=index.umd.js.map