@proton/wrap-constants 0.0.56 → 0.0.59

package/src/graph.ts

@@ -0,0 +1,126 @@
+import cloneDeep from 'lodash.clonedeep'
+
+export class INode <T> {
+    data: T = {} as T
+    constructor (public key: string, data?: T) {
+        if (data) {
+            this.data = data
+        }
+    }
+}
+
+export class ILink <T> {
+    data: T = {} as T
+    constructor (public from: INode<T>, public to: INode<T>, data?: T) {
+        if (data) {
+            this.data = data
+        }
+    }
+}
+
+export class Graph <T> {
+    nodes: INode<T>[] = []
+    links: ILink<T>[] = []
+    lastPathFound: INode<T>[] = []
+
+    isEquals = (a: INode<T>, b: INode<T>) => a.key === b.key
+
+    addNode (k: string, v?: T): void {
+        const node = this.findNode(k)
+        if (!node) {
+            this.nodes.push(new INode(k, v))
+        }
+    }
+
+    addNodes (...nodes: (string | [string, T?])[]): void {
+        nodes.forEach(node => typeof node === "string" ? this.addNode(node) : this.addNode(node[0], node[1]))
+    }
+
+    findNode (k: string): INode<T> | undefined {
+        const inode = new INode<T>(k)
+        return this.nodes.find(node => this.isEquals(node, inode))
+    }
+
+    findNodes (...keys: string[]): (INode<T> | undefined)[] {
+        return keys.map(k => this.findNode(k))
+    }
+
+    requireFindNodes (...keys: string[]): INode<T>[] {
+        const nodes = this.findNodes(...keys)
+        if (nodes.some(n => n === undefined)) {
+            throw new Error('One of the nodes does not exist')
+        }
+        return nodes as INode<T>[]
+    }
+
+    addLink (nodeA: string, nodeB: string, data?: T): void {
+        const [inodeA, inodeB] = this.requireFindNodes(nodeA, nodeB)
+        this.links.push(new ILink<T>(inodeA, inodeB, data))
+    }
+
+    addLinks (...links: [nodeA: string, nodeB: string, data?: T][]): void {
+        links.forEach(link => this.addLink(...link))
+    }
+    
+    /** 
+     * Get all nodes linked 
+     * to from `node`.
+     */
+    findLinkedNodes (node: INode<T>) {
+        return this.links.reduce((acc, link) => {
+            if (this.isEquals(link.from, node)) {
+                acc.push(link.to)
+            }
+            return acc;
+        }, [] as INode<T>[]);
+    }
+
+    findAllPaths(from: string, to: string) {
+        const allPaths: INode<T>[][] = []
+
+        const [fromNode, toNode] = this.requireFindNodes(from, to)
+
+        const path: INode<T>[] = [fromNode]
+        let seen = new Set()
+
+        const stuck = (x: INode<T>) => {
+            if (this.isEquals(x, toNode)) {
+                return false
+            }
+
+            for (const y of this.findLinkedNodes(x)) {
+                if (!seen.has(y.key)) {
+                    seen.add(y.key)
+                    if (!stuck(y)) {
+                        return false
+                    }
+                }
+            }
+
+            return true
+        }
+
+        const search = (x: INode<T>) => {
+            if (this.isEquals(x, toNode)) {
+                allPaths.push(cloneDeep(path))
+                return
+            }
+            seen = new Set(path.map(p => p.key))
+            if (stuck(x)) {
+                return
+            }
+
+            for (const y of this.findLinkedNodes(x)) {
+                if (!path.includes(y)) {
+                    path.push(y)
+                    search(y)
+                    path.pop()
+                }
+            }
+        }
+
+        search(fromNode)
+
+        return allPaths
+    }
+}

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from './coins'
 export * from './parsers'
 export * from './constants'
-export * from './utils'
+export * from './utils'
+export * from './graph'
+export * from './math'

package/src/math.ts

@@ -0,0 +1,112 @@
+import { BigNumber as BN } from 'bignumber.js'
+import { FEE_FACTOR } from './constants'
+
+/**
+ * XPR<>XUSDT (XPR -> XUSDT)
+ *
+ *                     pool1 * pool2
+ *  term =  pool2  -  --------------
+ *                     pool1 + swap
+ *
+ *  result = term - (term * fee)
+ */
+export const compute_transfer = (pool1: BN.Instance, pool2: BN.Instance, swap: BN.Instance, exchange_fee: number, precision: number): BN => {
+  const term1 = pool2
+  const term2over = pool1.multipliedBy(pool2)
+  const term2under = pool1.plus(swap)
+  const term2 = term2over.dividedBy(term2under).integerValue(BN.ROUND_DOWN)
+  const term = term1.minus(term2)
+  const fee = new BN(exchange_fee).dividedBy(FEE_FACTOR)
+  const result = term.minus(term.multipliedBy(fee))
+ 
+  return result.integerValue(BN.ROUND_DOWN).shiftedBy(-precision)
+}
+
+export const compute_transfer_curve = (
+  reserve_in: number,
+  reserve_out: number,
+  amount_in: number,
+  exchange_fee: number,
+  precision: number,
+  amplifier: number
+): BN => {
+  if (amplifier === 0) {
+      return compute_transfer(new BN(reserve_in), new BN(reserve_out), new BN(amount_in), exchange_fee, precision)
+  }
+
+  const MAX_ITERATIONS = 10
+
+  const sum = reserve_in + reserve_out
+  let D = sum;
+  let D_prev = 0
+
+  const F = (v: number) => {
+      return (v >= 0 ? 1 : -1) * Math.floor(Math.abs(v));
+  }
+
+  let i = MAX_ITERATIONS
+  while (D != D_prev && i--) {
+      const 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));
+  }
+
+  const b = ((reserve_in + amount_in) + F(D / (amplifier * 2))) - D;
+
+  const c = F(F((D * D) / ((reserve_in + amount_in) * 2)) * D / (amplifier * 4));
+
+  let x = D, x_prev = 0;
+  i = MAX_ITERATIONS;
+  while ( x != x_prev && i--) {
+    x_prev = F(x);
+    x = +new BN(x * x + c).dividedBy(2 * x + b).toFixed(0, BN.ROUND_DOWN)
+  }
+
+  if (reserve_out <= x) {
+      throw new Error("curve: insufficient reserve out")
+  }
+
+  // Amount out + Fee + 1
+  const amount_out_with_fee = new BN(reserve_out - x);
+
+  // Fee + 1
+  // +1 covers small precision issues
+  const fee = amount_out_with_fee.multipliedBy(exchange_fee).dividedBy(FEE_FACTOR).plus(1).toFixed(0, BN.ROUND_DOWN);
+  
+  // Amount out
+  const amount_out = amount_out_with_fee.minus(fee)
+
+  return amount_out.integerValue(BN.ROUND_DOWN).shiftedBy(-precision)
+}
+
+export const compute_liquidity = (amount_lt: BN.Instance, pool: BN.Instance, lt_supply: BN.Instance, precision: number): number => {
+  const over = amount_lt.multipliedBy(pool)
+  const under = lt_supply
+  const result = over.dividedBy(under).integerValue(BN.ROUND_DOWN)
+
+  return +(result.shiftedBy(-precision).toFixed(precision, BN.ROUND_DOWN))
+}
+
+export const isInputInvalid = (data: string, value: string | number, pool: { xtokenPrecision: number }): boolean => {
+  value = String(value)
+  
+  const isBackspace = data === null
+  const isNumber = !/[0-9]|\./.test(data)
+  const isDoubleDot = data === '.' && value.indexOf('.') !== value.length - 1
+  const isPrecisionTooHigh = value && value.indexOf('.') !== -1 && value.split('.')[1].length > pool.xtokenPrecision
+  const isInvalid = !isBackspace && Boolean(isNumber || isDoubleDot || isPrecisionTooHigh)
+
+  return isInvalid
+}
+
+export const applyDiscountToFee = (fee: number, staked: number): number => {
+  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
+  }
+}

package/src/parsers/pool.ts

@@ -1,5 +1,6 @@
 import { Coin } from "../coins"
 import { ExtendedAsset } from '@bloks/numbers'
+import { INode } from "../graph";
 
 
 export interface RawPool {
@@ -27,8 +28,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,8 +43,8 @@ export type ExtendedToken = Coin & ExtendedAsset & { key: string; }
 export type ExtendedTokenWithRate = ExtendedToken & { rate: number; }
 
 export type PoolTable = {
-pool1: ExtendedToken & { rate: number; };
-pool2: ExtendedToken & { rate: number; };
-path: { data: Pool }[];
-getPathString: () => string;
+  pool1: ExtendedTokenWithRate;
+  pool2: ExtendedTokenWithRate;
+  path: INode<Pool>[];
+  getPathString: () => string;
 } | undefined

package/src/utils.ts

@@ -8,4 +8,15 @@ export const isSameToken = (token1: PartialCoin, token2: PartialCoin) => {
     return token1.xtokenSymbol === token2.xtokenSymbol &&
            token1.xtokenPrecision === token2.xtokenPrecision &&
            token1.xtokenContract === token2.xtokenContract
-}
+}
+
+export const median = (numbers: number[]) => {
+    const sorted = numbers.slice().sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+
+    if (sorted.length % 2 === 0) {
+        return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+
+    return sorted[middle];
+}