@proton/wrap-constants 0.0.56 → 0.0.57

package/dist/constants.d.ts

@@ -1,6 +1,7 @@
 import { Coin, CoinWallet } from './coins';
 export declare const WRAP_CONTRACT = "proton.wrap";
 export declare const WRAP_AUTH_ACTION = "generateauth";
+export declare const FEE_FACTOR = 10000;
 export declare const initializeConstants: (chain: string) => {
     SWAP_CONTRACT: string;
     FEE_FACTOR: number;

package/dist/graph.d.ts

@@ -0,0 +1,30 @@
+export declare class INode<T> {
+    key: string;
+    data: T;
+    constructor(key: string, data?: T);
+}
+export declare class ILink<T> {
+    from: INode<T>;
+    to: INode<T>;
+    data: T;
+    constructor(from: INode<T>, to: INode<T>, data?: T);
+}
+export declare class Graph<T> {
+    nodes: INode<T>[];
+    links: ILink<T>[];
+    lastPathFound: INode<T>[];
+    isEquals: (a: INode<T>, b: INode<T>) => boolean;
+    addNode(k: string, v?: T): void;
+    addNodes(...nodes: (string | [string, T?])[]): void;
+    findNode(k: string): INode<T> | undefined;
+    findNodes(...keys: string[]): (INode<T> | undefined)[];
+    requireFindNodes(...keys: string[]): INode<T>[];
+    addLink(nodeA: string, nodeB: string, data?: T): void;
+    addLinks(...links: [nodeA: string, nodeB: string, data?: T][]): void;
+    /**
+     * Get all nodes linked
+     * to from `node`.
+     */
+    findLinkedNodes(node: INode<T>): INode<T>[];
+    findAllPaths(from: string, to: string): INode<T>[][];
+}

package/dist/index.d.ts

@@ -2,3 +2,5 @@ export * from './coins';
 export * from './parsers';
 export * from './constants';
 export * from './utils';
+export * from './graph';
+export * from './math';

package/dist/math.d.ts

@@ -0,0 +1,17 @@
+import { BigNumber as BN } from 'bignumber.js';
+/**
+ * XPR<>XUSDT (XPR -> XUSDT)
+ *
+ *                     pool1 * pool2
+ *  term =  pool2  -  --------------
+ *                     pool1 + swap
+ *
+ *  result = term - (term * fee)
+ */
+export declare const compute_transfer: (pool1: BN.Instance, pool2: BN.Instance, swap: BN.Instance, exchange_fee: number, precision: number) => BN;
+export declare const compute_transfer_curve: (reserve_in: number, reserve_out: number, amount_in: number, exchange_fee: number, precision: number, amplifier: number) => BN;
+export declare const compute_liquidity: (amount_lt: BN.Instance, pool: BN.Instance, lt_supply: BN.Instance, precision: number) => number;
+export declare const isInputInvalid: (data: string, value: string | number, pool: {
+    xtokenPrecision: number;
+}) => boolean;
+export declare const applyDiscountToFee: (fee: number, staked: number) => number;

package/dist/parsers/pool.d.ts

@@ -1,5 +1,6 @@
 import { Coin } from "../coins";
 import { ExtendedAsset } from '@bloks/numbers';
+import { INode } from "../graph";
 export interface RawPool {
     lt_symbol: string;
     creator: string;
@@ -25,8 +26,8 @@ export interface Pool extends Omit<RawPool, 'pool1' | 'pool2'> {
     lt_symbol: string;
     creator: string;
     memo: string;
-    pool1: ExtendedToken;
-    pool2: ExtendedToken;
+    pool1: ExtendedTokenWithRate;
+    pool2: ExtendedTokenWithRate;
     hash: string;
     fee: {
         exchange_fee: number;
@@ -42,14 +43,8 @@ export declare type ExtendedTokenWithRate = ExtendedToken & {
     rate: number;
 };
 export declare type PoolTable = {
-    pool1: ExtendedToken & {
-        rate: number;
-    };
-    pool2: ExtendedToken & {
-        rate: number;
-    };
-    path: {
-        data: Pool;
-    }[];
+    pool1: ExtendedTokenWithRate;
+    pool2: ExtendedTokenWithRate;
+    path: INode<Pool>[];
     getPathString: () => string;
 } | undefined;

package/dist/wrap-constants.cjs.development.js

@@ -2,7 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
 var z = require('zod');
+var cloneDeep = _interopDefault(require('lodash.clonedeep'));
+var bignumber_js = require('bignumber.js');
 
 var _similarChains, _explorerLinkByChain;
 
@@ -269,7 +273,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 +946,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 +999,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',
@@ -1220,16 +1263,301 @@ var isSameToken = function isSameToken(token1, token2) {
   return token1.xtokenSymbol === token2.xtokenSymbol && token1.xtokenPrecision === token2.xtokenPrecision && token1.xtokenContract === token2.xtokenContract;
 };
 
+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_js.BigNumber.ROUND_DOWN);
+  var term = term1.minus(term2);
+  var fee = new bignumber_js.BigNumber(exchange_fee).dividedBy(FEE_FACTOR);
+  var result = term.minus(term.multipliedBy(fee));
+  return result.integerValue(bignumber_js.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_js.BigNumber(reserve_in), new bignumber_js.BigNumber(reserve_out), new bignumber_js.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_js.BigNumber(x * x + c).dividedBy(2 * x + b).toFixed(0, bignumber_js.BigNumber.ROUND_DOWN);
+  }
+
+  if (reserve_out <= x) {
+    throw new Error("curve: insufficient reserve out");
+  } // Fee
+
+
+  var amount_out_with_fee = new bignumber_js.BigNumber(reserve_out - x);
+  var fee = amount_out_with_fee.multipliedBy(exchange_fee).dividedBy(FEE_FACTOR).toFixed(0, bignumber_js.BigNumber.ROUND_DOWN);
+  var amount_out = amount_out_with_fee.minus(fee);
+  return amount_out.integerValue(bignumber_js.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_js.BigNumber.ROUND_DOWN);
+  return +result.shiftedBy(-precision).toFixed(precision, bignumber_js.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;
+  }
+};
+
 exports.ExtendedAssetParser = ExtendedAssetParser;
+exports.FEE_FACTOR = FEE_FACTOR;
+exports.Graph = Graph;
+exports.ILink = ILink;
+exports.INode = INode;
 exports.WRAP_AUTH_ACTION = WRAP_AUTH_ACTION;
 exports.WRAP_CONTRACT = WRAP_CONTRACT;
 exports.accountParser = accountParser;
 exports.addressParser = addressParser;
+exports.applyDiscountToFee = applyDiscountToFee;
 exports.authorizationParser = authorizationParser;
 exports.authorizationsParser = authorizationsParser;
 exports.baseActionParser = baseActionParser;
 exports.baseActionSerializedParser = baseActionSerializedParser;
 exports.bloksRatesParser = bloksRatesParser;
+exports.compute_liquidity = compute_liquidity;
+exports.compute_transfer = compute_transfer;
+exports.compute_transfer_curve = compute_transfer_curve;
 exports.createAbstractAuthParser = createAbstractAuthParser;
 exports.depositBodyParser = depositBodyParser;
 exports.exchangeRateParser = exchangeRateParser;
@@ -1240,6 +1568,7 @@ exports.generateAddressResponse = generateAddressResponse;
 exports.generateAuthParser = generateAuthParser;
 exports.initializeCoins = initializeCoins;
 exports.initializeConstants = initializeConstants;
+exports.isInputInvalid = isInputInvalid;
 exports.isSameToken = isSameToken;
 exports.otcOrderResponseParser = otcOrderResponseParser;
 exports.otcQuoteBodyParser = otcQuoteBodyParser;