@marko00/routing-finder-mare 1.0.0

package/dexes/pools/Balancer/BalancerWeightedPool.ts

@@ -0,0 +1,96 @@
+// Ported from Solidity: https://github.com/balancer/balancer-v2-monorepo/blob/master/pkg/pool-weighted/contracts/WeightedMath.sol
+
+import { Token, Pool } from '../../../utils/types/types'
+import BigNumber from 'bignumber.js'
+import * as fp from '../../../utils/math/fixed-points'
+import * as math from '../../../utils/math/math'
+
+// Swap limits: amounts swapped may not be larger than this percentage of total balance of the token being swapped
+// Example - if the pool has 100 WETH, we can swap a maximum od 30 WETH
+const _MAX_IN_RATIO = new BigNumber(0.3e18)
+
+export class BalancerWeightedPool extends Pool {
+  reserves: BigNumber[]
+  startingReserves: BigNumber[]
+  weights: BigNumber[]
+  swapFeePercentage: BigNumber
+
+  constructor(poolId: string, dexId: string, tokens: Token[], reserves: BigInt[], weights: BigInt[], swapFeePercentage: BigInt) {
+    super(poolId, dexId, tokens)
+    this.reserves = reserves.map((r: BigInt) => new BigNumber(r.toString()))
+    this.startingReserves = [...this.reserves]
+    this.weights = weights.map((r: BigInt) => new BigNumber(r.toString()))
+    this.swapFeePercentage = new BigNumber(swapFeePercentage.toString())
+  }
+
+  reset(): void {
+    this.reserves = [...this.startingReserves]
+  }
+
+  calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint {
+    return calculateOutputAmount(this, tokenIn, tokenOut, BigNumber(amountIn.toString()))
+  }
+
+  update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void {
+    // CHECK ???
+    const i = this.tokens.findIndex((token) => token._address === tokenIn)
+    const j = this.tokens.findIndex((token) => token._address === tokenOut)
+
+    this.reserves[i] = fp.add(this.reserves[i], BigNumber(amountIn.toString()))
+    this.reserves[j] = fp.sub(this.reserves[j], BigNumber(amountOut.toString()))
+  }
+}
+
+function calculateOutputAmount(
+  pool: BalancerWeightedPool,
+  tokenA: string,
+  tokenB: string,
+  tokenAmountIn: BigNumber,
+  swapFeePercentage?: BigNumber
+): bigint {
+  // Subtract the fee from the amount in if requested
+  if (swapFeePercentage) tokenAmountIn = fp.sub(tokenAmountIn, fp.mulUp(tokenAmountIn, swapFeePercentage))
+
+  // Get the index of the token we are swapping from and to
+  const i = pool.tokens.findIndex((token) => token._address === tokenA)
+  const j = pool.tokens.findIndex((token) => token._address === tokenB)
+
+  try {
+    const res = _calcOutGivenIn(pool.reserves[i], pool.weights[i], pool.reserves[j], pool.weights[j], tokenAmountIn)
+    return BigInt(res.toFixed())
+  } catch (e) {
+    return BigInt(0)
+  }
+}
+
+/* Computes how many tokens can be taken out of a pool if `amountIn` are sent, given the current balances and weights.
+    Amount out, so we round down overall:
+**********************************************************************************************
+// outGivenIn                                                                                //
+// aO = amountOut                                                                            //
+// bO = balanceOut                                                                           //
+// bI = balanceIn              /      /            bI             \    (wI / wO) \           //
+// aI = amountIn    aO = bO * |  1 - | --------------------------  | ^            |          //
+// wI = weightIn               \      \       ( bI + aI )         /              /           //
+// wO = weightOut                                                                            //
+**********************************************************************************************
+The multiplication rounds down, and the subtrahend (power) runds up (so the base rounds up too).
+Because bI / (bI + aI) <= 1, the exponent rounds down.  */
+// Ovde puca!!!!!!!!!!!!!!
+function _calcOutGivenIn(
+  balanceIn: BigNumber,
+  weightIn: BigNumber,
+  balanceOut: BigNumber,
+  weightOut: BigNumber,
+  amountIn: BigNumber
+): BigNumber {
+  // Cannot exceed maximum in ratio (30% of tokenIn balance)
+  if (amountIn.gte(fp.mulDown(balanceIn, _MAX_IN_RATIO))) throw new Error('MAX_IN_RATIO')
+
+  const denominator = math.add(balanceIn, amountIn)
+  const base = fp.divUp(balanceIn, denominator)
+  const exponent = fp.divDown(weightIn, weightOut)
+  const power = fp.powUp(base, exponent)
+
+  return fp.mulDown(balanceOut, fp.complement(power))
+}

package/dexes/pools/Camelot.ts

@@ -0,0 +1,164 @@
+import { Pool, Token } from '../../utils/types/types'
+import BigNumber from "bignumber.js"
+
+// Camelot V2 pools have 2 tokens in the pool, and a fee
+// Example contracts of one Camelot V2 pool: https://arbiscan.io/address/0xa6c5c7d189fa4eb5af8ba34e63dcdd3a635d433f#readContract
+
+const feeDenominator = new BigNumber(100000)
+
+export class CamelotPool extends Pool {
+
+    fees: BigNumber[]
+    reserves: BigNumber[]
+    startingReserves: BigNumber[]
+    stableSwap: boolean
+
+    constructor(poolId: string, dexId: string, tokens: Token[], reserves: bigint[], fees: bigint[], stableSwap: boolean) {
+        super(poolId, dexId, tokens)
+        this.reserves = reserves.map((r) => BigNumber(r.toString()))
+        this.startingReserves = [...this.reserves]
+        this.fees = fees.map((f) => BigNumber(f.toString()))
+        this.stableSwap = stableSwap
+    }
+
+    reset(): void {
+        this.reserves = [...this.startingReserves]
+    }
+
+    // function getAmountOut on Camelot V2 pools smart contracts
+    calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint {
+        // this function will be called by our routing algorithm which uses bigint values
+        const amountInBN = new BigNumber(amountIn.toString())
+
+        if (this.stableSwap)
+            return calculateStableSwap(this, tokenIn, tokenOut, amountInBN)
+        else
+            return calculateRegularSwap(this, tokenIn, tokenOut, amountInBN)
+    }
+
+    update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void {
+        const i = this.tokens.findIndex((token) => token._address === tokenIn)
+        const j = this.tokens.findIndex((token) => token._address === tokenOut)
+
+        this.reserves[i] = this.reserves[i].plus(BigNumber(amountIn.toString()))
+        this.reserves[j] = this.reserves[j].minus(BigNumber(amountOut.toString()))
+    }
+}
+
+function calculateStableSwap(pool: CamelotPool, tokenIn: string, tokenOut: string, amountIn: BigNumber): bigint {
+
+    const feePercent = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase() ? pool.fees[0] : pool.fees[1];
+
+    let reserve0 = pool.reserves[0]
+    let reserve1 = pool.reserves[1]
+    const precisionMultiplier0 = new BigNumber(10 ** pool.tokens[0].decimals)
+    const precisionMultiplier1 = new BigNumber(10 ** pool.tokens[1].decimals)
+
+    amountIn = amountIn.minus(amountIn.times(feePercent).div(feeDenominator))          // remove fee from amount received
+    const xy: BigNumber = _k(pool);
+    reserve0 = reserve0.times(1e18).div(precisionMultiplier0)
+    reserve1 = reserve1.times(1e18).div(precisionMultiplier1)
+
+    const [reserveA, reserveB] = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? [reserve0, reserve1]
+        : [reserve1, reserve0];
+
+    // amountIn = tokenIn == token0 ? amountIn * 1e18 / precisionMultiplier0 : amountIn * 1e18 / precisionMultiplier1;
+    amountIn = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? amountIn.times(1e18).div(precisionMultiplier0)
+        : amountIn.times(1e18).div(precisionMultiplier1);
+
+    // uint y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
+    const y = reserveB.minus(_get_y(amountIn.plus(reserveA), xy, reserveB))
+
+    // return y * (tokenIn == token0 ? precisionMultiplier1 : precisionMultiplier0) / 1e18;
+    let result = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? y.times(precisionMultiplier1).div(1e18)
+        : y.times(precisionMultiplier0).div(1e18)
+
+    result = floor(result)
+    return BigInt(result.toFixed())
+}
+
+// named the same as in Camelot V2 pools smart contracts
+function _k(pool: CamelotPool): BigNumber {
+
+    // for simplicity extract values
+    let reserve0 = pool.reserves[0]
+    let reserve1 = pool.reserves[1]
+
+    if (pool.stableSwap) {
+        const precisionMultiplier0 = new BigNumber(10 ** pool.tokens[0].decimals)
+        const precisionMultiplier1 = new BigNumber(10 ** pool.tokens[1].decimals)
+
+        const x = reserve0.times(1e18).div(precisionMultiplier0)
+        const y = reserve1.times(1e18).div(precisionMultiplier1)
+        const a = x.times(y).div(1e18)
+        const b = x.times(x).div(1e18).plus(y.times(y).div(1e18))
+        let res = a.times(b).div(1e18)
+        return floor(res)                   // x3y+y3x >= k
+    }
+    return reserve0.times(reserve1)
+}
+
+// named the same as in Camelot V2 pools smart contracts
+function _get_y(x0: BigNumber, xy: BigNumber, y: BigNumber): BigNumber {
+
+    for (let i = 0; i < 255; i++) {
+        const y_prev = y
+        const k = _f(x0, y)
+        if (k.lt(xy)) {
+            let dy = xy.minus(k).times(1e18).dividedToIntegerBy(_d(x0, y))
+            y = y.plus(dy)
+        } else {
+            let dy = k.minus(xy).times(1e18).dividedToIntegerBy(_d(x0, y))
+            y = y.minus(dy)
+        }
+
+        const diff = y.minus(y_prev).abs()
+        if (diff.lte(1))
+            break
+    }
+    return floor(y)
+}
+
+function _f(x0: BigNumber, y: BigNumber): BigNumber {
+    // return x0 * (y * y / 1e18 * y / 1e18) / 1e18 + (x0 * x0 / 1e18 * x0 / 1e18) * y / 1e18;
+    const ySquared = y.times(y).dividedToIntegerBy(1e18)
+    const x0Squared = x0.times(x0).dividedToIntegerBy(1e18)
+    const term1 = x0.times((ySquared).times(y).dividedToIntegerBy(1e18)).dividedToIntegerBy(1e18)
+    const term2 = y.times(x0Squared.times(x0).dividedToIntegerBy(1e18)).dividedToIntegerBy(1e18)
+    return term1.plus(term2)
+}
+
+function _d(x0: BigNumber, y: BigNumber): BigNumber {
+    // return 3 * x0 * (y * y / 1e18) / 1e18 + (x0 * x0 / 1e18 * x0 / 1e18);
+    const ySquared = y.times(y).dividedToIntegerBy(1e18)
+    const x0Squared = x0.times(x0).dividedToIntegerBy(1e18)
+    const term1 = x0.times(ySquared).times(3).dividedToIntegerBy(1e18)
+    const term2 = x0Squared.times(x0).dividedToIntegerBy(1e18)
+    return term1.plus(term2)
+}
+
+function calculateRegularSwap(pool: CamelotPool, tokenIn: string, tokenOut: string, amountIn: BigNumber): bigint {
+
+    const feePercent = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase() ? pool.fees[0] : pool.fees[1];
+
+    const [reserveA, reserveB] = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? [pool.reserves[0], pool.reserves[1]]
+        : [pool.reserves[1], pool.reserves[0]];
+
+    amountIn = amountIn.times(feeDenominator.minus(feePercent))
+    const numerator = amountIn.times(reserveB)
+    const denominator = reserveA.times(feeDenominator).plus(amountIn)
+    const result = floor(numerator.div(denominator))
+    return BigInt(result.toFixed())
+}
+
+/*  Custom floor function because BigNumber library does not implement it
+    @param num: the BigNumber number to be floored
+*/
+function floor(num: BigNumber): BigNumber {
+    const whole = num.toFixed().toString().split('.')[0]
+    return new BigNumber(whole)
+}

package/dexes/pools/SushiSwapV2.ts

@@ -0,0 +1,35 @@
+import { Pool, Token } from '../../utils/types/types'
+
+export class SushiSwapV2Pool extends Pool {
+  reserves: bigint[]
+  startingReserves: bigint[]
+
+  constructor(poolId: string, dexId: string, tokens: Token[], reserves: bigint[]) {
+    super(poolId, dexId, tokens)
+    this.reserves = reserves.slice()
+    this.startingReserves = [...this.reserves]
+  }
+  reset(): void {
+    this.reserves = [...this.startingReserves]
+  }
+
+  calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint {
+    let reserveIn: bigint = this.reserves[0]
+    let reserveOut: bigint = this.reserves[1]
+    if (tokenIn.toLowerCase() === this.tokens[1]._address.toLowerCase()) {
+      reserveIn = this.reserves[1]
+      reserveOut = this.reserves[0]
+    }
+    return (amountIn * BigInt(997) * reserveOut) / (reserveIn * BigInt(1000) + amountIn * BigInt(997))
+  }
+
+  update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void {
+    if (tokenIn.toLowerCase() === this.tokens[0]._address.toLowerCase()) {
+      this.reserves[0] += amountIn
+      this.reserves[1] -= amountOut
+    } else {
+      this.reserves[1] += amountIn
+      this.reserves[0] -= amountOut
+    }
+  }
+}

package/dexes/pools/UniswapV2.ts

@@ -0,0 +1,36 @@
+import { Pool, Token } from '../../utils/types/types'
+
+export class UniswapV2Pool extends Pool {
+  reserves: bigint[]
+  startingReserves: bigint[]
+
+  constructor(poolId: string, dexId: string, tokens: Token[], reserves: bigint[]) {
+    super(poolId, dexId, tokens)
+    this.reserves = reserves.slice()
+    this.startingReserves = [...this.reserves]
+  }
+
+  reset(): void {
+    this.reserves = [...this.startingReserves]
+}
+
+  calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint {
+    let reserveIn: bigint = this.reserves[0]
+    let reserveOut: bigint = this.reserves[1]
+    if (tokenIn.toLowerCase() === this.tokens[1]._address.toLowerCase()) {
+      reserveIn = this.reserves[1]
+      reserveOut = this.reserves[0]
+    }
+    return (amountIn * BigInt(997) * reserveOut) / (reserveIn * BigInt(1000) + amountIn * BigInt(997))
+  }
+
+  update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void {
+    if (tokenIn.toLowerCase() === this.tokens[0]._address.toLowerCase()) {
+      this.reserves[0] += amountIn
+      this.reserves[1] -= amountOut
+    } else {
+      this.reserves[1] += amountIn
+      this.reserves[0] -= amountOut
+    }
+  }
+}

package/dexes/pools/uniswap/UniswapV3.ts

@@ -0,0 +1,40 @@
+import { Pool, Token } from '../../../utils/types/types'
+import { UniswapState } from './uniswapState'
+import { PoolState } from './types'
+
+export class UniswapV3Pool extends Pool {
+  public constructor(poolId: string, dexId: string, tokens: Token[]) {
+    super(poolId.toLowerCase(), dexId, tokens)
+  }
+
+  calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint {
+    const poolData: PoolState | undefined = UniswapState.getPoolState(this.poolId)
+    if (!poolData) {
+      console.log('ERROR: Data for uni v3 pool: ' + this.poolId + ' not found')
+      return BigInt(0)
+    }
+
+    return UniswapState.quoter.quote(poolData, tokenIn, tokenOut, amountIn)[0]
+  }
+
+  reset(): void {
+    UniswapState.resetPoolState(this.poolId)
+  }
+
+  update(tokenIn: string, tokenOut: string, amountIn: bigint) {
+    const poolData: PoolState | undefined = UniswapState.getPoolState(this.poolId)
+    if (!poolData) {
+      console.log('ERROR: Data for uni v3 pool: ' + this.poolId + ' not found')
+      return BigInt(0)
+    }
+
+    // lastQuote will be stored each time we call quote
+    const lastQuote = poolData.lastQuote;
+    poolData.data.currentLiquidity = lastQuote.newLiquidity;
+    poolData.data.currentSqrtPriceX96 = lastQuote.newSqrtPriceX96;
+    poolData.data.currentTickIndex = lastQuote.newTickIndex;
+
+    // we don't need this, because we don't use amountIn anyway
+    return BigInt(0);
+  }
+}

package/dexes/pools/uniswap/testUniswapOffchainQuoter.ts

@@ -0,0 +1,169 @@
+/**
+ * If you want to run this file separately, or any other in ts isolated environment
+ * ts-node --esm dexes/pools/uniswap/testUniswapOffchainQuoter.ts
+ *
+ * remove "type": "module" from sdk package.json
+ * And remove rpc function in RPC provider because window object is available only in browser
+ *
+ * Later if you want to run things in browser, add "type": "module" back to sdk package.json
+ *
+ * This examples assumes that you have localhost hardhat node running with deployed contracts
+ * */
+
+import { TradeInfo } from './types'
+import { Token } from '../../../types'
+import { addresses } from '../../../utils/addresses'
+import { UniswapState } from './uniswapState'
+import { UniswapV3Pool } from './UniswapV3'
+import Web3 from 'web3'
+import { IQuoterV2_ABI } from '../../../../contracts/abi/common/IQuoterV2_ABI'
+import { initLocalHardhatProvider } from '../../../../providers/RPCProvider'
+
+const web3: Web3 = initLocalHardhatProvider()
+
+const POOLS = [
+  addresses.univ3_wbtc_eth_pool_0_3,
+  addresses.gmx_usdc_pool_0_1,
+  addresses.uni_weth_pool,
+  addresses.weth_link_pool,
+  addresses.dai_usdce_pool_0_0_1,
+]
+const quoterContract = new web3.eth.Contract(IQuoterV2_ABI, addresses.uniQuoterV2)
+
+async function testQuote() {
+  const startTimestamp = Date.now()
+  await UniswapState.initializeFreshPoolsData(POOLS, 1, web3)
+  const endTimestamp = Date.now()
+
+  console.log('Time taken for initialization: ', endTimestamp - startTimestamp)
+
+  const trades: TradeInfo[] = getTestTrades()
+
+  for (let tradeInfo of trades) {
+    let params = {
+      tokenIn: tradeInfo.tokenIn,
+      tokenOut: tradeInfo.tokenOut,
+      amountIn: tradeInfo.amountIn,
+      fee: tradeInfo.fee,
+      sqrtPriceLimitX96: 0,
+    }
+    const tokenIn = { _address: tradeInfo.tokenIn } as Token
+    const tokenOut = { _address: tradeInfo.tokenOut } as Token
+    //@ts-ignore
+    let x: any[] = await quoterContract.methods.quoteExactInputSingle(params).call()
+
+    const uniV3Pool = new UniswapV3Pool(tradeInfo.pool, 'uniswap', [tokenIn, tokenOut])
+
+    let y = uniV3Pool.calculateExpectedOutputAmount(tradeInfo.tokenIn, tradeInfo.tokenOut, tradeInfo.amountIn)
+
+    console.log('-------')
+    console.log('Uniswap quote: ', x[0], x[2])
+    console.log('Offchain quote: ', y)
+  }
+}
+
+function getTestTrades(): TradeInfo[] {
+  let trades: TradeInfo[] = []
+
+  trades.push(
+    new TradeInfo(
+      addresses.univ3_wbtc_eth_pool_0_3,
+      addresses.wethToken,
+      addresses.wbtcToken,
+      BigInt('100000000000000000000'), // 100 WETH
+      BigInt(3000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.gmx_usdc_pool_0_1,
+      addresses.gmxToken,
+      addresses.usdcToken,
+      BigInt('200000000000000000000'), // 200 GMX
+      BigInt(10000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.uni_weth_pool,
+      addresses.wethToken,
+      addresses.uniToken,
+      BigInt('1000000000000000000'), // 1 WETH
+      BigInt(3000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.weth_link_pool,
+      addresses.linkToken,
+      addresses.wethToken,
+      BigInt('3000000000000000000000'), // 3000 LINK
+      BigInt(3000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.dai_usdce_pool_0_0_1,
+      addresses.usdceToken,
+      addresses.daiToken,
+      BigInt('10000000000'), // 10 000 usdc
+      BigInt(100)
+    )
+  )
+
+  // ZERO FOR ONE
+
+  trades.push(
+    new TradeInfo(
+      addresses.univ3_wbtc_eth_pool_0_3,
+      addresses.wbtcToken,
+      addresses.wethToken,
+      BigInt('1000000000'), // 10 WBTC
+      BigInt(3000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.gmx_usdc_pool_0_1,
+      addresses.usdcToken,
+      addresses.gmxToken,
+      BigInt('1000000000'), // 1000 USDC
+      BigInt(10000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.uni_weth_pool,
+      addresses.uniToken,
+      addresses.wethToken,
+      BigInt('1000000000000000000000'), // 1000 UNI
+      BigInt(3000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.weth_link_pool,
+      addresses.wethToken,
+      addresses.linkToken,
+      BigInt('10000000000000000000'), // 10 WETH
+      BigInt(3000)
+    )
+  )
+  trades.push(
+    new TradeInfo(
+      addresses.dai_usdce_pool_0_0_1,
+      addresses.daiToken,
+      addresses.usdceToken,
+      BigInt('1000000000000000000000'), // 1000 DAI
+      BigInt(100)
+    )
+  )
+
+  return trades
+}
+
+async function main() {
+  await testQuote()
+}
+
+main()