@marko00/routing-finder-mare 1.0.0

package/dexes/graph_queries/UniswapV2.ts

@@ -0,0 +1,252 @@
+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 { UniswapV2Pool } from '../pools/UniswapV2'
+import Web3 from 'web3'
+import { CreateUniswapV2HelperContract } from '../../contracts/rateX/UniswapV2Helper'
+import { v2LiquidityCollection, whereDirectedTokenPair, whereTokenOnSide } from './graphQueryFilters'
+
+export default class UniswapV2 implements DEXGraphFunctionality {
+  endpoint = ``
+  chainId = 1
+  dexId = dexIds.UNI_V2
+  myLocalStorage = null
+
+  static initialize(myLocalStorage: any): DEXGraphFunctionality {
+    const object = new UniswapV2();
+    object.myLocalStorage = myLocalStorage;
+    return object
+  }
+
+  // @reminder add uniswapv2 real endpoint for arbitrum
+  setEndpoint(chainId: number, graphApiKey: string): void {
+
+    if (chainId == 1329) {
+      this.endpoint = `https://indexer.us.hyperindex.xyz/32230f9/converter`
+    }
+
+    if (chainId == 1) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/EYCKATKGBKLWvSfwvBjzfCBmGwYNdVkduYXVivCsLRFu`
+    }
+
+    if (chainId == 42161) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/CStW6CSQbHoXsgKuVCrk3uShGA4JX3CAzzv2x9zaGf8w`
+    }
+
+    if (chainId == 420420417) {
+      this.endpoint = `https://saphyre-service-dev.saphyre.xyz/api/graphql/v2`
+    }
+
+    this.chainId = chainId
+  }
+
+  async getTopPools(numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const { resultKey } = v2LiquidityCollection(this.chainId)
+    const queryResult = await request(this.endpoint, queryTopPools(numPools, this.chainId))
+
+    queryResult[resultKey].forEach((pool: any) => {
+      poolsInfo.push(createPoolFromGraph(pool, this.dexId))
+    })
+
+    return poolsInfo
+  }
+
+  async getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]> {
+    const a = tokenA.toLowerCase()
+    const b = tokenB.toLowerCase()
+    const { resultKey } = v2LiquidityCollection(this.chainId)
+    const [resAb, resBa] = await Promise.all([
+      request(this.endpoint, queryPairsWithTokenPairDirected(a, b, numPools, this.chainId)),
+      request(this.endpoint, queryPairsWithTokenPairDirected(b, a, numPools, this.chainId)),
+    ])
+    return mergePairsByVolume([resAb[resultKey], resBa[resultKey]], numPools, this.dexId)
+  }
+
+  async getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]> {
+    const t = token.toLowerCase()
+    const { resultKey } = v2LiquidityCollection(this.chainId)
+    const [res0, res1] = await Promise.all([
+      request(this.endpoint, queryPairsWithTokenOnSide0(t, numPools, this.chainId)),
+      request(this.endpoint, queryPairsWithTokenOnSide1(t, numPools, this.chainId)),
+    ])
+    return mergePairsByVolume([res0[resultKey], res1[resultKey]], numPools, this.dexId)
+  }
+
+  async getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]> {
+    //@ts-ignore
+    const UniswapV2HelperContract = CreateUniswapV2HelperContract(this.chainId, rpcProvider)
+    const rawData: any[][] = await UniswapV2HelperContract.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 UniswapV2Pool(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>> {
+  const { field } = v2LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function queryPairsWithTokenPairDirected(
+    token0Id: string,
+    token1Id: string,
+    numPools: number,
+    chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v2LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${whereDirectedTokenPair(token0Id, token1Id, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function queryPairsWithTokenOnSide0(
+    token: string,
+    numPools: number,
+    chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v2LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${whereTokenOnSide('token0', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function queryPairsWithTokenOnSide1(
+    token: string,
+    numPools: number,
+    chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v2LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${whereTokenOnSide('token1', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function mergePairsByVolume(pairLists: any[][], numPools: number, dexId: string): PoolInfo[] {
+  const byId = new Map<string, any>()
+  for (const list of pairLists) {
+    for (const pair of list) {
+      byId.set(String(pair.id).toLowerCase(), pair)
+    }
+  }
+  const merged = [...byId.values()]
+  merged.sort((a, b) => {
+    const va = parseFloat(a.volumeUSD) || 0
+    const vb = parseFloat(b.volumeUSD) || 0
+    return vb - va
+  })
+  return merged.slice(0, numPools).map((p) => createPoolFromGraph(p, dexId))
+}
+
+function createPoolFromGraph(jsonData: any, dexId: string): PoolInfo {
+  const pool: PoolInfo = {
+    poolId: jsonData.id,
+    dexId: dexId,
+    tokens: [
+      {
+        _address: jsonData.token0.id,
+        decimals: Number(jsonData.token0.decimals),
+        name: jsonData.token0.name,
+      },
+      {
+        _address: jsonData.token1.id,
+        decimals: Number(jsonData.token1.decimals),
+        name: jsonData.token1.name,
+      },
+    ],
+  }
+  return pool
+}

package/dexes/graph_queries/UniswapV3.ts

@@ -0,0 +1,229 @@
+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, DEXGraphFunctionality } from '../../utils/types/types'
+import { UniswapState } from '../pools/uniswap/uniswapState'
+import { UniswapV3Pool } from '../pools/uniswap/UniswapV3'
+import Web3 from 'web3'
+import { v3LiquidityCollection, whereDirectedTokenPair, whereTokenOnSide } from './graphQueryFilters'
+
+export default class UniswapV3 implements DEXGraphFunctionality {
+  endpoint = ``
+  chainId = 1
+  dexId = dexIds.UNI_V3
+  myLocalStorage = null
+
+  static initialize(myLocalStorage: any): DEXGraphFunctionality {
+    const object = new UniswapV3();
+    object.myLocalStorage = myLocalStorage;
+    return object
+  }
+
+  setEndpoint(chainId: number, graphApiKey: string): void {
+
+    if (chainId == 1329) {
+      this.endpoint = 'https://indexer.us.hyperindex.xyz/32230f9/converter'
+    }
+
+    if (chainId == 1) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/5zvR82QoaXYFyDEKLZ9t6v9adgnptxYpKpSbxtgVENFV`
+    }
+    if (chainId == 42161) {
+      this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/FbCGRftH4a3yZugY7TnbYgPJVEv2LvMT6oF1fxPe9aJM`
+    }
+
+    if (chainId == 420420417) {
+      this.endpoint = `https://saphyre-service-dev.saphyre.xyz/api/graphql/v3`
+    }
+
+    this.chainId = chainId
+  }
+
+  async getTopPools(numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const { resultKey } = v3LiquidityCollection(this.chainId)
+    const queryResult = await request(this.endpoint, queryTopPools(numPools, this.chainId))
+
+    queryResult[resultKey].forEach((pool: any) => {
+      poolsInfo.push(createPoolFromGraph(pool, this.dexId))
+    })
+
+    return poolsInfo
+  }
+
+  async getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]> {
+    const a = tokenA.toLowerCase()
+    const b = tokenB.toLowerCase()
+    const { resultKey } = v3LiquidityCollection(this.chainId)
+    const [resAb, resBa] = await Promise.all([
+      request(this.endpoint, queryPoolsWithTokenPairDirected(a, b, numPools, this.chainId)),
+      request(this.endpoint, queryPoolsWithTokenPairDirected(b, a, numPools, this.chainId)),
+    ])
+    return mergePoolsByVolume([resAb[resultKey], resBa[resultKey]], numPools, this.dexId)
+  }
+
+  async getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]> {
+    const t = token.toLowerCase()
+    const { resultKey } = v3LiquidityCollection(this.chainId)
+    const [res0, res1] = await Promise.all([
+      request(this.endpoint, queryPoolsWithTokenOnSide0(t, numPools, this.chainId)),
+      request(this.endpoint, queryPoolsWithTokenOnSide1(t, numPools, this.chainId)),
+    ])
+    return mergePoolsByVolume([res0[resultKey], res1[resultKey]], numPools, this.dexId)
+  }
+
+  async getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]> {
+    const pools = poolInfos.map((poolInfo: PoolInfo) => poolInfo.poolId)
+    await UniswapState.initializeFreshPoolsData(pools, this.chainId, rpcProvider)
+
+    const pools2 = poolInfos.map((poolInfo: PoolInfo) => new UniswapV3Pool(poolInfo.poolId, this.dexId, poolInfo.tokens));
+    for (const pool of pools2)
+        // @ts-ignore
+      this.myLocalStorage.setItem(pool.poolId.toLowerCase(), pool)
+    return pools2
+  }
+}
+
+function queryTopPools(numPools: number, chainId: number): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v3LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function queryPoolsWithTokenPairDirected(
+    token0Id: string,
+    token1Id: string,
+    numPools: number,
+    chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v3LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${whereDirectedTokenPair(token0Id, token1Id, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function queryPoolsWithTokenOnSide0(
+    token: string,
+    numPools: number,
+    chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v3LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${whereTokenOnSide('token0', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function queryPoolsWithTokenOnSide1(
+    token: string,
+    numPools: number,
+    chainId: number
+): TypedDocumentNode<any, Record<string, unknown>> {
+  const { field } = v3LiquidityCollection(chainId)
+  return parse(gql`
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${whereTokenOnSide('token1', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `)
+}
+
+function mergePoolsByVolume(poolLists: any[][], numPools: number, dexId: string): PoolInfo[] {
+  const byId = new Map<string, any>()
+  for (const list of poolLists) {
+    for (const pool of list) {
+      byId.set(String(pool.id).toLowerCase(), pool)
+    }
+  }
+  const merged = [...byId.values()]
+  merged.sort((a, b) => {
+    const va = parseFloat(a.volumeUSD) || 0
+    const vb = parseFloat(b.volumeUSD) || 0
+    return vb - va
+  })
+  return merged.slice(0, numPools).map((p) => createPoolFromGraph(p, dexId))
+}
+
+function createPoolFromGraph(jsonData: any, dexId: string): PoolInfo {
+  const pool: PoolInfo = {
+    poolId: jsonData.id,
+    dexId: dexId,
+    tokens: [
+      {
+        _address: jsonData.token0.id,
+        decimals: Number(jsonData.token0.decimals),
+        name: jsonData.token0.name,
+      },
+      {
+        _address: jsonData.token1.id,
+        decimals: Number(jsonData.token1.decimals),
+        name: jsonData.token1.name,
+      },
+    ],
+  }
+  return pool
+}

package/dexes/graph_queries/graphQueryFilters.ts

@@ -0,0 +1,41 @@
+/** Chains whose graph URL goes through HyperIndex → Hasura (Saphyre / Sei). */
+export function usesHyperIndexConverter(chainId: number): boolean {
+    return chainId === 1329 || chainId === 420420417
+}
+
+/** V2 liquidity collection: merged schema uses V2_Factory_Pair; The Graph uses pairs. */
+export function v2LiquidityCollection(chainId: number): { field: string; resultKey: string } {
+    if (usesHyperIndexConverter(chainId)) {
+        return { field: 'V2_Factory_Pair', resultKey: 'V2_Factory_Pair' }
+    }
+    return { field: 'pairs', resultKey: 'pairs' }
+}
+
+/** V3 liquidity collection: merged schema uses V3_Factory_Pool; The Graph uses pools. */
+export function v3LiquidityCollection(chainId: number): { field: string; resultKey: string } {
+    if (usesHyperIndexConverter(chainId)) {
+        return { field: 'V3_Factory_Pool', resultKey: 'V3_Factory_Pool' }
+    }
+    return { field: 'pools', resultKey: 'pools' }
+}
+
+/**
+ * `where` clause fragment for a pool/pair token side.
+ * - HyperIndex: `token0: { id: "0x..." }` (scalar address becomes invalid `token1: { _eq }` on Token_bool_exp)
+ * - The Graph: `token0: "0x..."`
+ */
+export function whereTokenOnSide(side: 'token0' | 'token1', address: string, chainId: number): string {
+    const id = address.toLowerCase()
+    if (usesHyperIndexConverter(chainId)) {
+        return `${side} : { id : "${id}" }`
+    }
+    return `${side} : "${id}"`
+}
+
+export function whereDirectedTokenPair(
+    token0Id: string,
+    token1Id: string,
+    chainId: number
+): string {
+    return `${whereTokenOnSide('token0', token0Id, chainId)}, ${whereTokenOnSide('token1', token1Id, chainId)}`
+}

package/dexes/graph_queries/x_template.ts

@@ -0,0 +1,67 @@
+import { parse } from 'graphql'
+import { gql, request } from 'graphql-request'
+import { TypedDocumentNode } from '@graphql-typed-document-node/core'
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../../utils/types/types'
+
+export default class NewDex implements DEXGraphFunctionality {
+  endpoint = ''
+  dexId = ''
+  chainId = 1
+
+  static initialize(): DEXGraphFunctionality {
+    return new NewDex()
+  }
+
+  setEndpoint(chainId: number): void {
+    if (chainId == 42161) {
+      this.endpoint = ''
+    }
+    this.chainId = chainId
+  }
+
+  async getTopPools(numPools: number): Promise<PoolInfo[]> {
+    const poolsInfo: PoolInfo[] = []
+    const queryResult = await request(this.endpoint, queryTopPools(numPools))
+    queryResult.pairs.forEach((pair: any) => {
+      poolsInfo.push(pair.id)
+    })
+
+    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((pair: any) => {
+      poolsInfo.push(pair.id)
+    })
+
+    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((pair: any) => {
+      poolsInfo.push(pair.id)
+    })
+
+    return poolsInfo
+  }
+
+  async getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[]): Promise<Pool[]> {
+    return []
+  }
+}
+
+function queryTopPools(numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql``)
+}
+
+function queryPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql``)
+}
+
+function queryPoolsWithToken(token: string, numPools: number): TypedDocumentNode<any, Record<string, unknown>> {
+  return parse(gql``)
+}

package/dexes/pools/Balancer/BalancerState.ts

@@ -0,0 +1,34 @@
+import { Pool, PoolInfo } from '../../../utils/types/types';
+import { BalancerWeightedPool } from './BalancerWeightedPool';
+import { CreateBalancerHelperContract } from '../../../contracts/rateX/BalancerHelper';
+import Web3 from 'web3';
+
+export class BalancerState {
+    private constructor() {}
+
+    public static async getPoolDataFromContract(pools: PoolInfo[], chainId: number, rpcProvider: Web3): Promise<Pool[]> {
+        const promises = pools.map(async (pool) => {
+            // return token address after '-' split
+            pool.tokens.forEach((token) => token._address = token._address.split('-')[1]);
+
+            const BalancerHelperContract = CreateBalancerHelperContract(chainId, rpcProvider);
+            try {
+                // @ts-ignore
+                const res: any[] = await BalancerHelperContract.methods
+                    .getWeightedPoolInfo(pool.poolId)
+                    .call();
+                
+                const [decimals, tokens, balances, weights, swapFeePercentage] = [res[0], res[1], res[2], res[3], res[4]];
+                const weightedPool = new BalancerWeightedPool(pool.poolId, pool.dexId, pool.tokens, balances, weights, swapFeePercentage);
+                return weightedPool;
+            } catch (err) {
+                console.log('Weighted Get Pool Info Error: ', err);
+                return null; // Handle the error as needed
+            }
+        });
+
+        const newPools = await Promise.all(promises);
+        // @ts-ignore
+        return newPools.filter((pool) => pool !== null); // Filter out any null values
+    }
+}