@marko00/routing-finder-mare 1.0.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@marko00/routing-finder-mare",
+  "version": "1.0.0",
+  "private": false,
+  "type": "commonjs",
+  "dependencies": {
+    "@graphql-typed-document-node/core": "^3.2.0",
+    "@uniswap/sdk-core": "^4.0.6",
+    "@uniswap/v3-sdk": "^3.10.0",
+    "bignumber.js": "^9.1.2",
+    "crypto": "^1.0.1",
+    "ethers": "^6.7.0",
+    "graphql": "^16.7.1",
+    "graphql-request": "^6.1.0",
+    "js-sha256": "^0.10.1",
+    "mnemonist": "^0.39.5",
+    "object-hash": "^3.0.0",
+    "path": "^0.12.7",
+    "ratex-sdk": "^2.0.1",
+    "sha.js": "^2.4.11",
+    "sha256": "^0.2.0",
+    "ts-node": "^10.9.1",
+    "tstl": "^2.5.13",
+    "web3": "^4.11.1"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/object-hash": "^3.0.6",
+    "@types/web3": "^1.2.2",
+    "typescript": "^5.5.4"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}

package/routes.ts

@@ -0,0 +1,27 @@
+import {RateX, Dexes} from "./index";
+
+async function main() {
+    const rateX = new RateX({
+        rpcUrl: "https://tiniest-cold-general.sei-pacific.quiknode.pro/dfa7ceb1fbe6d4fdbce164d5e52201488999dd15",
+        chainId: 1329,
+        dexes: [Dexes.UNISWAP_V2, Dexes.UNISWAP_V3],
+        graphApiKey: "",
+    });
+
+    const tokenIn  = "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7"; // real Sei token
+    const tokenOut = "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392"; // real Sei token
+    const amountIn = BigInt("1000000000000000000");
+    const quote = await rateX.getQuote(tokenIn, tokenOut, amountIn);
+
+    const swapParams = await rateX.getSwapParameters(
+        tokenIn,
+        tokenOut,
+        amountIn,
+        1, // 1% slippage
+        "0xEC744EA7c6792c2D78abdd3E1B1254fdCd32E6fe",
+        30 // 30 minutes deadline
+    );
+    console.log("Swap parameters:", swapParams);
+}
+
+main().catch(console.error);

package/routing/iterative_spliting/main.ts

@@ -0,0 +1,131 @@
+import { myLocalStorage } from "../../swap/my_local_storage";
+import { Quote, Route, Pool, PoolInfo } from "../../utils/types/types";
+import { createGraph, multiHopSwap } from "./multiHopSwap";
+
+// Simple route key - just concatenate pool IDs (much faster than object-hash)
+function getRouteKey(swaps: { poolId: string }[]): string {
+    return swaps.map(s => s.poolId).join('→');
+}
+
+// Graph cache for performance optimization
+interface CachedGraph {
+    graph: Map<string, Pool[]>;
+    poolIds: string; // Hash of pool IDs to detect changes
+    timestamp: number;
+}
+
+let graphCache: CachedGraph | null = null;
+const GRAPH_CACHE_TTL_MS = 2000; // 2 second cache
+
+function getPoolsHash(pools: Pool[]): string {
+    return pools.map(p => p.poolId).sort().join(',');
+}
+
+function getCachedGraph(pools: Pool[]): Map<string, Pool[]> {
+    const poolsHash = getPoolsHash(pools);
+    const now = Date.now();
+
+    // Return cached graph if valid
+    if (graphCache &&
+        graphCache.poolIds === poolsHash &&
+        now - graphCache.timestamp < GRAPH_CACHE_TTL_MS) {
+        return graphCache.graph;
+    }
+
+    // Create new graph and cache it
+    const graph = createGraph(pools);
+    graphCache = {
+        graph,
+        poolIds: poolsHash,
+        timestamp: now
+    };
+
+    return graph;
+}
+
+/*  Simple algorithm that splits the input amount into (100/step) parts of step% each and finds the best route for each split.
+    The algorithm to find the best route for each iteration finds the route with the highest output amount.
+    (code is seen in ./multiHopSwap.ts)
+    After each iteration, the pools are updated with the amounts that passed through them.
+*/
+async function findRouteWithIterativeSplitting(tokenA: string, tokenB: string, amountIn: bigint, pools: Pool[], chainId: number): Promise<Quote> {
+    const graph = getCachedGraph(pools)
+
+    // percentage of the amountIn that we split into (5% = 20 iterations, faster than 2% = 50 iterations)
+    const step: number = 5
+
+    let amountOut: bigint = BigInt(0)
+    const poolMap: Map<string, Pool> = new Map<string, Pool>(pools.map((pool: Pool) => [pool.poolId, pool]))
+    const routes: Map<string, Route> = new Map<string, Route>()
+    const splitAmountIn: bigint = (amountIn * BigInt(step)) / BigInt(100)
+
+    for (let i = 0; i < 100; i += step) {
+        const route: Route = multiHopSwap(splitAmountIn, tokenA, tokenB, graph)
+        const routeHash = getRouteKey(route.swaps)
+
+        let existingRoute: Route | undefined = routes.get(routeHash)
+        if (!existingRoute) {
+            route.percentage = step
+            routes.set(routeHash, route)
+        } else {
+            existingRoute.percentage += step
+        }
+
+        amountOut += route.quote
+        updatePoolsInRoute(poolMap, route, splitAmountIn)
+    }
+
+    const foundRoutes: Route[] = [];
+
+    for (let route of routes.values()) {
+        route.amountIn = (BigInt(route.percentage) * amountIn) / BigInt(100);
+        foundRoutes.push(route);
+    }
+    const missingAmount = amountIn - foundRoutes.reduce((acc, route) => acc + route.amountIn, BigInt(0));
+    foundRoutes[0].amountIn += missingAmount;
+
+    const quote: Quote = { routes: foundRoutes, quote: amountOut };
+
+
+
+    let total = BigInt(0);
+    const resetPools = new Set<string>()
+    for (const route of quote.routes) {
+        let progress = route.amountIn;
+        for (const swap of route.swaps) {
+            const pool = myLocalStorage.getItem(swap.poolId.toLowerCase());
+            if (!pool)
+                throw Error("Error caching pools");
+            if (!resetPools.has(swap.poolId.toLowerCase())) {
+                pool.reset();
+                resetPools.add(swap.poolId.toLowerCase());
+            }
+            const amount = pool.calculateExpectedOutputAmount(swap.tokenIn, swap.tokenOut, progress)
+            pool.update(swap.tokenIn, swap.tokenOut, progress, amount);
+            progress = amount;
+        }
+        route.quote = progress;
+        total += progress;
+    }
+    quote.quote = total;
+    if (quote.routes[0].swaps.length == 0)
+        quote.quote = BigInt(0)
+    return quote;
+}
+
+// Function to update all the pools in a route with the amounts that passed through them
+function updatePoolsInRoute(poolMap: Map<string, Pool>, route: Route, amountIn: bigint): void {
+    for (let swap of route.swaps) {
+        const pool: Pool | undefined = poolMap.get(swap.poolId)
+        if (!pool) {
+            console.log('Pool ', swap.poolId, " doesn't exist!")
+            continue
+        }
+
+        const amountOut: bigint = pool.calculateExpectedOutputAmount(swap.tokenIn, swap.tokenOut, amountIn)
+        pool.update(swap.tokenIn, swap.tokenOut, amountIn, amountOut)
+        amountIn = amountOut
+    }
+}
+
+export { findRouteWithIterativeSplitting }

package/routing/iterative_spliting/multiHopSwap.ts

@@ -0,0 +1,98 @@
+import {Route, SwapStep, Pool, Token} from '../../utils/types/types'
+
+type DpInfo = {
+  amountOut: bigint
+  path: string[]
+  swaps: SwapStep[]
+}
+
+const max_hops = 4
+
+/*  The algorithm to find the best route for each iteration (highest output amount) is seen below.
+*   It is based on dynamic programming.
+*   @param amountIn: The amount of tokenIn that we want to swap (in wei)
+*   @param tokenIn: The address of the token we want to swap (address on Arbitrum)
+*   @param tokenOut: The address of the token we want to receive (address on Arbitrum)
+*   @param graph: The graph of all the fetched pools
+*/
+function multiHopSwap(amountIn: bigint, tokenIn: string, tokenOut: string, graph: Map<string, Pool[]>): Route {
+  tokenIn = tokenIn.toLowerCase()
+  tokenOut = tokenOut.toLowerCase()
+
+  // dp[hop][token]
+  const dp: Map<number, Map<string, DpInfo>> = new Map<number, Map<string, DpInfo>>()
+  dp.set(0, new Map<string, DpInfo>())
+  dp.get(0)?.set(tokenIn, { amountOut: amountIn, path: [tokenIn], swaps: [] })
+
+  const res: DpInfo = { amountOut: BigInt(-1), path: [], swaps: [] }
+
+  for (let hop = 0; hop < max_hops - 1; hop++) {
+    dp.get(hop)?.forEach((dpInfo: DpInfo, tokenA: string) => {
+      graph.get(tokenA)?.forEach((pool: Pool) => {
+        pool.tokens.forEach((tokenB: Token) => {
+          if (dpInfo.path.includes(tokenB._address)) {
+            return
+          }
+
+          // console.log(hop, pool.poolId, tokenA, tokenB._address, dpInfo.amountOut)
+          const amountOut: bigint = pool.calculateExpectedOutputAmount(tokenA, tokenB._address, dpInfo.amountOut)
+          if (amountOut <= 0) {
+            return
+          }
+
+          const newPath: string[] = [...dpInfo.path, tokenB._address]
+          const currSwap: SwapStep = { poolId: pool.poolId, dexId: pool.dexId, tokenIn: tokenA, tokenOut: tokenB._address }
+          const newSwaps: SwapStep[] = [...dpInfo.swaps, currSwap]
+
+          if (!dp.has(hop + 1)) {
+            dp.set(hop + 1, new Map<string, DpInfo>())
+          }
+
+          const dpEntry = dp.get(hop + 1)
+
+          if (!dpEntry?.has(tokenB._address)) {
+            dp.get(hop + 1)?.set(tokenB._address, { amountOut: amountOut, path: newPath, swaps: newSwaps })
+          } else if (amountOut > (dpEntry?.get(tokenB._address)?.amountOut || 0)) {
+            dp.get(hop + 1)?.set(tokenB._address, { amountOut: amountOut, path: newPath, swaps: newSwaps })
+          }
+        })
+      })
+    })
+
+    if (dp.get(hop + 1)?.has(tokenOut) && (dp.get(hop + 1)?.get(tokenOut)?.amountOut || -1) > res.amountOut) {
+      res.amountOut = dp.get(hop + 1)?.get(tokenOut)?.amountOut || BigInt(0)
+      res.path = dp.get(hop + 1)?.get(tokenOut)?.path || []
+      res.swaps = dp.get(hop + 1)?.get(tokenOut)?.swaps || []
+    }
+  }
+
+  return {
+    swaps: res.swaps,
+    quote: res.amountOut,
+    percentage: 0,
+    amountIn: BigInt(0) // will be set in iterative splitting when we know percentage
+  }
+}
+
+/* Function to create a graph from all the fetched pools
+*  Graph maps every token to a list of pools that token is in
+*  @param pools: The fetched pools
+*  @returns The graph
+*/  
+function createGraph(pools: Pool[]): Map<string, Pool[]> {
+  const graph: Map<string, Pool[]> = new Map<string, Pool[]>()
+  for (let pool of pools) {
+    const poolId = pool.poolId
+
+    for (let token of pool.tokens) {
+      if (!graph.has(token._address)) {
+        graph.set(token._address, [])
+      }
+      graph.get(token._address)?.push(pool)
+    }
+  }
+
+  return graph
+}
+
+export { multiHopSwap, createGraph }

package/routing/main.ts

@@ -0,0 +1,22 @@
+import {Quote, Pool} from "../utils/types/types";
+import {findRouteUniLikeAlgo} from "./uni_like_algo/main";
+import {findRouteWithIterativeSplitting} from "./iterative_spliting/main";
+
+/**
+ * This algo works good if we are using pools with two tokens,
+ * but it doesn't scale well for pools with more than two tokens because
+ * amount of routes rapidly increases with number of tokens in pool as there are more ways to go
+ * from token A to token B. This makes algo really slow, especially slow if we include curve dex.
+ * That being said, it will stay here as a reference for future algo ideas and improvements but right
+ * now iterative splitting is way to go.
+ * */
+const UNI_LIKE_ALGO_ACTIVE = false;
+
+export async function findRoute(tokenIn: string, tokenOut: string, amountIn: bigint, pools: Pool[], chainId: number): Promise<Quote> {
+
+    if (UNI_LIKE_ALGO_ACTIVE) {
+        return findRouteUniLikeAlgo(tokenIn, tokenOut, amountIn, pools);
+    } else {
+        return (await findRouteWithIterativeSplitting(tokenIn, tokenOut, amountIn, pools, chainId));
+    }
+}

package/routing/uni_like_algo/algo_config.ts

@@ -0,0 +1,7 @@
+import {AlgoParams} from "./types";
+
+export const algoParams: AlgoParams = {
+    maxHops: 4,
+    distributionPercentage: 2,
+    maxSplit: 8
+};

package/routing/uni_like_algo/amount_distribution.ts

@@ -0,0 +1,16 @@
+import {AmountPercentage} from "./types";
+
+export default function calculateAmountDistribution(amountIn: bigint, distributionPercentage: number): AmountPercentage[] {
+    const percentages: number[] = [];
+    const amounts: bigint[] = [];
+    for (let i = 1; i <= 100 / distributionPercentage; ++i) {
+        percentages.push(distributionPercentage * i);
+        amounts.push(amountIn * BigInt(distributionPercentage * i) / BigInt(100));
+    }
+    return amounts.map((amount, index) => {
+        return {
+            amountIn: amount,
+            percentage: percentages[index]
+        }
+    });
+}

package/routing/uni_like_algo/compute_routes_backtrack.ts

@@ -0,0 +1,81 @@
+import {Pool} from "../../utils/types/types";
+import {ComputeRoutesParams, TRoute, TRouteStep} from "./types";
+
+export default function computeRoutes(
+    tokenIn: string,
+    tokenOut: string,
+    pools: Pool[],
+    maxHops: number
+) {
+    const usedPools = Array<boolean>(pools.length).fill(false);
+    const routes: TRoute[] = [];
+
+    const params = new ComputeRoutesParams(tokenIn, tokenOut, pools, maxHops);
+
+    _computeRoutes(
+        params,
+        [],
+        usedPools,
+        routes,
+        tokenIn
+    );
+
+    return routes;
+}
+
+function _computeRoutes(
+    params: ComputeRoutesParams,
+    currentRoute: TRouteStep[],
+    usedPools: boolean[],
+    foundRoutes: TRoute[],
+    previousTokenOut: string
+) {
+    if (currentRoute.length > params.maxHops) {
+        return;
+    }
+
+    if (routeFound(currentRoute, params)) {
+        foundRoutes.push({
+            steps: [...currentRoute],
+            tokenIn: params.tokenIn,
+            tokenOut: params.tokenOut
+        });
+        return;
+    }
+
+    for (let i = 0; i < params.pools.length; i++) {
+
+        if (usedPools[i]) {
+            continue;
+        }
+
+        const curPool = params.pools[i];
+
+        if (!curPool.containsToken(previousTokenOut)) {
+            continue;
+        }
+
+        const tokensToExplore = curPool.tokens.filter((token) => token._address.toLowerCase() !== previousTokenOut.toLowerCase());
+
+        for (let token of tokensToExplore) {
+            currentRoute.push({pool: curPool, tokenOut: token._address});
+            usedPools[i] = true;
+
+            _computeRoutes(
+                params,
+                currentRoute,
+                usedPools,
+                foundRoutes,
+                token._address
+            );
+
+            usedPools[i] = false;
+            currentRoute.pop();
+        }
+    }
+}
+
+function routeFound(route: TRouteStep[], params: ComputeRoutesParams): boolean {
+    return route.length > 0 && route[route.length - 1].tokenOut.toLowerCase() === params.tokenOut.toLowerCase();
+}
+

package/routing/uni_like_algo/main.ts

@@ -0,0 +1,65 @@
+import {Pool, Quote, Route, SwapStep} from "../../utils/types/types";
+import {TQuoteUniLike, TRoute,} from "./types";
+import computeRoutes from "./compute_routes_backtrack";
+import calculateAmountDistribution from "./amount_distribution";
+import {getRoutesWithQuotes} from "./routes_quoter";
+import {SwapFinder} from "./swap_finder";
+import {algoParams} from "./algo_config";
+
+export function findRouteUniLikeAlgo(
+    tokenIn: string,
+    tokenOut: string,
+    amountIn: bigint,
+    pools: Pool[]
+): Quote {
+
+    const routes: TRoute[] = computeRoutes(tokenIn, tokenOut, pools, algoParams.maxHops);
+    const amounts = calculateAmountDistribution(amountIn, algoParams.distributionPercentage);
+    console.log("Amounts:", amounts);
+    console.log("Amounts size:", amounts.length);
+    console.log("Routes size:", routes.length);
+
+    const routesWithQuotes = getRoutesWithQuotes(routes, amounts);
+
+    const swapFinder = new SwapFinder(
+        algoParams,
+        routesWithQuotes,
+        amounts.map(amount => amount.percentage),
+        amountIn
+    );
+    const quote = swapFinder.findBestRoute();
+    console.log("UniLikeQuote:", quote);
+
+    return convertResponseToFoundQuoteType(quote);
+}
+
+function convertResponseToFoundQuoteType(q: TQuoteUniLike): Quote {
+    const routes = q.routes.map(r => {
+        const route = r.route;
+        let tokenIn = route.tokenIn;
+        let swaps: SwapStep[] = [];
+
+        route.steps.forEach(step => {
+            swaps.push({
+                poolId: step.pool.poolId,
+                dexId: step.pool.dexId,
+                tokenIn: tokenIn,
+                tokenOut: step.tokenOut
+            });
+
+            tokenIn = step.tokenOut;
+        });
+
+        return {
+            swaps: swaps,
+            amountIn: r.amount.amountIn,
+            percentage: r.amount.percentage,
+            quote: r.quote
+        } as Route;
+    });
+
+    return {
+        routes: routes,
+        quote: q.quote
+    };
+}

package/routing/uni_like_algo/routes_quoter.ts

@@ -0,0 +1,63 @@
+import {AmountPercentage, TRoute, TRouteWithQuote} from "./types";
+
+/**
+ * We will calcualte everything offchain. Why?
+ * Because if we want to call for quotes on uni, we will need separate call for each pool.
+ * We can have route that theoretically looks like this:
+ * sushiPool->uniPool->curvePool->uniPool->uniPool->balancerPool->uniPool
+ * Here, we can't batch any calls, because we need amount out from previous pool. There is no other way than
+ * to call for quote on each uni pool separately.
+ * If we have 40 routes, 10 splitted amounts, and 2 uni pool on average per route, we will need 800 rpc calls.
+ *
+ * We can batch it, but that would require to calculate everything on chain. Which is also doable to try if we have time.
+ *
+ * Start with calculating everything offchain, and check final result.
+ * The problem we can have is that for large trades we fetch only +- 15 ticks. Maybe that would be solved if
+ * we split amount on lets say 5% percentage or even 2%. That would be fast because we will have offchain calculation. The only
+ * concert is that we can end up with to many splits for large trade.
+ *
+ * */
+
+export function getRoutesWithQuotes(
+    routes: TRoute[],
+    amounts: AmountPercentage[]
+): TRouteWithQuote[] {
+
+    const routesWithQuotes: TRouteWithQuote[][] = [];
+    routes.forEach(route => {
+        routesWithQuotes.push(getSingleRouteWithAllQuotes(route, amounts));
+    });
+    return routesWithQuotes.flat();
+}
+
+export function getSingleRouteWithAllQuotes(route: TRoute, amounts: AmountPercentage[]): TRouteWithQuote[] {
+    const routes: TRouteWithQuote[] = [];
+
+    amounts.forEach(amount => {
+        routes.push(getSingleRouteWithSingleQuote(route, amount));
+    });
+
+    return routes;
+}
+
+export function getSingleRouteWithSingleQuote(route: TRoute, amount: AmountPercentage): TRouteWithQuote {
+    let tokenIn = route.tokenIn;
+    let amountOut = amount.amountIn;
+
+    for (let step of route.steps) {
+        const tokenOut = step.tokenOut;
+
+        amountOut = step.pool.calculateExpectedOutputAmount(tokenIn, tokenOut, amountOut);
+
+        if (amountOut <= BigInt(0)) {
+            break;
+        }
+
+        tokenIn = tokenOut;
+    }
+    return {
+        route: route,
+        quote: amountOut,
+        amount: amount
+    }
+}