@marko00/routing-finder-mare 1.0.0

package/dist/routing/iterative_spliting/main.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRouteWithIterativeSplitting = findRouteWithIterativeSplitting;
+const my_local_storage_1 = require("../../swap/my_local_storage");
+const multiHopSwap_1 = require("./multiHopSwap");
+// Simple route key - just concatenate pool IDs (much faster than object-hash)
+function getRouteKey(swaps) {
+    return swaps.map(s => s.poolId).join('→');
+}
+let graphCache = null;
+const GRAPH_CACHE_TTL_MS = 2000; // 2 second cache
+function getPoolsHash(pools) {
+    return pools.map(p => p.poolId).sort().join(',');
+}
+function getCachedGraph(pools) {
+    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 = (0, multiHopSwap_1.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, tokenB, amountIn, pools, chainId) {
+    const graph = getCachedGraph(pools);
+    // percentage of the amountIn that we split into (5% = 20 iterations, faster than 2% = 50 iterations)
+    const step = 5;
+    let amountOut = BigInt(0);
+    const poolMap = new Map(pools.map((pool) => [pool.poolId, pool]));
+    const routes = new Map();
+    const splitAmountIn = (amountIn * BigInt(step)) / BigInt(100);
+    for (let i = 0; i < 100; i += step) {
+        const route = (0, multiHopSwap_1.multiHopSwap)(splitAmountIn, tokenA, tokenB, graph);
+        const routeHash = getRouteKey(route.swaps);
+        let existingRoute = 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 = [];
+    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 = { routes: foundRoutes, quote: amountOut };
+    let total = BigInt(0);
+    const resetPools = new Set();
+    for (const route of quote.routes) {
+        let progress = route.amountIn;
+        for (const swap of route.swaps) {
+            const pool = my_local_storage_1.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, route, amountIn) {
+    for (let swap of route.swaps) {
+        const pool = poolMap.get(swap.poolId);
+        if (!pool) {
+            console.log('Pool ', swap.poolId, " doesn't exist!");
+            continue;
+        }
+        const amountOut = pool.calculateExpectedOutputAmount(swap.tokenIn, swap.tokenOut, amountIn);
+        pool.update(swap.tokenIn, swap.tokenOut, amountIn, amountOut);
+        amountIn = amountOut;
+    }
+}

package/dist/routing/iterative_spliting/multiHopSwap.d.ts

@@ -0,0 +1,4 @@
+import { Route, Pool } from '../../utils/types/types';
+declare function multiHopSwap(amountIn: bigint, tokenIn: string, tokenOut: string, graph: Map<string, Pool[]>): Route;
+declare function createGraph(pools: Pool[]): Map<string, Pool[]>;
+export { multiHopSwap, createGraph };

package/dist/routing/iterative_spliting/multiHopSwap.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiHopSwap = multiHopSwap;
+exports.createGraph = createGraph;
+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, tokenIn, tokenOut, graph) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    tokenIn = tokenIn.toLowerCase();
+    tokenOut = tokenOut.toLowerCase();
+    // dp[hop][token]
+    const dp = new Map();
+    dp.set(0, new Map());
+    (_a = dp.get(0)) === null || _a === void 0 ? void 0 : _a.set(tokenIn, { amountOut: amountIn, path: [tokenIn], swaps: [] });
+    const res = { amountOut: BigInt(-1), path: [], swaps: [] };
+    for (let hop = 0; hop < max_hops - 1; hop++) {
+        (_b = dp.get(hop)) === null || _b === void 0 ? void 0 : _b.forEach((dpInfo, tokenA) => {
+            var _a;
+            (_a = graph.get(tokenA)) === null || _a === void 0 ? void 0 : _a.forEach((pool) => {
+                pool.tokens.forEach((tokenB) => {
+                    var _a, _b, _c;
+                    if (dpInfo.path.includes(tokenB._address)) {
+                        return;
+                    }
+                    // console.log(hop, pool.poolId, tokenA, tokenB._address, dpInfo.amountOut)
+                    const amountOut = pool.calculateExpectedOutputAmount(tokenA, tokenB._address, dpInfo.amountOut);
+                    if (amountOut <= 0) {
+                        return;
+                    }
+                    const newPath = [...dpInfo.path, tokenB._address];
+                    const currSwap = { poolId: pool.poolId, dexId: pool.dexId, tokenIn: tokenA, tokenOut: tokenB._address };
+                    const newSwaps = [...dpInfo.swaps, currSwap];
+                    if (!dp.has(hop + 1)) {
+                        dp.set(hop + 1, new Map());
+                    }
+                    const dpEntry = dp.get(hop + 1);
+                    if (!(dpEntry === null || dpEntry === void 0 ? void 0 : dpEntry.has(tokenB._address))) {
+                        (_a = dp.get(hop + 1)) === null || _a === void 0 ? void 0 : _a.set(tokenB._address, { amountOut: amountOut, path: newPath, swaps: newSwaps });
+                    }
+                    else if (amountOut > (((_b = dpEntry === null || dpEntry === void 0 ? void 0 : dpEntry.get(tokenB._address)) === null || _b === void 0 ? void 0 : _b.amountOut) || 0)) {
+                        (_c = dp.get(hop + 1)) === null || _c === void 0 ? void 0 : _c.set(tokenB._address, { amountOut: amountOut, path: newPath, swaps: newSwaps });
+                    }
+                });
+            });
+        });
+        if (((_c = dp.get(hop + 1)) === null || _c === void 0 ? void 0 : _c.has(tokenOut)) && (((_e = (_d = dp.get(hop + 1)) === null || _d === void 0 ? void 0 : _d.get(tokenOut)) === null || _e === void 0 ? void 0 : _e.amountOut) || -1) > res.amountOut) {
+            res.amountOut = ((_g = (_f = dp.get(hop + 1)) === null || _f === void 0 ? void 0 : _f.get(tokenOut)) === null || _g === void 0 ? void 0 : _g.amountOut) || BigInt(0);
+            res.path = ((_j = (_h = dp.get(hop + 1)) === null || _h === void 0 ? void 0 : _h.get(tokenOut)) === null || _j === void 0 ? void 0 : _j.path) || [];
+            res.swaps = ((_l = (_k = dp.get(hop + 1)) === null || _k === void 0 ? void 0 : _k.get(tokenOut)) === null || _l === void 0 ? void 0 : _l.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) {
+    var _a;
+    const graph = new Map();
+    for (let pool of pools) {
+        const poolId = pool.poolId;
+        for (let token of pool.tokens) {
+            if (!graph.has(token._address)) {
+                graph.set(token._address, []);
+            }
+            (_a = graph.get(token._address)) === null || _a === void 0 ? void 0 : _a.push(pool);
+        }
+    }
+    return graph;
+}

package/dist/routing/main.d.ts

@@ -0,0 +1,2 @@
+import { Quote, Pool } from "../utils/types/types";
+export declare function findRoute(tokenIn: string, tokenOut: string, amountIn: bigint, pools: Pool[], chainId: number): Promise<Quote>;

package/dist/routing/main.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRoute = findRoute;
+const main_1 = require("./uni_like_algo/main");
+const main_2 = require("./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;
+async function findRoute(tokenIn, tokenOut, amountIn, pools, chainId) {
+    if (UNI_LIKE_ALGO_ACTIVE) {
+        return (0, main_1.findRouteUniLikeAlgo)(tokenIn, tokenOut, amountIn, pools);
+    }
+    else {
+        return (await (0, main_2.findRouteWithIterativeSplitting)(tokenIn, tokenOut, amountIn, pools, chainId));
+    }
+}

package/dist/routing/uni_like_algo/algo_config.d.ts

@@ -0,0 +1,2 @@
+import { AlgoParams } from "./types";
+export declare const algoParams: AlgoParams;

package/dist/routing/uni_like_algo/algo_config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.algoParams = void 0;
+exports.algoParams = {
+    maxHops: 4,
+    distributionPercentage: 2,
+    maxSplit: 8
+};

package/dist/routing/uni_like_algo/amount_distribution.d.ts

@@ -0,0 +1,2 @@
+import { AmountPercentage } from "./types";
+export default function calculateAmountDistribution(amountIn: bigint, distributionPercentage: number): AmountPercentage[];

package/dist/routing/uni_like_algo/amount_distribution.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = calculateAmountDistribution;
+function calculateAmountDistribution(amountIn, distributionPercentage) {
+    const percentages = [];
+    const amounts = [];
+    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/dist/routing/uni_like_algo/compute_routes_backtrack.d.ts

@@ -0,0 +1,3 @@
+import { Pool } from "../../utils/types/types";
+import { TRoute } from "./types";
+export default function computeRoutes(tokenIn: string, tokenOut: string, pools: Pool[], maxHops: number): TRoute[];

package/dist/routing/uni_like_algo/compute_routes_backtrack.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = computeRoutes;
+const types_1 = require("./types");
+function computeRoutes(tokenIn, tokenOut, pools, maxHops) {
+    const usedPools = Array(pools.length).fill(false);
+    const routes = [];
+    const params = new types_1.ComputeRoutesParams(tokenIn, tokenOut, pools, maxHops);
+    _computeRoutes(params, [], usedPools, routes, tokenIn);
+    return routes;
+}
+function _computeRoutes(params, currentRoute, usedPools, foundRoutes, previousTokenOut) {
+    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, params) {
+    return route.length > 0 && route[route.length - 1].tokenOut.toLowerCase() === params.tokenOut.toLowerCase();
+}

package/dist/routing/uni_like_algo/main.d.ts

@@ -0,0 +1,2 @@
+import { Pool, Quote } from "../../utils/types/types";
+export declare function findRouteUniLikeAlgo(tokenIn: string, tokenOut: string, amountIn: bigint, pools: Pool[]): Quote;

package/dist/routing/uni_like_algo/main.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRouteUniLikeAlgo = findRouteUniLikeAlgo;
+const compute_routes_backtrack_1 = __importDefault(require("./compute_routes_backtrack"));
+const amount_distribution_1 = __importDefault(require("./amount_distribution"));
+const routes_quoter_1 = require("./routes_quoter");
+const swap_finder_1 = require("./swap_finder");
+const algo_config_1 = require("./algo_config");
+function findRouteUniLikeAlgo(tokenIn, tokenOut, amountIn, pools) {
+    const routes = (0, compute_routes_backtrack_1.default)(tokenIn, tokenOut, pools, algo_config_1.algoParams.maxHops);
+    const amounts = (0, amount_distribution_1.default)(amountIn, algo_config_1.algoParams.distributionPercentage);
+    console.log("Amounts:", amounts);
+    console.log("Amounts size:", amounts.length);
+    console.log("Routes size:", routes.length);
+    const routesWithQuotes = (0, routes_quoter_1.getRoutesWithQuotes)(routes, amounts);
+    const swapFinder = new swap_finder_1.SwapFinder(algo_config_1.algoParams, routesWithQuotes, amounts.map(amount => amount.percentage), amountIn);
+    const quote = swapFinder.findBestRoute();
+    console.log("UniLikeQuote:", quote);
+    return convertResponseToFoundQuoteType(quote);
+}
+function convertResponseToFoundQuoteType(q) {
+    const routes = q.routes.map(r => {
+        const route = r.route;
+        let tokenIn = route.tokenIn;
+        let swaps = [];
+        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
+        };
+    });
+    return {
+        routes: routes,
+        quote: q.quote
+    };
+}

package/dist/routing/uni_like_algo/routes_quoter.d.ts

@@ -0,0 +1,21 @@
+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 declare function getRoutesWithQuotes(routes: TRoute[], amounts: AmountPercentage[]): TRouteWithQuote[];
+export declare function getSingleRouteWithAllQuotes(route: TRoute, amounts: AmountPercentage[]): TRouteWithQuote[];
+export declare function getSingleRouteWithSingleQuote(route: TRoute, amount: AmountPercentage): TRouteWithQuote;

package/dist/routing/uni_like_algo/routes_quoter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRoutesWithQuotes = getRoutesWithQuotes;
+exports.getSingleRouteWithAllQuotes = getSingleRouteWithAllQuotes;
+exports.getSingleRouteWithSingleQuote = getSingleRouteWithSingleQuote;
+/**
+ * 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.
+ *
+ * */
+function getRoutesWithQuotes(routes, amounts) {
+    const routesWithQuotes = [];
+    routes.forEach(route => {
+        routesWithQuotes.push(getSingleRouteWithAllQuotes(route, amounts));
+    });
+    return routesWithQuotes.flat();
+}
+function getSingleRouteWithAllQuotes(route, amounts) {
+    const routes = [];
+    amounts.forEach(amount => {
+        routes.push(getSingleRouteWithSingleQuote(route, amount));
+    });
+    return routes;
+}
+function getSingleRouteWithSingleQuote(route, amount) {
+    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
+    };
+}

package/dist/routing/uni_like_algo/swap_finder.d.ts

@@ -0,0 +1,25 @@
+import { AlgoParams, TQuoteUniLike, TRouteWithQuote } from "./types";
+export declare class SwapFinder {
+    private algoParams;
+    private percentagesToSortedQuotes;
+    private percentages;
+    private amountIn;
+    private bestQuote;
+    private bestSwap;
+    private queue;
+    private numOfSplits;
+    constructor(algoParams: AlgoParams, routesWithQuotes: TRouteWithQuote[], percentages: number[], amountIn: bigint);
+    private readyToFinishSplitting;
+    findBestRoute(): TQuoteUniLike;
+    private addMissingAmountIn;
+    private processLayer;
+    private processPairedItemsInLayer;
+    private processPairedItem;
+    private updateBestQuoteAndSwapIfBetter;
+    private initBestQuoteAndSwapForFullAmount;
+    private initQueueWithHighestQuotes;
+    private insertHigestQuoteForPercentageIfExist;
+    private insertSecondHigestQuoteForPercentageIfExist;
+    private getSortedQuotes;
+    private findFirstRouteNotUsingUsedPools;
+}

package/dist/routing/uni_like_algo/swap_finder.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapFinder = void 0;
+const queue_1 = __importDefault(require("mnemonist/queue"));
+class SwapFinder {
+    constructor(algoParams, routesWithQuotes, percentages, amountIn) {
+        this.algoParams = algoParams;
+        this.percentages = percentages;
+        this.amountIn = amountIn;
+        this.percentagesToSortedQuotes = this.getSortedQuotes(routesWithQuotes);
+        this.bestQuote = BigInt(0);
+        this.bestSwap = [];
+        this.queue = new queue_1.default();
+        this.numOfSplits = 1;
+    }
+    readyToFinishSplitting() {
+        const maxSplitsReached = this.numOfSplits > this.algoParams.maxSplit;
+        const bestSwapNotImprovedWithNewSplit = this.numOfSplits >= 3 && (this.bestSwap.length < this.numOfSplits - 1);
+        return maxSplitsReached || bestSwapNotImprovedWithNewSplit;
+    }
+    findBestRoute() {
+        this.initBestQuoteAndSwapForFullAmount();
+        this.initQueueWithHighestQuotes();
+        while (this.queue.size > 0) {
+            let layer = this.queue.size;
+            this.numOfSplits++;
+            if (this.readyToFinishSplitting()) {
+                break;
+            }
+            this.processLayer(layer);
+        }
+        this.addMissingAmountIn();
+        return {
+            quote: this.bestQuote,
+            routes: this.bestSwap
+        };
+    }
+    addMissingAmountIn() {
+        const totalAmountIn = this.bestSwap.reduce((acc, route) => acc + route.amount.amountIn, BigInt(0));
+        const diff = this.amountIn - totalAmountIn;
+        if (diff > BigInt(0)) {
+            this.bestSwap[this.bestSwap.length - 1].amount.amountIn += diff;
+        }
+    }
+    processLayer(layer) {
+        while (layer > 0) {
+            layer--;
+            const q = this.queue.dequeue();
+            this.processPairedItemsInLayer(q);
+        }
+    }
+    processPairedItemsInLayer(q) {
+        for (let i = q.percentageIndex; i >= 0; --i) {
+            const percentage = this.percentages[i];
+            if (percentage > q.ramainingPercentage || !this.percentagesToSortedQuotes.has(percentage)) {
+                continue;
+            }
+            this.processPairedItem(q, percentage, i);
+        }
+    }
+    processPairedItem(q, percentage, index) {
+        const candidateRoutes = this.percentagesToSortedQuotes.get(percentage);
+        const routeWithQuote = this.findFirstRouteNotUsingUsedPools(q.currentRoutes, candidateRoutes);
+        if (!routeWithQuote) {
+            return;
+        }
+        const newRemainingPercentage = q.ramainingPercentage - percentage;
+        const newCurrentRoutes = [...q.currentRoutes, routeWithQuote];
+        if (newRemainingPercentage === 0) {
+            this.updateBestQuoteAndSwapIfBetter(newCurrentRoutes);
+        }
+        else {
+            this.queue.enqueue({
+                percentageIndex: index,
+                currentRoutes: newCurrentRoutes,
+                ramainingPercentage: newRemainingPercentage
+            });
+        }
+    }
+    updateBestQuoteAndSwapIfBetter(currentRoutes) {
+        const quote = currentRoutes.reduce((acc, route) => acc + route.quote, BigInt(0));
+        if (quote > this.bestQuote) {
+            this.bestQuote = quote;
+            this.bestSwap = currentRoutes;
+        }
+    }
+    initBestQuoteAndSwapForFullAmount() {
+        if (this.percentagesToSortedQuotes.has(100)) {
+            this.bestQuote = this.percentagesToSortedQuotes.get(100)[0].quote;
+            this.bestSwap = [this.percentagesToSortedQuotes.get(100)[0]];
+        }
+    }
+    initQueueWithHighestQuotes() {
+        for (let i = this.percentages.length - 1; i >= 0; --i) {
+            this.insertHigestQuoteForPercentageIfExist(i);
+            this.insertSecondHigestQuoteForPercentageIfExist(i);
+        }
+    }
+    insertHigestQuoteForPercentageIfExist(percentageIndex) {
+        const percentage = this.percentages[percentageIndex];
+        if (this.percentagesToSortedQuotes.has(percentage)) {
+            this.queue.enqueue({
+                percentageIndex: percentageIndex,
+                currentRoutes: [this.percentagesToSortedQuotes.get(percentage)[0]],
+                ramainingPercentage: 100 - percentage
+            });
+        }
+    }
+    insertSecondHigestQuoteForPercentageIfExist(percentageIndex) {
+        const percentage = this.percentages[percentageIndex];
+        if (this.percentagesToSortedQuotes.get(percentage)[1]) {
+            this.queue.enqueue({
+                percentageIndex: percentageIndex,
+                currentRoutes: [this.percentagesToSortedQuotes.get(percentage)[1]],
+                ramainingPercentage: 100 - percentage
+            });
+        }
+    }
+    getSortedQuotes(routeWithQuotes) {
+        const map = new Map();
+        routeWithQuotes.forEach(routeWithQuote => {
+            var _a;
+            const percentage = routeWithQuote.amount.percentage;
+            if (!map.has(percentage)) {
+                map.set(percentage, []);
+            }
+            (_a = map.get(percentage)) === null || _a === void 0 ? void 0 : _a.push(routeWithQuote);
+        });
+        map.forEach((value, key) => {
+            value.sort((a, b) => {
+                return Number(b.quote - a.quote);
+            });
+        });
+        return map;
+    }
+    findFirstRouteNotUsingUsedPools(usedRoutes, candidateRoutes) {
+        const usedPoolsSet = new Set();
+        usedRoutes.forEach(route => {
+            route.route.steps.forEach(step => usedPoolsSet.add(step.pool.poolId));
+        });
+        for (const candidateRoute of candidateRoutes) {
+            const candidatePools = candidateRoute.route.steps.map(step => step.pool.poolId);
+            if (candidatePools.some(pool => usedPoolsSet.has(pool))) {
+                continue;
+            }
+            return candidateRoute;
+        }
+        return null;
+    }
+}
+exports.SwapFinder = SwapFinder;

package/dist/routing/uni_like_algo/types.d.ts

@@ -0,0 +1,40 @@
+import { Pool } from "../../utils/types/types";
+export interface TRouteStep {
+    pool: Pool;
+    tokenOut: string;
+}
+export interface TRoute {
+    steps: TRouteStep[];
+    tokenIn: string;
+    tokenOut: string;
+}
+export interface TRouteWithQuote {
+    route: TRoute;
+    quote: bigint;
+    amount: AmountPercentage;
+}
+export interface AmountPercentage {
+    amountIn: bigint;
+    percentage: number;
+}
+export declare class ComputeRoutesParams {
+    tokenIn: string;
+    tokenOut: string;
+    pools: Pool[];
+    maxHops: number;
+    constructor(tokenIn: string, tokenOut: string, pools: Pool[], maxHops: number);
+}
+export interface QueueItem {
+    percentageIndex: number;
+    currentRoutes: TRouteWithQuote[];
+    ramainingPercentage: number;
+}
+export interface TQuoteUniLike {
+    routes: TRouteWithQuote[];
+    quote: bigint;
+}
+export type AlgoParams = {
+    maxHops: number;
+    distributionPercentage: number;
+    maxSplit: number;
+};

package/dist/routing/uni_like_algo/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComputeRoutesParams = void 0;
+class ComputeRoutesParams {
+    constructor(tokenIn, tokenOut, pools, maxHops) {
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+        this.pools = pools;
+        this.maxHops = maxHops;
+    }
+}
+exports.ComputeRoutesParams = ComputeRoutesParams;