@marko00/routing-finder-mare 1.0.0

package/dexes/graph_queries/BalancerV2.ts

@@ -0,0 +1,150 @@
+import { parse } from 'graphql'
+import { gql, request } from 'graphql-request'
+import { TypedDocumentNode } from '@graphql-typed-document-node/core'
+import { dexIds, balancerWeightedPoolTypes } from '../dexIdsList'
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../../utils/types/types'
+import { BalancerState } from '../pools/Balancer/BalancerState'
+import { myLocalStorage } from '../../swap/my_local_storage'
+import Web3 from 'web3'
+
+export default class BalancerV2 implements DEXGraphFunctionality {
+  endpoint = ``
+  dexId = dexIds.BALANCER_V2
+  chainId = 1
+  myLocalStorage = null
+
+  static initialize(myLocalStorage: any): DEXGraphFunctionality {
+    const object = new BalancerV2();
+    object.myLocalStorage = myLocalStorage;
+    return object
+  }
+
+  setEndpoint(chainId: number, graphApiKey: string): void {
+    if (chainId == 1) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/C4ayEZP2yTXRAB8vSaTrgN4m9anTe9Mdm2ViyiAuV9TV`
+    }
+    if (chainId == 42161) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/itkjv6Vdh22HtNEPQuk5c9M3T7VeGLQtXxcH8rFi1vc`
+    }
+    this.chainId = chainId
+  }
+
+  async getTopPools(numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryTopPools(numPools))
+    queryResult.pools.forEach((pool: any) => {
+      try {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId))
+      } catch (e) { }
+    })
+
+    return poolsInfo
+  }
+
+  async getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryPoolsWithTokenPair(tokenA, tokenB, numPools))
+    queryResult.pools.forEach((pool: any) => {
+      try {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId))
+      } catch (e) { }
+    })
+
+    return poolsInfo
+  }
+
+  async getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryPoolsWithToken(token, numPools))
+    queryResult.pools.forEach((pool: any) => {
+      try {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId))
+      } catch (e) { }
+    })
+
+    return poolsInfo
+  }
+
+  async getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]> {
+    const pools: Pool[] = await BalancerState.getPoolDataFromContract(poolInfos, this.chainId, rpcProvider)
+    for (const pool of pools)
+      // @ts-ignore
+      this.myLocalStorage.setItem(pool.poolId.toLowerCase(), pool)
+    return pools
+  }
+}
+
+function queryTopPools(numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql`{
+    pools(first: ${numPools},  orderBy: totalLiquidity, orderDirection: desc, where: {totalLiquidity_not: "0"}) {
+      id
+      name
+      poolType
+      tokens {
+        id
+        decimals
+        name
+      }
+    }
+  }
+  `)
+}
+
+function queryPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql`{
+      pools(first: ${numPools}, orderBy: totalLiquidity, orderDirection: desc, where: {
+          and: [
+              {tokens_: {address: "${tokenA.toLowerCase()}"}},
+              {tokens_: {address: "${tokenB.toLowerCase()}"}},
+              {totalLiquidity_not: "0"}
+            ],
+        }
+        ) {
+          id
+          poolType
+          tokens {
+            id
+            decimals
+            name
+          }
+      }
+  }
+  `)
+}
+
+function queryPoolsWithToken(token: string, numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql`{
+      pools(first: ${numPools}, orderBy: totalLiquidity, orderDirection: desc, where: 
+          {
+              tokens_: {address_contains: "${token.toLowerCase()}"},
+              totalLiquidity_not: "0"
+          }
+        ) {
+          id
+          poolType
+          tokens {
+            id
+            decimals
+            name
+          }
+      }
+  }
+  `)
+}
+
+function createPoolFromGraph(jsonData: any, dexId: string): PoolInfo {
+  const isWeighted = balancerWeightedPoolTypes.includes(jsonData.poolType)
+  if (!isWeighted) throw new Error('BALANCER: Pool type not supported')
+  const pool: PoolInfo = {
+    poolId: jsonData.id,
+    dexId: dexId,
+    tokens: jsonData.tokens.map((token: any) => {
+      return {
+        _address: token.id,
+        decimals: token.decimals,
+        name: token.name,
+      }
+    }),
+  }
+  return pool
+}

package/dexes/graph_queries/CamelotV2.ts

@@ -0,0 +1,202 @@
+import { parse } from 'graphql'
+import { gql, request } from 'graphql-request'
+import { TypedDocumentNode } from '@graphql-typed-document-node/core'
+import { Pool, PoolInfo, Token, DEXGraphFunctionality } from '../../utils/types/types'
+import { dexIds } from '../dexIdsList'
+import { CamelotPool } from '../pools/Camelot'
+import { CreateCamelotHelperContract } from '../../contracts/rateX/CamelotHelper'
+import Web3 from 'web3'
+
+// Camelot is a silly place
+
+export default class CamelotV2 implements DEXGraphFunctionality {
+  // Camelot is currently not working, ne
+  endpoint = ``
+  dexId = dexIds.CAMELOT
+  chainId = 1
+  myLocalStorage = null
+
+  static initialize(myLocalStorage: any): DEXGraphFunctionality {
+    const object = new CamelotV2();
+    object.myLocalStorage = myLocalStorage;
+    return object
+  }
+
+  setEndpoint(chainId: number, graphApiKey: string): void {
+    if (chainId == 1) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/8zagLSufxk5cVhzkzai3tyABwJh53zxn9tmUYJcJxijG`
+    }
+    if (chainId == 42161) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/8zagLSufxk5cVhzkzai3tyABwJh53zxn9tmUYJcJxijG`
+    }
+    this.chainId = chainId
+  }
+
+  async getTopPools(numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryTopPools(numPools))
+    queryResult.pairs.forEach((lp: any) => {
+      poolsInfo.push(createPoolFromGraph(lp, this.dexId))
+    })
+
+    return poolsInfo
+  }
+
+  async getPoolsWithTokenPair(token1: string, token2: string, first: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryPoolsWithTokenPair(token1, token2, first))
+    queryResult.pairs.forEach((lp: any) => {
+      poolsInfo.push(createPoolFromGraph(lp, this.dexId))
+    })
+
+    return poolsInfo
+  }
+
+  async getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryPoolsWithToken(token, numPools))
+    queryResult.pairs.forEach((lp: any) => {
+      poolsInfo.push(createPoolFromGraph(lp, this.dexId))
+    })
+
+    return poolsInfo
+  }
+
+  // call to Solidity for additional data
+  async getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]> {
+    const CamelotHelperContract = CreateCamelotHelperContract(this.chainId, rpcProvider)
+    //@ts-ignore
+    const rawData: any[][] = await CamelotHelperContract.methods.getPoolsData(poolInfos).call()
+
+    const pools: Pool[] = []
+    for (let pool of rawData) {
+      const poolId = pool[0]
+      const dexId = pool[1]
+      const tokensRaw1 = pool[2][0]
+      const tokensRaw2 = pool[2][1]
+
+      const token1: Token = {
+        _address: tokensRaw1[0],
+        decimals: Number(tokensRaw1[1]),
+      }
+
+      const token2: Token = {
+        _address: tokensRaw2[0],
+        decimals: Number(tokensRaw2[1]),
+      }
+
+      const reserves = [BigInt(pool[3][0]), BigInt(pool[3][1])]
+      const fees = [BigInt(pool[4][0]), BigInt(pool[4][1])]
+      const stableSwap = pool[5]
+
+      // do not include pools with no liquidity
+      if (reserves[0] === BigInt(0) || reserves[1] === BigInt(0)) {
+        continue
+      }
+
+      pools.push(new CamelotPool(poolId, dexId, [token1, token2], reserves, fees, stableSwap))
+    }
+    for (const pool of pools)
+      // @ts-ignore
+      this.myLocalStorage.setItem(pool.poolId.toLowerCase(), pool)
+    return pools
+  }
+}
+
+function queryTopPools(numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql`
+      {
+        pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD) {
+          id
+          token0 {
+            id
+            name
+            decimals
+          }
+          token1 {
+            id
+            name
+            decimals
+          }
+        }
+      }
+    `)
+}
+
+function queryPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql`
+      {
+        pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD, where: {
+          or: [
+            {and: [
+              {token0_: {id: "${tokenA.toLowerCase()}"}},
+              {token1_: {id: "${tokenB.toLowerCase()}"}}
+            ]},
+            {and: [
+              {token0_: {id: "${tokenB.toLowerCase()}"}},
+              {token1_: {id: "${tokenA.toLowerCase()}"}}
+            ]}
+          ]   
+        }) {
+          id
+          volumeUSD
+          token0 {
+            id
+            name
+            decimals
+          }
+          token1 {
+            id
+            name
+            decimals
+          }
+        }
+      }
+    `)
+}
+
+function queryPoolsWithToken(token: string, numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql`
+    {
+      pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD, where: {
+        or: [
+          {token0_: {id: "${token.toLowerCase()}"}},
+          {token1_: {id: "${token.toLowerCase()}"}}
+        ]
+      }) {
+        id
+        volumeUSD
+        token0 {
+          id
+          name
+          decimals
+        }
+        token1 {
+          id
+          name
+          decimals
+        }
+      }
+    }  
+  `)
+}
+
+function createPoolFromGraph(jsonData: any, dexId: string): PoolInfo {
+  const pool: PoolInfo = {
+    poolId: jsonData.id,
+    dexId: dexId,
+    tokens: [
+      {
+        _address: jsonData.token0.id,
+        decimals: jsonData.token0.decimals,
+        name: jsonData.token0.name,
+      },
+      {
+        _address: jsonData.token1.id,
+        decimals: jsonData.token1.decimals,
+        name: jsonData.token1.name,
+      },
+    ],
+  }
+  return pool
+}

package/dexes/graph_queries/SushiSwapV2.ts

@@ -0,0 +1,283 @@
+import { parse } from 'graphql'
+import { gql, request } from 'graphql-request'
+import { TypedDocumentNode } from '@graphql-typed-document-node/core'
+import { dexIds } from '../dexIdsList'
+import { Pool, PoolInfo, Token, DEXGraphFunctionality } from '../../utils/types/types'
+import { SushiSwapV2Pool } from '../pools/SushiSwapV2'
+import Web3 from 'web3'
+import { CreateSushiSwapHelperContract } from '../../contracts/rateX/SushiSwapHelper'
+
+
+export default class SushiSwapV2 implements DEXGraphFunctionality {
+  endpoint = ""
+  dexId = dexIds.SUSHI_V2
+  chainId = 1
+  myLocalStorage = null
+
+  static initialize(myLocalStorage: any): DEXGraphFunctionality {
+    const object = new SushiSwapV2();
+    object.myLocalStorage = myLocalStorage;
+    return object
+  }
+
+  setEndpoint(chainId: number, graphApiKey: string): void {
+    if (chainId == 1) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/77jZ9KWeyi3CJ96zkkj5s1CojKPHt6XJKjLFzsDCd8Fd`
+    }
+    if (chainId == 42161) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/8yBXBTMfdhsoE5QCf7KnoPmQb7QAWtRzESfYjiCjGEM9`
+    }
+    this.chainId = chainId
+  }
+
+  async getTopPools(numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryTopPools(numPools, this.chainId))
+    if (this.chainId == 1) {
+      queryResult.liquidityPools.forEach((pool: any) => {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId))
+      })
+    } else {
+      queryResult.pairs.forEach((pool: any) => {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId))
+      })
+    }
+
+    return poolsInfo
+  }
+
+  async getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryPoolsWithTokenPair(tokenA, tokenB, numPools, this.chainId))
+    if (this.chainId == 1) {
+      queryResult.liquidityPools.forEach((pool: any) => {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId))
+      })
+    } else {
+      queryResult.pairs.forEach((pool: any) => {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId))
+      })
+    }
+
+    return poolsInfo
+  }
+
+  async getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryPoolsWithToken(token, numPools, this.chainId))
+    if (this.chainId == 1) {
+      queryResult.liquidityPools.forEach((pool: any) => {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId))
+      })
+    } else {
+      queryResult.pairs.forEach((pool: any) => {
+        poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId))
+      })
+    }
+
+    return poolsInfo
+  }
+
+  async getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]> {
+    //@ts-ignore
+    const SushiSwapHelperContract = CreateSushiSwapHelperContract(this.chainId, rpcProvider)
+    const rawData: any[][] = await SushiSwapHelperContract.methods.getPoolsData(poolInfos).call()
+
+    const pools: Pool[] = []
+    for (let pool of rawData) {
+      const poolId = pool[0]
+      const dexId = pool[1]
+      const tokensRaw1 = pool[2][0]
+      const tokensRaw2 = pool[2][1]
+
+      const token1: Token = {
+        _address: tokensRaw1[0],
+        decimals: Number(tokensRaw1[1]),
+        name: tokensRaw1[2],
+      }
+
+      const token2: Token = {
+        _address: tokensRaw2[0],
+        decimals: Number(tokensRaw2[1]),
+        name: tokensRaw2[2],
+      }
+
+      pools.push(new SushiSwapV2Pool(pool[0], pool[1], [token1, token2], pool[3]))
+    }
+    for (const pool of pools)
+      // @ts-ignore
+      this.myLocalStorage.setItem(pool.poolId.toLowerCase(), pool)
+    return pools
+  }
+}
+
+function queryTopPools(numPools: number, chainId: number): TypedDocumentNode<any, Record<string, unknown>> {
+  if (chainId == 1) {
+    return parse(gql`
+    {
+      liquidityPools(first:${numPools}, orderDirection: desc, orderBy: cumulativeVolumeUSD) {
+        id
+        cumulativeVolumeUSD
+        inputTokens {
+          id
+          decimals
+          name
+        }
+      }
+    }
+  `)
+  }
+  return parse(gql`
+    {
+      pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD) {
+        id
+        volumeUSD
+        token0 {
+          id
+          name
+          decimals
+        }
+        token1 {
+          id
+          name
+          decimals
+        }
+      }
+    }
+  `)
+}
+
+function queryPoolsWithTokenPair(
+  tokenA: string,
+  tokenB: string,
+  numPools: number,
+  chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  if (chainId == 1) {
+    return parse(gql`{
+    liquidityPools(first: ${numPools}, orderDirection: desc, orderBy: cumulativeVolumeUSD, where: {
+      and: [
+        {inputTokens_: {id: "${tokenA.toLowerCase()}"}},
+        {inputTokens_: {id: "${tokenB.toLowerCase()}"}}
+      ]
+    }
+    ) {
+      id
+      cumulativeVolumeUSD
+      inputTokens {
+        id
+        decimals
+        name
+      }
+    }
+  }`)
+  }
+
+  return parse(gql`
+    {
+      pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD, where: {
+        or: [
+          {and: [
+            {token0_: {id: "${tokenA.toLowerCase()}"}},
+            {token1_: {id: "${tokenB.toLowerCase()}"}}
+          ]},
+          {and: [
+            {token0_: {id: "${tokenB.toLowerCase()}"}},
+            {token1_: {id: "${tokenA.toLowerCase()}"}}
+          ]}
+        ]   
+      }) {
+        id
+        volumeUSD
+        token0 {
+          id
+          name
+          decimals
+        }
+        token1 {
+          id
+          name
+          decimals
+        }
+      }
+    }
+  `)
+}
+
+function queryPoolsWithToken(token: string, numPools: number, chainId: number): TypedDocumentNode<any, Record<string, unknown>> {
+  if (chainId == 1) {
+    return parse(gql`{
+    liquidityPools(first: ${numPools}, orderDirection: desc, orderBy: cumulativeVolumeUSD, where: {
+      inputTokens_: { id: "${token.toLowerCase()}" }
+    }
+    ) {
+      id
+      cumulativeVolumeUSD
+      inputTokens {
+        id
+        decimals
+        name
+      }
+    }
+  }`)
+  }
+
+  return parse(gql`
+  {
+    pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD, where: {
+      or: [
+        {token0_: {id: "${token.toLowerCase()}"}},
+        {token1_: {id: "${token.toLowerCase()}"}}
+      ]
+    }) {
+      id
+      volumeUSD
+      token0 {
+        id
+        name
+        decimals
+      }
+      token1 {
+        id
+        name
+        decimals
+      }
+    }
+  }  
+`)
+}
+
+function createPoolFromGraph(jsonData: any, dexId: string, chainId: number): PoolInfo {
+  let pool: PoolInfo
+  if (chainId == 1) {
+    pool = {
+      poolId: jsonData.id,
+      dexId: dexId,
+      tokens: jsonData.inputTokens.map((token: any, index: any) => {
+        return {
+          _address: token.id,
+          decimals: token.decimals,
+          name: token.name,
+        }
+      }),
+    }
+  } else {
+    pool = {
+      poolId: jsonData.id,
+      dexId: dexId,
+      tokens: [
+        {
+          _address: jsonData.token0.id,
+          decimals: jsonData.token0.decimals,
+          name: jsonData.token0.name,
+        },
+        {
+          _address: jsonData.token1.id,
+          decimals: jsonData.token1.decimals,
+          name: jsonData.token1.name,
+        },
+      ],
+    }
+  }
+  return pool
+}