@marko00/routing-finder-mare 1.0.0

package/dist/swap/graph_communication.d.ts

@@ -0,0 +1,5 @@
+import Web3 from 'web3';
+import { Pool } from '../utils/types/types';
+import { Dexes } from '../index';
+declare function fetchPoolsData(tokenFrom: string, tokenTo: string, numFromToPools: number | undefined, numTopPools: number | undefined, chainId: number, rpcProvider: Web3, graphApiKey: string, dexes: Array<Dexes>): Promise<Pool[]>;
+export { fetchPoolsData };

package/dist/swap/graph_communication.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPoolsData = fetchPoolsData;
+const index_1 = require("../index");
+const my_local_storage_1 = require("./my_local_storage");
+const UniswapV2_1 = __importDefault(require("../dexes/graph_queries/UniswapV2"));
+const SushiSwapV2_1 = __importDefault(require("../dexes/graph_queries/SushiSwapV2"));
+const UniswapV3_1 = __importDefault(require("../dexes/graph_queries/UniswapV3"));
+const BalancerV2_1 = __importDefault(require("../dexes/graph_queries/BalancerV2"));
+const CamelotV2_1 = __importDefault(require("../dexes/graph_queries/CamelotV2"));
+let initializedMainnet = false;
+let initializedArbitrum = false;
+let initializedSei = false;
+let initializedPas = false;
+let initializedDexes = [];
+let dexesPools = new Map();
+async function initializeDexes(chainId, graphApiKey, dexes) {
+    try {
+        // Clear Previous Dex Graph Mappings and Initialized DEX array
+        dexesPools.clear();
+        initializedDexes = [];
+        for (const dex of dexes) {
+            let Dex;
+            switch (dex) {
+                case index_1.Dexes.BALANCER:
+                    Dex = BalancerV2_1.default;
+                    break;
+                case index_1.Dexes.CAMELOT:
+                    if (chainId === 1)
+                        continue;
+                    Dex = CamelotV2_1.default;
+                    break;
+                case index_1.Dexes.SUSHISWAP_V2:
+                    Dex = SushiSwapV2_1.default;
+                    break;
+                case index_1.Dexes.UNISWAP_V2:
+                    if (chainId === 42161)
+                        continue;
+                    Dex = UniswapV2_1.default;
+                    break;
+                case index_1.Dexes.UNISWAP_V3:
+                    Dex = UniswapV3_1.default;
+                    break;
+                default:
+                    throw Error("Invalid Dex value");
+            }
+            const dexInstance = Dex.initialize(my_local_storage_1.myLocalStorage);
+            dexInstance.setEndpoint(chainId, graphApiKey);
+            initializedDexes.push(dexInstance);
+            dexesPools.set(dexInstance, []);
+        }
+    }
+    catch (err) {
+        console.error('Error reading directory dexes_graph:', err);
+    }
+}
+async function checkInitializedDexes(chainId, graphApiKey, dexes) {
+    if (chainId === 1 && !initializedMainnet) {
+        await initializeDexes(chainId, graphApiKey, dexes);
+        initializedArbitrum = false;
+        initializedSei = false;
+        initializedPas = false;
+        initializedMainnet = true;
+    }
+    if (chainId === 42161 && !initializedArbitrum) {
+        await initializeDexes(chainId, graphApiKey, dexes);
+        initializedMainnet = false;
+        initializedSei = false;
+        initializedPas = false;
+        initializedArbitrum = true;
+    }
+    if (chainId === 1329 && !initializedSei) {
+        await initializeDexes(chainId, graphApiKey, dexes);
+        initializedMainnet = false;
+        initializedArbitrum = false;
+        initializedPas = false;
+        initializedSei = true;
+    }
+    if (chainId === 420420417 && !initializedPas) {
+        await initializeDexes(chainId, graphApiKey, dexes);
+        initializedMainnet = false;
+        initializedArbitrum = false;
+        initializedSei = false;
+        initializedPas = true;
+    }
+}
+/*   Returns dictionary of dexes and their poolIds for token1 and token2:
+ *   UniswapV3: [poolId1, poolId2, ...],
+ *   SushiSwapV2: [poolId1, poolId2, ...]
+ */
+async function getPoolIdsForTokenPairs(tokenA, tokenB, numPools = 3, chainId, graphApiKey, dexes) {
+    await checkInitializedDexes(chainId, graphApiKey, dexes);
+    const allPoolsPromises = initializedDexes.map((dex) => dex.getPoolsWithTokenPair(tokenA, tokenB, numPools));
+    const allPoolsResults = await Promise.all(allPoolsPromises);
+    initializedDexes.forEach((dex, index) => {
+        var _a;
+        const pools = allPoolsResults[index];
+        if (dexesPools.has(dex)) {
+            (_a = dexesPools.get(dex)) === null || _a === void 0 ? void 0 : _a.push(...pools);
+        }
+        else {
+            dexesPools.set(dex, pools);
+        }
+    });
+}
+/* Get pools from each dex in initializedDexes list that have token as one of the tokens in the pool
+ * @param token: token address to match (for now the chain is Arbitrum -> param for the future)
+ * @param numPools: number of pools to return from each dex
+ * @param amountIn: amount of token1 to swap (in wei) - currently unused
+ * @returns: list of poolIds
+ */
+async function getPoolIdsForToken(token, numPools = 5, chainId, graphApiKey, dexes) {
+    await checkInitializedDexes(chainId, graphApiKey, dexes);
+    const allPoolsPromises = initializedDexes.map((dex) => dex.getPoolsWithToken(token, numPools));
+    const allPoolsResults = await Promise.all(allPoolsPromises);
+    initializedDexes.forEach((dex, index) => {
+        var _a;
+        const pools = allPoolsResults[index];
+        if (dexesPools.has(dex)) {
+            (_a = dexesPools.get(dex)) === null || _a === void 0 ? void 0 : _a.push(...pools);
+        }
+        else {
+            dexesPools.set(dex, pools);
+        }
+    });
+}
+/* Get top pools from each dex in initializedDexes list - returns a list of poolIds
+ * @param numPools: number of pools to return from each dex
+ * @param amountIn: amount of token1 to swap (in wei) - currently unused
+ * @returns: list of poolIds
+ */
+async function getTopPools(numPools = 5, chainId, graphApiKey, dexes) {
+    await checkInitializedDexes(chainId, graphApiKey, dexes);
+    const allPoolsPromises = initializedDexes.map((dex) => dex.getTopPools(numPools));
+    const allPoolsResults = await Promise.all(allPoolsPromises);
+    initializedDexes.forEach((dex, index) => {
+        var _a;
+        const pools = allPoolsResults[index];
+        if (dexesPools.has(dex)) {
+            (_a = dexesPools.get(dex)) === null || _a === void 0 ? void 0 : _a.push(...pools);
+        }
+        else {
+            dexesPools.set(dex, pools);
+        }
+    });
+}
+/* We are fetching pools from multiple dexes, so we might get duplicate pools
+ * top numTopPools pools for tokenFrom and tokenTo are fetched from each DEX
+ * top numTopPools by TVL from each DEX
+ * top numTopPools that contain tokenFrom and tokenTo from each DEX (possible direct swap)
+ */
+async function fetchPoolsData(tokenFrom, tokenTo, numFromToPools = 5, numTopPools = 5, chainId, rpcProvider, graphApiKey, dexes) {
+    let pools = [];
+    dexesPools.forEach((poolInfos, dex) => {
+        dexesPools.set(dex, []);
+    });
+    await checkInitializedDexes(chainId, graphApiKey, dexes);
+    // call Graph API
+    const promises = [];
+    promises.push(getPoolIdsForToken(tokenFrom, numFromToPools, chainId, graphApiKey, dexes));
+    promises.push(getPoolIdsForToken(tokenTo, numFromToPools, chainId, graphApiKey, dexes));
+    promises.push(getTopPools(numTopPools, chainId, graphApiKey, dexes));
+    promises.push(getPoolIdsForTokenPairs(tokenFrom, tokenTo, numFromToPools, chainId, graphApiKey, dexes));
+    await Promise.all(promises);
+    filterDuplicatePools();
+    // call Solidity for additional pool data
+    const dexPoolsPromises = [];
+    for (let [dex, poolInfos] of dexesPools.entries()) {
+        dexPoolsPromises.push(dex.getAdditionalPoolDataFromSolidity(poolInfos, rpcProvider));
+    }
+    const allPoolsData = await Promise.all(dexPoolsPromises);
+    allPoolsData.forEach((poolsData) => {
+        pools.push(...poolsData);
+    });
+    return pools;
+}
+function filterDuplicatePools() {
+    dexesPools.forEach((poolInfos, dex, self) => {
+        const filteredPoolInfos = poolInfos.filter((poolInfo, index, allPoolInfos) => {
+            return allPoolInfos.findIndex((pool2) => pool2.poolId === poolInfo.poolId) === index;
+        });
+        self.set(dex, filteredPoolInfos);
+    });
+}

package/dist/swap/my_local_storage.d.ts

@@ -0,0 +1,8 @@
+import { Pool } from "../utils/types/types";
+interface ILocalStorage {
+    setItem(key: string, value: Pool): void;
+    getItem(key: string): Pool | null;
+    removeItem(key: string): void;
+}
+export declare const myLocalStorage: ILocalStorage;
+export {};

package/dist/swap/my_local_storage.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.myLocalStorage = void 0;
+const values = {};
+class MockLocalStorage {
+    setItem(key, value) {
+        values[key] = value;
+    }
+    getItem(key) {
+        return values[key] || null;
+    }
+    removeItem(key) {
+        delete values[key];
+    }
+}
+exports.myLocalStorage = new MockLocalStorage();

package/dist/utils/addresses.d.ts

@@ -0,0 +1,24 @@
+export declare const addresses: {
+    name: string;
+    uniQuoterV2: string;
+    wethToken: string;
+    daiToken: string;
+    usdtToken: string;
+    wbtcToken: string;
+    usdcToken: string;
+    uniToken: string;
+    linkToken: string;
+    usdceToken: string;
+    gmxToken: string;
+    sushiRouter: string;
+    sushiFactory: string;
+    univ3_wbtc_eth_pool_0_05: string;
+    univ3_wbtc_eth_pool_0_3: string;
+    sushi_wbtc_eth_pool: string;
+    gmx_usdc_pool_0_1: string;
+    uni_weth_pool: string;
+    weth_link_pool: string;
+    dai_usdce_pool_0_0_1: string;
+    impersonate_weth: string;
+    impersonate_dai: string;
+};

package/dist/utils/addresses.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addresses = void 0;
+// hardcode it like this for now
+exports.addresses = {
+    // Acutally used.
+    name: "sei",
+    uniQuoterV2: "0x38F759cf0Af1D0dcAEd723a3967A3B658738eDe9",
+    wethToken: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    daiToken: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+    usdtToken: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    wbtcToken: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+    usdcToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    uniToken: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0",
+    linkToken: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4",
+    usdceToken: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+    gmxToken: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a",
+    sushiRouter: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
+    sushiFactory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+    // uniQuoter: "0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6",
+    // uniQuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    // uniRouter: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+    univ3_wbtc_eth_pool_0_05: "0x2f5e87C9312fa29aed5c179E456625D79015299c", // 0.05 fee
+    univ3_wbtc_eth_pool_0_3: "0x149e36E72726e0BceA5c59d40df2c43F60f5A22D", // 0.3 fee
+    sushi_wbtc_eth_pool: "0x515e252b2b5c22b4b2b6Df66c2eBeeA871AA4d69", // 0.3 fee always
+    gmx_usdc_pool_0_1: "0x0A36952Fb8C8dc6daeFB2fADb07C5212f560880e",
+    uni_weth_pool: "0xC24f7d8E51A64dc1238880BD00bb961D54cbeb29",
+    weth_link_pool: "0x468b88941e7Cc0B88c1869d68ab6b570bCEF62Ff",
+    dai_usdce_pool_0_0_1: "0xF0428617433652c9dc6D1093A42AdFbF30D29f74",
+    impersonate_weth: "0x0df5dfd95966753f01cb80e76dc20ea958238c46",
+    impersonate_dai: "0xd85e038593d7a098614721eae955ec2022b9b91b"
+    // name: "arbitrum",
+    //
+    // wethToken: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    // daiToken: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+    // usdtToken: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    // wbtcToken: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+    // usdcToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    // uniToken: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0",
+    // linkToken: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4",
+    // usdceToken: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+    // gmxToken: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a",
+    //
+    // sushiRouter: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
+    // sushiFactory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+    //
+    // uniQuoter: "0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6",
+    // uniQuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    // uniRouter: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+    // univ3_wbtc_eth_pool_0_05: "0x2f5e87C9312fa29aed5c179E456625D79015299c", // 0.05 fee
+    // univ3_wbtc_eth_pool_0_3: "0x149e36E72726e0BceA5c59d40df2c43F60f5A22D", // 0.3 fee
+    // sushi_wbtc_eth_pool: "0x515e252b2b5c22b4b2b6Df66c2eBeeA871AA4d69", // 0.3 fee always
+    // gmx_usdc_pool_0_1: "0x0A36952Fb8C8dc6daeFB2fADb07C5212f560880e",
+    // uni_weth_pool: "0xC24f7d8E51A64dc1238880BD00bb961D54cbeb29",
+    // weth_link_pool: "0x468b88941e7Cc0B88c1869d68ab6b570bCEF62Ff",
+    // dai_usdce_pool_0_0_1: "0xF0428617433652c9dc6D1093A42AdFbF30D29f74",
+    //
+    // impersonate_weth: "0x0df5dfd95966753f01cb80e76dc20ea958238c46",
+    // impersonate_dai: "0xd85e038593d7a098614721eae955ec2022b9b91b"
+};

package/dist/utils/math/fixed-points.d.ts

@@ -0,0 +1,14 @@
+import BigNumber from "bignumber.js";
+export declare const ZERO: BigNumber;
+export declare const ONE: BigNumber;
+export declare const MAX_POW_RELATIVE_ERROR: BigNumber;
+export declare const MIN_POW_BASE_FREE_EXPONENT: BigNumber;
+export declare const add: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const sub: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const mulDown: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const mulUp: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const divDown: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const divUp: (a: BigNumber, b: BigNumber) => BigNumber;
+export declare const powDown: (x: BigNumber, y: BigNumber) => BigNumber;
+export declare const powUp: (x: BigNumber, y: BigNumber) => BigNumber;
+export declare const complement: (x: BigNumber) => BigNumber;

package/dist/utils/math/fixed-points.js

@@ -0,0 +1,123 @@
+"use strict";
+// Ported from Solidity:
+// https://github.com/balancer-labs/balancer-core-v2/blob/70843e6a61ad11208c1cfabf5cfe15be216ca8d3/pkg/solidity-utils/contracts/math/FixedPoint.sol
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complement = exports.powUp = exports.powDown = exports.divUp = exports.divDown = exports.mulUp = exports.mulDown = exports.sub = exports.add = exports.MIN_POW_BASE_FREE_EXPONENT = exports.MAX_POW_RELATIVE_ERROR = exports.ONE = exports.ZERO = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const logExp = __importStar(require("./log-exp"));
+exports.ZERO = new bignumber_js_1.default(0);
+exports.ONE = new bignumber_js_1.default("1000000000000000000"); // 10^18
+exports.MAX_POW_RELATIVE_ERROR = new bignumber_js_1.default(10000); // 10^(-14)
+// Minimum base for the power function when the exponent is 'free' (larger than ONE)
+exports.MIN_POW_BASE_FREE_EXPONENT = new bignumber_js_1.default("700000000000000000"); // 0.7e18
+const add = (a, b) => {
+    // Fixed Point addition is the same as regular checked addition
+    return a.plus(b);
+};
+exports.add = add;
+const sub = (a, b) => {
+    // Fixed Point subtraction is the same as regular checked subtraction
+    if (b.gt(a))
+        throw new Error("SUB_OVERFLOW");
+    return a.minus(b);
+};
+exports.sub = sub;
+const mulDown = (a, b) => {
+    return a.times(b).idiv(exports.ONE);
+};
+exports.mulDown = mulDown;
+const mulUp = (a, b) => {
+    const product = a.times(b);
+    if (product.isZero()) {
+        return product;
+    }
+    else {
+        // The traditional divUp formula is:
+        // divUp(x, y) := (x + y - 1) / y
+        // To avoid intermediate overflow in the addition, we distribute the division and get:
+        // divUp(x, y) := (x - 1) / y + 1
+        // Note that this requires x != 0, which we already tested for
+        return product.minus(new bignumber_js_1.default(1)).idiv(exports.ONE).plus(new bignumber_js_1.default(1));
+    }
+};
+exports.mulUp = mulUp;
+const divDown = (a, b) => {
+    if (b.isZero())
+        throw new Error("ZERO_DIVISION");
+    if (a.isZero())
+        return a;
+    else
+        return a.times(exports.ONE).idiv(b);
+};
+exports.divDown = divDown;
+const divUp = (a, b) => {
+    if (b.isZero())
+        throw new Error("ZERO_DIVISION");
+    if (a.isZero())
+        return a;
+    else {
+        // The traditional divUp formula is:
+        // divUp(x, y) := (x + y - 1) / y
+        // To avoid intermediate overflow in the addition, we distribute the division and get:
+        // divUp(x, y) := (x - 1) / y + 1
+        // Note that this requires x != 0, which we already tested for.
+        return a.times(exports.ONE).minus(new bignumber_js_1.default(1)).idiv(b).plus(new bignumber_js_1.default(1));
+    }
+};
+exports.divUp = divUp;
+const powDown = (x, y) => {
+    const raw = logExp.pow(x, y);
+    const maxError = (0, exports.add)((0, exports.mulUp)(raw, exports.MAX_POW_RELATIVE_ERROR), new bignumber_js_1.default(1));
+    if (raw.lt(maxError))
+        return new bignumber_js_1.default(0);
+    else {
+        return (0, exports.sub)(raw, maxError);
+    }
+};
+exports.powDown = powDown;
+const powUp = (x, y) => {
+    const raw = logExp.pow(x, y);
+    const maxError = (0, exports.add)((0, exports.mulUp)(raw, exports.MAX_POW_RELATIVE_ERROR), new bignumber_js_1.default(1));
+    return (0, exports.add)(raw, maxError);
+};
+exports.powUp = powUp;
+const complement = (x) => {
+    return x.lt(exports.ONE) ? exports.ONE.minus(x) : new bignumber_js_1.default(0);
+};
+exports.complement = complement;

package/dist/utils/math/log-exp.d.ts

@@ -0,0 +1,5 @@
+import BigNumber from "bignumber.js";
+export declare const pow: (x: BigNumber, y: BigNumber) => BigNumber;
+export declare const exp: (x: BigNumber) => BigNumber;
+export declare const log: (arg: BigNumber, base: BigNumber) => BigNumber;
+export declare const ln: (a: BigNumber) => BigNumber;