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

package/dist/index.module.js

@@ -1437,8 +1437,8 @@ var s = {"container":"_DYS-g","m-0":"_85R9d","p-0":"_wi0-U","m-1":"_YoewO","p-1"
 
 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,
@@ -1454,8 +1454,8 @@ var AssetIcon = function AssetIcon(_ref) {
     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
@@ -1463,12 +1463,12 @@ var AssetIcon = function AssetIcon(_ref) {
 };
 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
 };
@@ -1568,6 +1568,37 @@ function _extends() {
   };
   return _extends.apply(this, arguments);
 }
+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
 
@@ -1887,5 +1918,818 @@ AmountUtils.defaultCryptoParams = {
   periods: true // Whether we add periods ("..") as suffix for trimmed numbers
 };
 
-export { AmountUtils, AssetIcon, Button, FiatCurrenciesService, LoadingDots, SupportChat, improveAndRethrow };
+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 +
+};
+
+export { AmountUtils, AssetIcon, Blockchain, Button, Cache, Coin, ExistingSwap, FiatCurrenciesService, LoadingDots, Logger, LogsStorage, Protocol, SupportChat, SwapProvider, improveAndRethrow, safeStringify };
 //# sourceMappingURL=index.module.js.map