@proton/wrap-constants 0.0.56 → 0.0.59

package/dist/wrap-constants.esm.js

@@ -1,4 +1,6 @@
 import { string, object, array, literal, number, any, nativeEnum, boolean } from 'zod';
+import cloneDeep from 'lodash.clonedeep';
+import { BigNumber } from 'bignumber.js';
 
 var _similarChains, _explorerLinkByChain;
 
@@ -269,7 +271,7 @@ var initializeCoins = function initializeCoins(protonChain) {
     xtokenPrecision: 4,
     xtokenContract: 'loan.token',
     wallets: [],
-    image: 'https://www.protonchain.com/images/tokens/loan.tokenLOAN.png',
+    image: 'https://raw.githubusercontent.com/eoscafe/eos-airdrops/master/logos/loan.png',
     coingeckoId: 'proton-loan'
   }, {
     allowSwap: true,
@@ -942,8 +944,47 @@ 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.");
+}
+
 var WRAP_CONTRACT = 'proton.wrap';
 var WRAP_AUTH_ACTION = 'generateauth';
+var FEE_FACTOR = 10000;
 var initializeConstants = function initializeConstants(chain) {
   var _initializeCoins = initializeCoins(chain),
       swapCoins = _initializeCoins.swapCoins,
@@ -956,7 +997,7 @@ var initializeConstants = function initializeConstants(chain) {
 
   var constants = {
     SWAP_CONTRACT: 'proton.swaps',
-    FEE_FACTOR: 10000,
+    FEE_FACTOR: FEE_FACTOR,
     GOOGLE_MAPS_KEY: 'AIzaSyDb2_CrK032kSIqBXbkdwmaLKWELl0SxVs',
     SWAP_URL: chain === 'proton' ? 'https://otc.protonswap.com' : 'https://otc-test.protonswap.com',
     WRAP_SERVER_URL: chain === 'proton' ? 'https://www.api.bloks.io/proton-wrap-public2' : 'https://www.api.bloks.io/proton-wrap-testnet-public2',
@@ -1223,6 +1264,298 @@ var wrapParser = /*#__PURE__*/object({
 var isSameToken = function isSameToken(token1, token2) {
   return token1.xtokenSymbol === token2.xtokenSymbol && token1.xtokenPrecision === token2.xtokenPrecision && token1.xtokenContract === token2.xtokenContract;
 };
+var median = function median(numbers) {
+  var sorted = numbers.slice().sort(function (a, b) {
+    return a - b;
+  });
+  var middle = Math.floor(sorted.length / 2);
+
+  if (sorted.length % 2 === 0) {
+    return (sorted[middle - 1] + sorted[middle]) / 2;
+  }
+
+  return sorted[middle];
+};
+
+var INode = function INode(key, data) {
+  this.key = void 0;
+  this.data = {};
+  this.key = key;
+
+  if (data) {
+    this.data = data;
+  }
+};
+var ILink = function ILink(from, to, data) {
+  this.from = void 0;
+  this.to = void 0;
+  this.data = {};
+  this.from = from;
+  this.to = to;
+
+  if (data) {
+    this.data = data;
+  }
+};
+var Graph = /*#__PURE__*/function () {
+  function Graph() {
+    this.nodes = [];
+    this.links = [];
+    this.lastPathFound = [];
+
+    this.isEquals = function (a, b) {
+      return a.key === b.key;
+    };
+  }
+
+  var _proto = Graph.prototype;
+
+  _proto.addNode = function addNode(k, v) {
+    var node = this.findNode(k);
+
+    if (!node) {
+      this.nodes.push(new INode(k, v));
+    }
+  };
+
+  _proto.addNodes = function addNodes() {
+    var _this = this;
+
+    for (var _len = arguments.length, nodes = new Array(_len), _key = 0; _key < _len; _key++) {
+      nodes[_key] = arguments[_key];
+    }
+
+    nodes.forEach(function (node) {
+      return typeof node === "string" ? _this.addNode(node) : _this.addNode(node[0], node[1]);
+    });
+  };
+
+  _proto.findNode = function findNode(k) {
+    var _this2 = this;
+
+    var inode = new INode(k);
+    return this.nodes.find(function (node) {
+      return _this2.isEquals(node, inode);
+    });
+  };
+
+  _proto.findNodes = function findNodes() {
+    var _this3 = this;
+
+    for (var _len2 = arguments.length, keys = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      keys[_key2] = arguments[_key2];
+    }
+
+    return keys.map(function (k) {
+      return _this3.findNode(k);
+    });
+  };
+
+  _proto.requireFindNodes = function requireFindNodes() {
+    var nodes = this.findNodes.apply(this, arguments);
+
+    if (nodes.some(function (n) {
+      return n === undefined;
+    })) {
+      throw new Error('One of the nodes does not exist');
+    }
+
+    return nodes;
+  };
+
+  _proto.addLink = function addLink(nodeA, nodeB, data) {
+    var _this$requireFindNode = this.requireFindNodes(nodeA, nodeB),
+        inodeA = _this$requireFindNode[0],
+        inodeB = _this$requireFindNode[1];
+
+    this.links.push(new ILink(inodeA, inodeB, data));
+  };
+
+  _proto.addLinks = function addLinks() {
+    var _this4 = this;
+
+    for (var _len3 = arguments.length, links = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      links[_key3] = arguments[_key3];
+    }
+
+    links.forEach(function (link) {
+      return _this4.addLink.apply(_this4, link);
+    });
+  }
+  /**
+   * Get all nodes linked
+   * to from `node`.
+   */
+  ;
+
+  _proto.findLinkedNodes = function findLinkedNodes(node) {
+    var _this5 = this;
+
+    return this.links.reduce(function (acc, link) {
+      if (_this5.isEquals(link.from, node)) {
+        acc.push(link.to);
+      }
+
+      return acc;
+    }, []);
+  };
+
+  _proto.findAllPaths = function findAllPaths(from, to) {
+    var _this6 = this;
+
+    var allPaths = [];
+
+    var _this$requireFindNode2 = this.requireFindNodes(from, to),
+        fromNode = _this$requireFindNode2[0],
+        toNode = _this$requireFindNode2[1];
+
+    var path = [fromNode];
+    var seen = new Set();
+
+    var stuck = function stuck(x) {
+      if (_this6.isEquals(x, toNode)) {
+        return false;
+      }
+
+      for (var _iterator = _createForOfIteratorHelperLoose(_this6.findLinkedNodes(x)), _step; !(_step = _iterator()).done;) {
+        var y = _step.value;
+
+        if (!seen.has(y.key)) {
+          seen.add(y.key);
+
+          if (!stuck(y)) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    };
+
+    var search = function search(x) {
+      if (_this6.isEquals(x, toNode)) {
+        allPaths.push(cloneDeep(path));
+        return;
+      }
+
+      seen = new Set(path.map(function (p) {
+        return p.key;
+      }));
+
+      if (stuck(x)) {
+        return;
+      }
+
+      for (var _iterator2 = _createForOfIteratorHelperLoose(_this6.findLinkedNodes(x)), _step2; !(_step2 = _iterator2()).done;) {
+        var y = _step2.value;
+
+        if (!path.includes(y)) {
+          path.push(y);
+          search(y);
+          path.pop();
+        }
+      }
+    };
+
+    search(fromNode);
+    return allPaths;
+  };
+
+  return Graph;
+}();
+
+/**
+ * XPR<>XUSDT (XPR -> XUSDT)
+ *
+ *                     pool1 * pool2
+ *  term =  pool2  -  --------------
+ *                     pool1 + swap
+ *
+ *  result = term - (term * fee)
+ */
+
+var compute_transfer = function compute_transfer(pool1, pool2, swap, exchange_fee, precision) {
+  var term1 = pool2;
+  var term2over = pool1.multipliedBy(pool2);
+  var term2under = pool1.plus(swap);
+  var term2 = term2over.dividedBy(term2under).integerValue(BigNumber.ROUND_DOWN);
+  var term = term1.minus(term2);
+  var fee = new BigNumber(exchange_fee).dividedBy(FEE_FACTOR);
+  var result = term.minus(term.multipliedBy(fee));
+  return result.integerValue(BigNumber.ROUND_DOWN).shiftedBy(-precision);
+};
+var compute_transfer_curve = function compute_transfer_curve(reserve_in, reserve_out, amount_in, exchange_fee, precision, amplifier) {
+  if (amplifier === 0) {
+    return compute_transfer(new BigNumber(reserve_in), new BigNumber(reserve_out), new BigNumber(amount_in), exchange_fee, precision);
+  }
+
+  var MAX_ITERATIONS = 10;
+  var sum = reserve_in + reserve_out;
+  var D = sum;
+  var D_prev = 0;
+
+  var F = function F(v) {
+    return (v >= 0 ? 1 : -1) * Math.floor(Math.abs(v));
+  };
+
+  var i = MAX_ITERATIONS;
+
+  while (D != D_prev && i--) {
+    var prod1 = F(F(D * D / (reserve_in * 2)) * D / (reserve_out * 2));
+    D_prev = D;
+    D = F(2 * D * (amplifier * sum + prod1) / ((2 * amplifier - 1) * D + 3 * prod1));
+  }
+
+  var b = reserve_in + amount_in + F(D / (amplifier * 2)) - D;
+  var c = F(F(D * D / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4));
+  var x = D,
+      x_prev = 0;
+  i = MAX_ITERATIONS;
+
+  while (x != x_prev && i--) {
+    x_prev = F(x);
+    x = +new BigNumber(x * x + c).dividedBy(2 * x + b).toFixed(0, BigNumber.ROUND_DOWN);
+  }
+
+  if (reserve_out <= x) {
+    throw new Error("curve: insufficient reserve out");
+  } // Amount out + Fee + 1
+
+
+  var amount_out_with_fee = new BigNumber(reserve_out - x); // Fee + 1
+  // +1 covers small precision issues
+
+  var fee = amount_out_with_fee.multipliedBy(exchange_fee).dividedBy(FEE_FACTOR).plus(1).toFixed(0, BigNumber.ROUND_DOWN); // Amount out
+
+  var amount_out = amount_out_with_fee.minus(fee);
+  return amount_out.integerValue(BigNumber.ROUND_DOWN).shiftedBy(-precision);
+};
+var compute_liquidity = function compute_liquidity(amount_lt, pool, lt_supply, precision) {
+  var over = amount_lt.multipliedBy(pool);
+  var under = lt_supply;
+  var result = over.dividedBy(under).integerValue(BigNumber.ROUND_DOWN);
+  return +result.shiftedBy(-precision).toFixed(precision, BigNumber.ROUND_DOWN);
+};
+var isInputInvalid = function isInputInvalid(data, value, pool) {
+  value = String(value);
+  var isBackspace = data === null;
+  var isNumber = !/[0-9]|\./.test(data);
+  var isDoubleDot = data === '.' && value.indexOf('.') !== value.length - 1;
+  var isPrecisionTooHigh = value && value.indexOf('.') !== -1 && value.split('.')[1].length > pool.xtokenPrecision;
+  var isInvalid = !isBackspace && Boolean(isNumber || isDoubleDot || isPrecisionTooHigh);
+  return isInvalid;
+};
+var applyDiscountToFee = function applyDiscountToFee(fee, staked) {
+  if (staked >= 10000000) {
+    return fee * 0;
+  } else if (staked >= 1000000) {
+    return fee * 0.33;
+  } else if (staked >= 100000) {
+    return fee * 0.66;
+  } else {
+    return fee;
+  }
+};
 
-export { Chains, ExtendedAssetParser, Networks, Status, Type, WRAP_AUTH_ACTION, WRAP_CONTRACT, accountParser, addressParser, authorizationParser, authorizationsParser, baseActionParser, baseActionSerializedParser, bloksRatesParser, createAbstractAuthParser, depositBodyParser, exchangeRateParser, exchangeRatesParser, explorerLinkByChain, generateAddressBodyParser, generateAddressResponse, generateAuthParser, initializeCoins, initializeConstants, isSameToken, otcOrderResponseParser, otcQuoteBodyParser, otcQuoteResponseParser, rateParser, similarChains, singleActionTransactionParser, transactionParser, webauthActionParser, withdrawBodyParser, withdrawHistoryMetalResponseParser, withdrawHistoryMetalSwapParser, withdrawMetalResponseParser, withdrawalFeeQuoteParser, wrapParser, wrapSetConfParser, wrapStartParser };
+export { Chains, ExtendedAssetParser, FEE_FACTOR, Graph, ILink, INode, Networks, Status, Type, WRAP_AUTH_ACTION, WRAP_CONTRACT, accountParser, addressParser, applyDiscountToFee, authorizationParser, authorizationsParser, baseActionParser, baseActionSerializedParser, bloksRatesParser, compute_liquidity, compute_transfer, compute_transfer_curve, createAbstractAuthParser, depositBodyParser, exchangeRateParser, exchangeRatesParser, explorerLinkByChain, generateAddressBodyParser, generateAddressResponse, generateAuthParser, initializeCoins, initializeConstants, isInputInvalid, isSameToken, median, otcOrderResponseParser, otcQuoteBodyParser, otcQuoteResponseParser, rateParser, similarChains, singleActionTransactionParser, transactionParser, webauthActionParser, withdrawBodyParser, withdrawHistoryMetalResponseParser, withdrawHistoryMetalSwapParser, withdrawMetalResponseParser, withdrawalFeeQuoteParser, wrapParser, wrapSetConfParser, wrapStartParser };
 //# sourceMappingURL=wrap-constants.esm.js.map