@marko00/routing-finder-mare 1.0.0

package/dist/dexes/graph_queries/CamelotV2.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_request_1 = require("graphql-request");
+const dexIdsList_1 = require("../dexIdsList");
+const Camelot_1 = require("../pools/Camelot");
+const CamelotHelper_1 = require("../../contracts/rateX/CamelotHelper");
+// Camelot is a silly place
+class CamelotV2 {
+    constructor() {
+        // Camelot is currently not working, ne
+        this.endpoint = ``;
+        this.dexId = dexIdsList_1.dexIds.CAMELOT;
+        this.chainId = 1;
+        this.myLocalStorage = null;
+    }
+    static initialize(myLocalStorage) {
+        const object = new CamelotV2();
+        object.myLocalStorage = myLocalStorage;
+        return object;
+    }
+    setEndpoint(chainId, graphApiKey) {
+        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) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryTopPools(numPools));
+        queryResult.pairs.forEach((lp) => {
+            poolsInfo.push(createPoolFromGraph(lp, this.dexId));
+        });
+        return poolsInfo;
+    }
+    async getPoolsWithTokenPair(token1, token2, first) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenPair(token1, token2, first));
+        queryResult.pairs.forEach((lp) => {
+            poolsInfo.push(createPoolFromGraph(lp, this.dexId));
+        });
+        return poolsInfo;
+    }
+    async getPoolsWithToken(token, numPools) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryPoolsWithToken(token, numPools));
+        queryResult.pairs.forEach((lp) => {
+            poolsInfo.push(createPoolFromGraph(lp, this.dexId));
+        });
+        return poolsInfo;
+    }
+    // call to Solidity for additional data
+    async getAdditionalPoolDataFromSolidity(poolInfos, rpcProvider) {
+        const CamelotHelperContract = (0, CamelotHelper_1.CreateCamelotHelperContract)(this.chainId, rpcProvider);
+        //@ts-ignore
+        const rawData = await CamelotHelperContract.methods.getPoolsData(poolInfos).call();
+        const pools = [];
+        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 = {
+                _address: tokensRaw1[0],
+                decimals: Number(tokensRaw1[1]),
+            };
+            const token2 = {
+                _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 Camelot_1.CamelotPool(poolId, dexId, [token1, token2], reserves, fees, stableSwap));
+        }
+        for (const pool of pools)
+            // @ts-ignore
+            this.myLocalStorage.setItem(pool.poolId.toLowerCase(), pool);
+        return pools;
+    }
+}
+exports.default = CamelotV2;
+function queryTopPools(numPools) {
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+      {
+        pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD) {
+          id
+          token0 {
+            id
+            name
+            decimals
+          }
+          token1 {
+            id
+            name
+            decimals
+          }
+        }
+      }
+    `);
+}
+function queryPoolsWithTokenPair(tokenA, tokenB, numPools) {
+    return (0, graphql_1.parse)((0, graphql_request_1.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, numPools) {
+    return (0, graphql_1.parse)((0, graphql_request_1.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, dexId) {
+    const 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;
+}

package/dist/dexes/graph_queries/SushiSwapV2.d.ts

@@ -0,0 +1,14 @@
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../../utils/types/types';
+import Web3 from 'web3';
+export default class SushiSwapV2 implements DEXGraphFunctionality {
+    endpoint: string;
+    dexId: string;
+    chainId: number;
+    myLocalStorage: null;
+    static initialize(myLocalStorage: any): DEXGraphFunctionality;
+    setEndpoint(chainId: number, graphApiKey: string): void;
+    getTopPools(numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]>;
+    getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]>;
+}

package/dist/dexes/graph_queries/SushiSwapV2.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_request_1 = require("graphql-request");
+const dexIdsList_1 = require("../dexIdsList");
+const SushiSwapV2_1 = require("../pools/SushiSwapV2");
+const SushiSwapHelper_1 = require("../../contracts/rateX/SushiSwapHelper");
+class SushiSwapV2 {
+    constructor() {
+        this.endpoint = "";
+        this.dexId = dexIdsList_1.dexIds.SUSHI_V2;
+        this.chainId = 1;
+        this.myLocalStorage = null;
+    }
+    static initialize(myLocalStorage) {
+        const object = new SushiSwapV2();
+        object.myLocalStorage = myLocalStorage;
+        return object;
+    }
+    setEndpoint(chainId, graphApiKey) {
+        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) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryTopPools(numPools, this.chainId));
+        if (this.chainId == 1) {
+            queryResult.liquidityPools.forEach((pool) => {
+                poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId));
+            });
+        }
+        else {
+            queryResult.pairs.forEach((pool) => {
+                poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId));
+            });
+        }
+        return poolsInfo;
+    }
+    async getPoolsWithTokenPair(tokenA, tokenB, numPools) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenPair(tokenA, tokenB, numPools, this.chainId));
+        if (this.chainId == 1) {
+            queryResult.liquidityPools.forEach((pool) => {
+                poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId));
+            });
+        }
+        else {
+            queryResult.pairs.forEach((pool) => {
+                poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId));
+            });
+        }
+        return poolsInfo;
+    }
+    async getPoolsWithToken(token, numPools) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryPoolsWithToken(token, numPools, this.chainId));
+        if (this.chainId == 1) {
+            queryResult.liquidityPools.forEach((pool) => {
+                poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId));
+            });
+        }
+        else {
+            queryResult.pairs.forEach((pool) => {
+                poolsInfo.push(createPoolFromGraph(pool, this.dexId, this.chainId));
+            });
+        }
+        return poolsInfo;
+    }
+    async getAdditionalPoolDataFromSolidity(poolInfos, rpcProvider) {
+        //@ts-ignore
+        const SushiSwapHelperContract = (0, SushiSwapHelper_1.CreateSushiSwapHelperContract)(this.chainId, rpcProvider);
+        const rawData = await SushiSwapHelperContract.methods.getPoolsData(poolInfos).call();
+        const pools = [];
+        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 = {
+                _address: tokensRaw1[0],
+                decimals: Number(tokensRaw1[1]),
+                name: tokensRaw1[2],
+            };
+            const token2 = {
+                _address: tokensRaw2[0],
+                decimals: Number(tokensRaw2[1]),
+                name: tokensRaw2[2],
+            };
+            pools.push(new SushiSwapV2_1.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;
+    }
+}
+exports.default = SushiSwapV2;
+function queryTopPools(numPools, chainId) {
+    if (chainId == 1) {
+        return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      liquidityPools(first:${numPools}, orderDirection: desc, orderBy: cumulativeVolumeUSD) {
+        id
+        cumulativeVolumeUSD
+        inputTokens {
+          id
+          decimals
+          name
+        }
+      }
+    }
+  `);
+    }
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      pairs(first: ${numPools}, orderDirection: desc, orderBy: volumeUSD) {
+        id
+        volumeUSD
+        token0 {
+          id
+          name
+          decimals
+        }
+        token1 {
+          id
+          name
+          decimals
+        }
+      }
+    }
+  `);
+}
+function queryPoolsWithTokenPair(tokenA, tokenB, numPools, chainId) {
+    if (chainId == 1) {
+        return (0, graphql_1.parse)((0, graphql_request_1.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 (0, graphql_1.parse)((0, graphql_request_1.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, numPools, chainId) {
+    if (chainId == 1) {
+        return (0, graphql_1.parse)((0, graphql_request_1.gql) `{
+    liquidityPools(first: ${numPools}, orderDirection: desc, orderBy: cumulativeVolumeUSD, where: {
+      inputTokens_: { id: "${token.toLowerCase()}" }
+    }
+    ) {
+      id
+      cumulativeVolumeUSD
+      inputTokens {
+        id
+        decimals
+        name
+      }
+    }
+  }`);
+    }
+    return (0, graphql_1.parse)((0, graphql_request_1.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, dexId, chainId) {
+    let pool;
+    if (chainId == 1) {
+        pool = {
+            poolId: jsonData.id,
+            dexId: dexId,
+            tokens: jsonData.inputTokens.map((token, index) => {
+                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;
+}

package/dist/dexes/graph_queries/UniswapV2.d.ts

@@ -0,0 +1,14 @@
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../../utils/types/types';
+import Web3 from 'web3';
+export default class UniswapV2 implements DEXGraphFunctionality {
+    endpoint: string;
+    chainId: number;
+    dexId: string;
+    myLocalStorage: null;
+    static initialize(myLocalStorage: any): DEXGraphFunctionality;
+    setEndpoint(chainId: number, graphApiKey: string): void;
+    getTopPools(numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]>;
+    getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]>;
+}

package/dist/dexes/graph_queries/UniswapV2.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_request_1 = require("graphql-request");
+const dexIdsList_1 = require("../dexIdsList");
+const UniswapV2_1 = require("../pools/UniswapV2");
+const UniswapV2Helper_1 = require("../../contracts/rateX/UniswapV2Helper");
+const graphQueryFilters_1 = require("./graphQueryFilters");
+class UniswapV2 {
+    constructor() {
+        this.endpoint = ``;
+        this.chainId = 1;
+        this.dexId = dexIdsList_1.dexIds.UNI_V2;
+        this.myLocalStorage = null;
+    }
+    static initialize(myLocalStorage) {
+        const object = new UniswapV2();
+        object.myLocalStorage = myLocalStorage;
+        return object;
+    }
+    // @reminder add uniswapv2 real endpoint for arbitrum
+    setEndpoint(chainId, graphApiKey) {
+        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) {
+        const poolsInfo = [];
+        const { resultKey } = (0, graphQueryFilters_1.v2LiquidityCollection)(this.chainId);
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryTopPools(numPools, this.chainId));
+        queryResult[resultKey].forEach((pool) => {
+            poolsInfo.push(createPoolFromGraph(pool, this.dexId));
+        });
+        return poolsInfo;
+    }
+    async getPoolsWithTokenPair(tokenA, tokenB, numPools) {
+        const a = tokenA.toLowerCase();
+        const b = tokenB.toLowerCase();
+        const { resultKey } = (0, graphQueryFilters_1.v2LiquidityCollection)(this.chainId);
+        const [resAb, resBa] = await Promise.all([
+            (0, graphql_request_1.request)(this.endpoint, queryPairsWithTokenPairDirected(a, b, numPools, this.chainId)),
+            (0, graphql_request_1.request)(this.endpoint, queryPairsWithTokenPairDirected(b, a, numPools, this.chainId)),
+        ]);
+        return mergePairsByVolume([resAb[resultKey], resBa[resultKey]], numPools, this.dexId);
+    }
+    async getPoolsWithToken(token, numPools) {
+        const t = token.toLowerCase();
+        const { resultKey } = (0, graphQueryFilters_1.v2LiquidityCollection)(this.chainId);
+        const [res0, res1] = await Promise.all([
+            (0, graphql_request_1.request)(this.endpoint, queryPairsWithTokenOnSide0(t, numPools, this.chainId)),
+            (0, graphql_request_1.request)(this.endpoint, queryPairsWithTokenOnSide1(t, numPools, this.chainId)),
+        ]);
+        return mergePairsByVolume([res0[resultKey], res1[resultKey]], numPools, this.dexId);
+    }
+    async getAdditionalPoolDataFromSolidity(poolInfos, rpcProvider) {
+        //@ts-ignore
+        const UniswapV2HelperContract = (0, UniswapV2Helper_1.CreateUniswapV2HelperContract)(this.chainId, rpcProvider);
+        const rawData = await UniswapV2HelperContract.methods.getPoolsData(poolInfos).call();
+        const pools = [];
+        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 = {
+                _address: tokensRaw1[0],
+                decimals: Number(tokensRaw1[1]),
+                name: tokensRaw1[2],
+            };
+            const token2 = {
+                _address: tokensRaw2[0],
+                decimals: Number(tokensRaw2[1]),
+                name: tokensRaw2[2],
+            };
+            pools.push(new UniswapV2_1.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;
+    }
+}
+exports.default = UniswapV2;
+function queryTopPools(numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v2LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function queryPairsWithTokenPairDirected(token0Id, token1Id, numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v2LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${(0, graphQueryFilters_1.whereDirectedTokenPair)(token0Id, token1Id, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function queryPairsWithTokenOnSide0(token, numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v2LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${(0, graphQueryFilters_1.whereTokenOnSide)('token0', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function queryPairsWithTokenOnSide1(token, numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v2LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${(0, graphQueryFilters_1.whereTokenOnSide)('token1', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function mergePairsByVolume(pairLists, numPools, dexId) {
+    const byId = new Map();
+    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, dexId) {
+    const pool = {
+        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/dist/dexes/graph_queries/UniswapV3.d.ts

@@ -0,0 +1,14 @@
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../../utils/types/types';
+import Web3 from 'web3';
+export default class UniswapV3 implements DEXGraphFunctionality {
+    endpoint: string;
+    chainId: number;
+    dexId: string;
+    myLocalStorage: null;
+    static initialize(myLocalStorage: any): DEXGraphFunctionality;
+    setEndpoint(chainId: number, graphApiKey: string): void;
+    getTopPools(numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithTokenPair(tokenA: string, tokenB: string, numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]>;
+    getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[], rpcProvider: Web3): Promise<Pool[]>;
+}