@curvefi/api 2.47.4 → 2.48.0

package/README.md

@@ -1753,7 +1753,9 @@ import curve from "@curvefi/api";
     const gaugeSidechainAddress = await curve.factory.getDeployedGaugeAddress(deployGaugeSidechain);
     // 0x60d3d7ebbc44dc810a743703184f062d00e6db7e
     //After that should be deployed mirror gauge on mainnet with same salt
-    //await curve.tricryptoFactory.deployGaugeMirror(sidechainId, salt);
+    //const gaugeMirrorTx = await curve.tricryptoFactory.deployGaugeMirror(sidechainId, salt);
+    //const deployedGaugeMirrorAddress = await curve.tricryptoFactory.getDeployedGaugeMirrorAddressByTx(gaugeMirrorTx);
+    //OR
     //const deployedGaugeMirrorAddress = await curve.tricryptoFactory.getDeployedGaugeMirrorAddress(sidechainId);
     
     // Deposit & Stake

package/lib/factory/deploy.d.ts

@@ -21,4 +21,5 @@ export declare const deployGaugeSidechain: (pool: string, salt: string) => Promi
 export declare const deployGaugeMirrorEstimateGas: (chainId: number, salt: string) => Promise<number>;
 export declare const deployGaugeMirror: (chainId: number, salt: string) => Promise<ethers.ContractTransactionResponse>;
 export declare const getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+export declare const getDeployedGaugeMirrorAddressByTx: (tx: ethers.ContractTransactionResponse) => Promise<string>;
 export declare const getDeployedGaugeMirrorAddress: (chainId: number) => Promise<string>;

package/lib/factory/deploy.js

@@ -645,6 +645,23 @@ export var getDeployedGaugeAddress = function (tx) { return __awaiter(void 0, vo
         }
     });
 }); };
+export var getDeployedGaugeMirrorAddressByTx = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
+    var txInfo;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId !== 1)
+                    throw Error("There is no getDeployedGaugeMirrorAddressByTx method on sidechain network");
+                return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                if (!txInfo)
+                    throw Error("Can't get tx info");
+                // @ts-ignore
+                return [2 /*return*/, txInfo.logs[1].args[txInfo.logs[1].args.length - 1].toLowerCase()];
+        }
+    });
+}); };
 export var getDeployedGaugeMirrorAddress = function (chainId) { return __awaiter(void 0, void 0, void 0, function () {
     var contract, gaugeCount, currentIndex;
     return __generator(this, function (_a) {

package/lib/index.d.ts

@@ -71,6 +71,7 @@ declare const curve: {
         getDeployedMetaPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeMirrorAddress: (chainId: number) => Promise<string>;
+        getDeployedGaugeMirrorAddressByTx: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         gaugeImplementation: () => string;
         estimateGas: {
@@ -101,6 +102,7 @@ declare const curve: {
         getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeMirrorAddress: (chainId: number) => Promise<string>;
+        getDeployedGaugeMirrorAddressByTx: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         gaugeImplementation: () => string;
         estimateGas: {
@@ -121,6 +123,7 @@ declare const curve: {
         getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeMirrorAddress: (chainId: number) => Promise<string>;
+        getDeployedGaugeMirrorAddressByTx: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         gaugeImplementation: () => string;
         estimateGas: {

package/lib/index.js

@@ -40,7 +40,7 @@ import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceIm
 import { curve as _curve } from "./curve.js";
 import { getCrv, getLockedAmountAndUnlockTime, getVeCrv, getVeCrvPct, calcUnlockTime, createLockEstimateGas, createLock, isApproved, approveEstimateGas, approve, increaseAmountEstimateGas, increaseAmount, increaseUnlockTimeEstimateGas, increaseUnlockTime, withdrawLockedCrvEstimateGas, withdrawLockedCrv, claimableFees, claimFeesEstimateGas, claimFees, lastEthBlock, getAnycallBalance, topUpAnycall, topUpAnycallEstimateGas, lastBlockSent, blockToSend, sendBlockhash, sendBlockhashEstimateGas, submitProof, submitProofEstimateGas, } from "./boosting.js";
 import { getBalances, getAllowance, hasAllowance, ensureAllowanceEstimateGas, ensureAllowance, getUsdRate, getTVL, getCoinsData, getVolume, hasDepositAndStake, hasRouter, } from "./utils.js";
-import { deployStablePlainPool, deployStablePlainPoolEstimateGas, getDeployedStablePlainPoolAddress, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, getDeployedStableMetaPoolAddress, deployCryptoPool, deployCryptoPoolEstimateGas, getDeployedCryptoPoolAddress, deployTricryptoPool, deployTricryptoPoolEstimateGas, getDeployedTricryptoPoolAddress, deployGauge, deployGaugeEstimateGas, getDeployedGaugeAddress, deployGaugeSidechain, deployGaugeSidechainEstimateGas, deployGaugeMirror, deployGaugeMirrorEstimateGas, getDeployedGaugeMirrorAddress, } from './factory/deploy.js';
+import { deployStablePlainPool, deployStablePlainPoolEstimateGas, getDeployedStablePlainPoolAddress, setOracle, setOracleEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, getDeployedStableMetaPoolAddress, deployCryptoPool, deployCryptoPoolEstimateGas, getDeployedCryptoPoolAddress, deployTricryptoPool, deployTricryptoPoolEstimateGas, getDeployedTricryptoPoolAddress, deployGauge, deployGaugeEstimateGas, getDeployedGaugeAddress, deployGaugeSidechain, deployGaugeSidechainEstimateGas, deployGaugeMirror, deployGaugeMirrorEstimateGas, getDeployedGaugeMirrorAddress, getDeployedGaugeMirrorAddressByTx, } from './factory/deploy.js';
 function init(providerType, providerSettings, options) {
     if (options === void 0) { options = {}; }
     return __awaiter(this, void 0, void 0, function () {
@@ -105,6 +105,7 @@ var curve = {
         getDeployedMetaPoolAddress: getDeployedStableMetaPoolAddress,
         getDeployedGaugeAddress: getDeployedGaugeAddress,
         getDeployedGaugeMirrorAddress: getDeployedGaugeMirrorAddress,
+        getDeployedGaugeMirrorAddressByTx: getDeployedGaugeMirrorAddressByTx,
         fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedFactoryPool,
         gaugeImplementation: function () { return _curve.getGaugeImplementation("factory"); },
         estimateGas: {
@@ -147,6 +148,7 @@ var curve = {
         getDeployedPoolAddress: getDeployedCryptoPoolAddress,
         getDeployedGaugeAddress: getDeployedGaugeAddress,
         getDeployedGaugeMirrorAddress: getDeployedGaugeMirrorAddress,
+        getDeployedGaugeMirrorAddressByTx: getDeployedGaugeMirrorAddressByTx,
         fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedCryptoFactoryPool,
         gaugeImplementation: function () { return _curve.getGaugeImplementation("factory-crypto"); },
         estimateGas: {
@@ -179,6 +181,7 @@ var curve = {
         getDeployedPoolAddress: getDeployedTricryptoPoolAddress,
         getDeployedGaugeAddress: getDeployedGaugeAddress,
         getDeployedGaugeMirrorAddress: getDeployedGaugeMirrorAddress,
+        getDeployedGaugeMirrorAddressByTx: getDeployedGaugeMirrorAddressByTx,
         fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedTricryptoFactoryPool,
         gaugeImplementation: function () { return _curve.getGaugeImplementation("factory-tricrypto"); },
         estimateGas: {

package/lib/interfaces.d.ts

@@ -150,6 +150,7 @@ export interface IRouteStep {
     baseToken: string;
     secondBasePool: string;
     secondBaseToken: string;
+    tvl: number;
 }
 export type IRoute = IRouteStep[];
 export interface IRouteTvl {

package/lib/pools/utils.js

@@ -489,7 +489,7 @@ export var _getAmplificationCoefficientsFromApi = function () { return __awaiter
                     extendedPoolData = allTypesExtendedPoolData_1[_i];
                     for (_a = 0, _b = extendedPoolData.poolData; _a < _b.length; _a++) {
                         pool = _b[_a];
-                        amplificationCoefficientDict[pool.address] = Number(pool.amplificationCoefficient);
+                        amplificationCoefficientDict[pool.address.toLowerCase()] = Number(pool.amplificationCoefficient);
                     }
                 }
                 return [2 /*return*/, amplificationCoefficientDict];

package/lib/router.js

@@ -63,59 +63,16 @@ import { getPool } from "./pools/index.js";
 import { _getAmplificationCoefficientsFromApi } from "./pools/utils.js";
 var MAX_STEPS = 5;
 var ROUTE_LENGTH = (MAX_STEPS * 2) + 1;
-// 4 --> 6, 5 --> 7 not allowed
-// 4 --> 7, 5 --> 6 allowed
-var _handleSwapType = function (swapType) {
-    if (swapType === 6)
-        return "4";
-    if (swapType === 7)
-        return "5";
-    return swapType.toString();
-};
-var _getNewRoute = function (routeTvl, poolId, swapAddress, inputCoinAddress, outputCoinAddress, swapParams, // i, j, swap_type, pool_type, n_coins
-poolAddress, basePool, baseToken, secondBasePool, secondBaseToken, tvl) {
-    var routePoolIdsPlusSwapType = routeTvl.route.map(function (s) { return s.poolId + "+" + _handleSwapType(s.swapParams[2]); });
-    // Steps <= MAX_STEPS
-    if (routePoolIdsPlusSwapType.length >= MAX_STEPS)
-        return { route: [], minTvl: Infinity, totalTvl: 0 };
-    // Exclude such cases as cvxeth -> tricrypto2 -> tricrypto2 -> susd
-    if (routePoolIdsPlusSwapType.includes(poolId + "+" + _handleSwapType(swapParams[2])))
-        return { route: [], minTvl: Infinity, totalTvl: 0 };
-    return {
-        route: __spreadArray(__spreadArray([], routeTvl.route, true), [
-            { poolId: poolId, swapAddress: swapAddress, inputCoinAddress: inputCoinAddress, outputCoinAddress: outputCoinAddress, swapParams: swapParams, poolAddress: poolAddress, basePool: basePool, baseToken: baseToken, secondBasePool: secondBasePool, secondBaseToken: secondBaseToken },
-        ], false),
-        minTvl: Math.min(tvl, routeTvl.minTvl),
-        totalTvl: routeTvl.totalTvl + tvl,
-    };
-};
-var MAX_ROUTES_FOR_ONE_COIN = 3;
-var _filterRoutes = function (routes, inputCoinAddress, sortFn) {
-    return routes
-        .filter(function (r) { return r.route.length > 0; })
-        .filter(function (r) { return r.route[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
-        .filter(function (r, i, _routes) {
+var GRAPH_MAX_EDGES = 3;
+var MAX_ROUTES_FOR_ONE_COIN = 5;
+var _removeDuplications = function (routes) {
+    return routes.filter(function (r, i, _routes) {
         var routesByPoolIds = _routes.map(function (r) { return r.route.map(function (s) { return s.poolId; }).toString(); });
         return routesByPoolIds.indexOf(r.route.map(function (s) { return s.poolId; }).toString()) === i;
-    }) // Route duplications
-        .sort(sortFn).slice(0, MAX_ROUTES_FOR_ONE_COIN);
+    });
 };
 var _sortByTvl = function (a, b) { return b.minTvl - a.minTvl || b.totalTvl - a.totalTvl || a.route.length - b.route.length; };
 var _sortByLength = function (a, b) { return a.route.length - b.route.length || b.minTvl - a.minTvl || b.totalTvl - a.totalTvl; };
-var _updateRoutes = function (inputCoinAddress, routesByTvl, routesByLength, poolId, swapAddress, inCoin, outCoin, swapParams, // i, j, swap_type, pool_type, n_coins
-poolAddress, basePool, baseToken, secondBasePool, secondBaseToken, tvl) {
-    var _a, _b;
-    var newRoutesByTvl = routesByTvl[inCoin].map(function (route) {
-        return _getNewRoute(route, poolId, swapAddress, inCoin, outCoin, swapParams, poolAddress, basePool, baseToken, secondBasePool, secondBaseToken, tvl);
-    });
-    var newRoutesByLength = routesByLength[inCoin].map(function (route) {
-        return _getNewRoute(route, poolId, swapAddress, inCoin, outCoin, swapParams, poolAddress, basePool, baseToken, secondBasePool, secondBaseToken, tvl);
-    });
-    routesByTvl[outCoin] = __spreadArray(__spreadArray([], ((_a = routesByTvl[outCoin]) !== null && _a !== void 0 ? _a : []), true), newRoutesByTvl, true);
-    routesByTvl[outCoin] = _filterRoutes(routesByTvl[outCoin], inputCoinAddress, _sortByTvl);
-    routesByLength[outCoin] = __spreadArray(__spreadArray([], ((_b = routesByLength[outCoin]) !== null && _b !== void 0 ? _b : []), true), newRoutesByLength, true);
-    routesByLength[outCoin] = _filterRoutes(routesByLength[outCoin], inputCoinAddress, _sortByLength);
-};
 var _getTVL = memoize(function (poolId) { return __awaiter(void 0, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
     switch (_b.label) {
         case 0:
@@ -127,6 +84,15 @@ var _getTVL = memoize(function (poolId) { return __awaiter(void 0, void 0, void
     promise: true,
     maxAge: 5 * 60 * 1000, // 5m
 });
+// 4 --> 6, 5 --> 7 not allowed
+// 4 --> 7, 5 --> 6 allowed
+var _handleSwapType = function (swapType) {
+    if (swapType === 6)
+        return "4";
+    if (swapType === 7)
+        return "5";
+    return swapType.toString();
+};
 var SNX = {
     1: {
         swap: "0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F".toLowerCase(),
@@ -147,226 +113,384 @@ var SNX = {
         ].map(function (a) { return a.toLowerCase(); }),
     },
 };
-// Inspired by Dijkstra's algorithm
-var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
-    var ALL_POOLS, amplificationCoefficientDict, curCoins, nextCoins, routesByTvl, routesByLength, step, _i, curCoins_1, inCoin, outCoin, _a, _b, outCoin, outCoin, outCoin, _c, _d, outCoin, _e, ALL_POOLS_1, _f, poolId, poolData, wrapped_coin_addresses, underlying_coin_addresses, pool_address, token_address, is_aave_like_lending, pool_type, tvl_multiplier, base_pool, base_pool_address, base_token_address, second_base_pool, second_base_pool_address, second_base_token_address, meta_coin_addresses, swap_address, inCoinIndexes, tvl, j, outputCoinIdx, j, outputCoinIdx, swapType, swapType, j, outputCoinIdx, j, outputCoinIdx, hasEth, swapType, routes;
-    var _h, _j;
-    var _k, _l, _m, _o, _p, _q, _r;
-    return __generator(this, function (_s) {
-        switch (_s.label) {
+var _buildRouteGraph = memoize(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var routerGraph, _i, _a, outCoin, _b, _c, inCoin, _d, _e, outCoin, ALL_POOLS, amplificationCoefficientDict, _f, ALL_POOLS_1, _h, poolId, poolData, wrappedCoinAddresses, underlyingCoinAddresses, poolAddress, tokenAddress, isAaveLikeLending, poolType, tvlMultiplier, basePool, basePoolAddress, baseTokenAddress, secondBasePool, secondBasePoolAddress, secondBaseTokenAddress, metaCoinAddresses, swapAddress, tvl, coins, k, l, i, j, swapType, coins, k, l, i, j, swapType, i, j, i, j, hasEth, swapType;
+    var _j, _k, _l;
+    return __generator(this, function (_m) {
+        switch (_m.label) {
             case 0:
-                inputCoinAddress = inputCoinAddress.toLowerCase();
-                outputCoinAddress = outputCoinAddress.toLowerCase();
-                ALL_POOLS = Object.entries(curve.getPoolsData()).filter(function (_a) {
-                    var id = _a[0], _ = _a[1];
-                    return id !== "crveth";
-                });
-                return [4 /*yield*/, _getAmplificationCoefficientsFromApi()];
-            case 1:
-                amplificationCoefficientDict = _s.sent();
-                curCoins = [inputCoinAddress];
-                nextCoins = new Set();
-                routesByTvl = (_h = {},
-                    _h[inputCoinAddress] = [{ route: [], minTvl: Infinity, totalTvl: 0 }],
-                    _h);
-                routesByLength = (_j = {},
-                    _j[inputCoinAddress] = [{ route: [], minTvl: Infinity, totalTvl: 0 }],
-                    _j);
-                step = 0;
-                _s.label = 2;
-            case 2:
-                if (!(step < MAX_STEPS)) return [3 /*break*/, 10];
-                _i = 0, curCoins_1 = curCoins;
-                _s.label = 3;
-            case 3:
-                if (!(_i < curCoins_1.length)) return [3 /*break*/, 8];
-                inCoin = curCoins_1[_i];
+                routerGraph = {};
                 // ETH <-> WETH (exclude Celo)
-                if (curve.chainId !== 42220 && [curve.constants.NATIVE_TOKEN.address, curve.constants.NATIVE_TOKEN.wrappedAddress].includes(inCoin)) {
-                    outCoin = inCoin === curve.constants.NATIVE_TOKEN.address ? curve.constants.NATIVE_TOKEN.wrappedAddress : curve.constants.NATIVE_TOKEN.address;
-                    _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, "WETH", curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin, [0, 0, 8, 0, 0], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, Infinity);
-                    nextCoins.add(outCoin);
+                if (curve.chainId !== 42220) {
+                    routerGraph[curve.constants.NATIVE_TOKEN.address] = {};
+                    routerGraph[curve.constants.NATIVE_TOKEN.address][curve.constants.NATIVE_TOKEN.wrappedAddress] = [{
+                            poolId: "WETH wrapper",
+                            swapAddress: curve.constants.NATIVE_TOKEN.wrappedAddress,
+                            inputCoinAddress: curve.constants.NATIVE_TOKEN.address,
+                            outputCoinAddress: curve.constants.NATIVE_TOKEN.wrappedAddress,
+                            swapParams: [0, 0, 8, 0, 0],
+                            poolAddress: curve.constants.ZERO_ADDRESS,
+                            basePool: curve.constants.ZERO_ADDRESS,
+                            baseToken: curve.constants.ZERO_ADDRESS,
+                            secondBasePool: curve.constants.ZERO_ADDRESS,
+                            secondBaseToken: curve.constants.ZERO_ADDRESS,
+                            tvl: Infinity,
+                        }];
+                    routerGraph[curve.constants.NATIVE_TOKEN.wrappedAddress] = {};
+                    routerGraph[curve.constants.NATIVE_TOKEN.wrappedAddress][curve.constants.NATIVE_TOKEN.address] = [{
+                            poolId: "WETH wrapper",
+                            swapAddress: curve.constants.NATIVE_TOKEN.wrappedAddress,
+                            inputCoinAddress: curve.constants.NATIVE_TOKEN.wrappedAddress,
+                            outputCoinAddress: curve.constants.NATIVE_TOKEN.address,
+                            swapParams: [0, 0, 8, 0, 0],
+                            poolAddress: curve.constants.ZERO_ADDRESS,
+                            basePool: curve.constants.ZERO_ADDRESS,
+                            baseToken: curve.constants.ZERO_ADDRESS,
+                            secondBasePool: curve.constants.ZERO_ADDRESS,
+                            secondBaseToken: curve.constants.ZERO_ADDRESS,
+                            tvl: Infinity,
+                        }];
                 }
                 // ETH -> stETH, ETH -> frxETH, ETH -> wBETH (Ethereum only)
-                if (curve.chainId == 1 && inCoin === curve.constants.NATIVE_TOKEN.address) {
-                    for (_a = 0, _b = ["stETH", "frxETH", "wBETH"]; _a < _b.length; _a++) {
-                        outCoin = _b[_a];
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, outCoin === "frxETH" ? "frxETH minter" : outCoin, outCoin === "frxETH" ? "0xbAFA44EFE7901E04E39Dad13167D089C559c1138".toLowerCase() : curve.constants.COINS[outCoin.toLowerCase()], inCoin, curve.constants.COINS[outCoin.toLowerCase()], [0, 0, 8, 0, 0], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, Infinity);
-                        nextCoins.add(curve.constants.COINS[outCoin.toLowerCase()]);
+                if (curve.chainId == 1) {
+                    for (_i = 0, _a = ["stETH", "frxETH", "wBETH"]; _i < _a.length; _i++) {
+                        outCoin = _a[_i];
+                        routerGraph[curve.constants.NATIVE_TOKEN.address][curve.constants.COINS[outCoin.toLowerCase()]] = [{
+                                poolId: outCoin + " minter",
+                                swapAddress: outCoin === "frxETH" ? "0xbAFA44EFE7901E04E39Dad13167D089C559c1138".toLowerCase() : curve.constants.COINS[outCoin.toLowerCase()],
+                                inputCoinAddress: curve.constants.NATIVE_TOKEN.address,
+                                outputCoinAddress: curve.constants.COINS[outCoin.toLowerCase()],
+                                swapParams: [0, 0, 8, 0, 0],
+                                poolAddress: curve.constants.ZERO_ADDRESS,
+                                basePool: curve.constants.ZERO_ADDRESS,
+                                baseToken: curve.constants.ZERO_ADDRESS,
+                                secondBasePool: curve.constants.ZERO_ADDRESS,
+                                secondBaseToken: curve.constants.ZERO_ADDRESS,
+                                tvl: Infinity,
+                            }];
                     }
                 }
                 // stETH <-> wstETH (Ethereum only)
-                if (curve.chainId === 1 && [curve.constants.COINS.steth, curve.constants.COINS.wsteth].includes(inCoin)) {
-                    outCoin = inCoin === curve.constants.COINS.steth ? curve.constants.COINS.wsteth : curve.constants.COINS.steth;
-                    _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, "wstETH", curve.constants.COINS["wsteth"], inCoin, outCoin, [0, 0, 8, 0, 0], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, Infinity);
-                    nextCoins.add(outCoin);
+                if (curve.chainId === 1) {
+                    routerGraph[curve.constants.COINS.steth] = {};
+                    routerGraph[curve.constants.COINS.steth][curve.constants.COINS.wsteth] = [{
+                            poolId: "wstETH wrapper",
+                            swapAddress: curve.constants.COINS.wsteth,
+                            inputCoinAddress: curve.constants.COINS.steth,
+                            outputCoinAddress: curve.constants.COINS.wsteth,
+                            swapParams: [0, 0, 8, 0, 0],
+                            poolAddress: curve.constants.ZERO_ADDRESS,
+                            basePool: curve.constants.ZERO_ADDRESS,
+                            baseToken: curve.constants.ZERO_ADDRESS,
+                            secondBasePool: curve.constants.ZERO_ADDRESS,
+                            secondBaseToken: curve.constants.ZERO_ADDRESS,
+                            tvl: Infinity,
+                        }];
+                    routerGraph[curve.constants.COINS.wsteth] = {};
+                    routerGraph[curve.constants.COINS.wsteth][curve.constants.COINS.steth] = [{
+                            poolId: "wstETH wrapper",
+                            swapAddress: curve.constants.COINS.wsteth,
+                            inputCoinAddress: curve.constants.COINS.wsteth,
+                            outputCoinAddress: curve.constants.COINS.steth,
+                            swapParams: [0, 0, 8, 0, 0],
+                            poolAddress: curve.constants.ZERO_ADDRESS,
+                            basePool: curve.constants.ZERO_ADDRESS,
+                            baseToken: curve.constants.ZERO_ADDRESS,
+                            secondBasePool: curve.constants.ZERO_ADDRESS,
+                            secondBaseToken: curve.constants.ZERO_ADDRESS,
+                            tvl: Infinity,
+                        }];
                 }
                 // frxETH <-> sfrxETH (Ethereum only)
-                if (curve.chainId === 1 && [curve.constants.COINS.frxeth, curve.constants.COINS.sfrxeth].includes(inCoin)) {
-                    outCoin = inCoin === curve.constants.COINS.frxeth ? curve.constants.COINS.sfrxeth : curve.constants.COINS.frxeth;
-                    _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, "sfrxETH", curve.constants.COINS["sfrxeth"], inCoin, outCoin, [0, 0, 8, 0, 0], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, Infinity);
-                    nextCoins.add(outCoin);
+                if (curve.chainId === 1) {
+                    routerGraph[curve.constants.COINS.frxeth] = {};
+                    routerGraph[curve.constants.COINS.frxeth][curve.constants.COINS.sfrxeth] = [{
+                            poolId: "sfrxETH wrapper",
+                            swapAddress: curve.constants.COINS.sfrxeth,
+                            inputCoinAddress: curve.constants.COINS.frxeth,
+                            outputCoinAddress: curve.constants.COINS.sfrxeth,
+                            swapParams: [0, 0, 8, 0, 0],
+                            poolAddress: curve.constants.ZERO_ADDRESS,
+                            basePool: curve.constants.ZERO_ADDRESS,
+                            baseToken: curve.constants.ZERO_ADDRESS,
+                            secondBasePool: curve.constants.ZERO_ADDRESS,
+                            secondBaseToken: curve.constants.ZERO_ADDRESS,
+                            tvl: Infinity,
+                        }];
+                    routerGraph[curve.constants.COINS.sfrxeth] = {};
+                    routerGraph[curve.constants.COINS.sfrxeth][curve.constants.COINS.frxeth] = [{
+                            poolId: "sfrxETH wrapper",
+                            swapAddress: curve.constants.COINS.sfrxeth,
+                            inputCoinAddress: curve.constants.COINS.sfrxeth,
+                            outputCoinAddress: curve.constants.COINS.frxeth,
+                            swapParams: [0, 0, 8, 0, 0],
+                            poolAddress: curve.constants.ZERO_ADDRESS,
+                            basePool: curve.constants.ZERO_ADDRESS,
+                            baseToken: curve.constants.ZERO_ADDRESS,
+                            secondBasePool: curve.constants.ZERO_ADDRESS,
+                            secondBaseToken: curve.constants.ZERO_ADDRESS,
+                            tvl: Infinity,
+                        }];
                 }
                 // SNX swaps
-                // @ts-ignore
-                if (((_l = (_k = SNX[curve.chainId]) === null || _k === void 0 ? void 0 : _k.coins) !== null && _l !== void 0 ? _l : []).includes(inCoin)) {
+                if (curve.chainId in SNX) {
                     // @ts-ignore
-                    for (_c = 0, _d = SNX[curve.chainId].coins; _c < _d.length; _c++) {
-                        outCoin = _d[_c];
-                        if (inCoin === outCoin)
-                            continue;
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, "SNX exchange", 
+                    for (_b = 0, _c = SNX[curve.chainId].coins; _b < _c.length; _b++) {
+                        inCoin = _c[_b];
                         // @ts-ignore
-                        SNX[curve.chainId].swap, inCoin, outCoin, [0, 0, 9, 0, 0], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, Infinity);
-                        nextCoins.add(outCoin);
+                        for (_d = 0, _e = SNX[curve.chainId].coins; _d < _e.length; _d++) {
+                            outCoin = _e[_d];
+                            if (inCoin === outCoin)
+                                continue;
+                            if (!routerGraph[inCoin])
+                                routerGraph[inCoin] = {};
+                            routerGraph[inCoin][outCoin] = [{
+                                    poolId: "SNX exchanger",
+                                    // @ts-ignore
+                                    swapAddress: SNX[curve.chainId].swap,
+                                    inputCoinAddress: inCoin,
+                                    outputCoinAddress: outCoin,
+                                    swapParams: [0, 0, 9, 0, 0],
+                                    poolAddress: curve.constants.ZERO_ADDRESS,
+                                    basePool: curve.constants.ZERO_ADDRESS,
+                                    baseToken: curve.constants.ZERO_ADDRESS,
+                                    secondBasePool: curve.constants.ZERO_ADDRESS,
+                                    secondBaseToken: curve.constants.ZERO_ADDRESS,
+                                    tvl: Infinity,
+                                }];
+                        }
                     }
                 }
-                _e = 0, ALL_POOLS_1 = ALL_POOLS;
-                _s.label = 4;
-            case 4:
-                if (!(_e < ALL_POOLS_1.length)) return [3 /*break*/, 7];
-                _f = ALL_POOLS_1[_e], poolId = _f[0], poolData = _f[1];
-                wrapped_coin_addresses = poolData.wrapped_coin_addresses.map(function (a) { return a.toLowerCase(); });
-                underlying_coin_addresses = poolData.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); });
-                pool_address = poolData.swap_address.toLowerCase();
-                token_address = poolData.token_address.toLowerCase();
-                is_aave_like_lending = poolData.is_lending && wrapped_coin_addresses.length === 3 && !poolData.deposit_address;
-                pool_type = poolData.is_llamma ? 4 : poolData.is_crypto ? Math.min(poolData.wrapped_coins.length, 3) : 1;
-                tvl_multiplier = poolData.is_crypto ? 1 : ((_m = amplificationCoefficientDict[poolData.swap_address]) !== null && _m !== void 0 ? _m : 1);
-                base_pool = poolData.is_meta ? __assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA)[poolData.base_pool] : null;
-                base_pool_address = base_pool ? base_pool.swap_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
-                base_token_address = base_pool ? base_pool.token_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
-                second_base_pool = base_pool && base_pool.base_pool ? __assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRVUSD_FACTORY_POOLS_DATA)[base_pool.base_pool] : null;
-                second_base_pool_address = second_base_pool ? second_base_pool.swap_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
+                ALL_POOLS = Object.entries(curve.getPoolsData()).filter(function (_a) {
+                    var id = _a[0], _ = _a[1];
+                    return id !== "crveth";
+                });
+                return [4 /*yield*/, _getAmplificationCoefficientsFromApi()];
+            case 1:
+                amplificationCoefficientDict = _m.sent();
+                _f = 0, ALL_POOLS_1 = ALL_POOLS;
+                _m.label = 2;
+            case 2:
+                if (!(_f < ALL_POOLS_1.length)) return [3 /*break*/, 5];
+                _h = ALL_POOLS_1[_f], poolId = _h[0], poolData = _h[1];
+                wrappedCoinAddresses = poolData.wrapped_coin_addresses.map(function (a) { return a.toLowerCase(); });
+                underlyingCoinAddresses = poolData.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); });
+                poolAddress = poolData.swap_address.toLowerCase();
+                tokenAddress = poolData.token_address.toLowerCase();
+                isAaveLikeLending = poolData.is_lending && wrappedCoinAddresses.length === 3 && !poolData.deposit_address;
+                poolType = poolData.is_llamma ? 4 : poolData.is_crypto ? Math.min(poolData.wrapped_coins.length, 3) : 1;
+                tvlMultiplier = poolData.is_crypto ? 1 : ((_j = amplificationCoefficientDict[poolData.swap_address]) !== null && _j !== void 0 ? _j : 1);
+                basePool = poolData.is_meta ? __assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA)[poolData.base_pool] : null;
+                basePoolAddress = basePool ? basePool.swap_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
+                baseTokenAddress = basePool ? basePool.token_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
+                secondBasePool = basePool && basePool.base_pool ? __assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRVUSD_FACTORY_POOLS_DATA)[basePool.base_pool] : null;
+                secondBasePoolAddress = secondBasePool ? secondBasePool.swap_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
                 // for double meta underlying (crv/tricrypto, wmatic/tricrypto)
-                if (base_pool && second_base_pool_address !== curve.constants.ZERO_ADDRESS)
-                    base_token_address = (_o = base_pool.deposit_address) === null || _o === void 0 ? void 0 : _o.toLowerCase();
-                second_base_token_address = second_base_pool ? second_base_pool.token_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
-                meta_coin_addresses = base_pool ? base_pool.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); }) : [];
-                swap_address = poolData.is_fake ? (_p = poolData.deposit_address) === null || _p === void 0 ? void 0 : _p.toLowerCase() : pool_address;
-                inCoinIndexes = {
-                    wrapped_coin: wrapped_coin_addresses.indexOf(inCoin),
-                    underlying_coin: underlying_coin_addresses.indexOf(inCoin),
-                    meta_coin: meta_coin_addresses ? meta_coin_addresses.indexOf(inCoin) : -1,
-                };
-                // Skip pools which don't contain inCoin
-                if (inCoinIndexes.wrapped_coin === -1 && inCoinIndexes.underlying_coin === -1 && inCoinIndexes.meta_coin === -1 && inCoin !== token_address)
-                    return [3 /*break*/, 6];
+                if (basePool && secondBasePoolAddress !== curve.constants.ZERO_ADDRESS)
+                    baseTokenAddress = (_k = basePool.deposit_address) === null || _k === void 0 ? void 0 : _k.toLowerCase();
+                secondBaseTokenAddress = secondBasePool ? secondBasePool.token_address.toLowerCase() : curve.constants.ZERO_ADDRESS;
+                metaCoinAddresses = basePool ? basePool.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); }) : [];
+                swapAddress = poolData.is_fake ? (_l = poolData.deposit_address) === null || _l === void 0 ? void 0 : _l.toLowerCase() : poolAddress;
                 return [4 /*yield*/, _getTVL(poolId)];
-            case 5:
-                tvl = (_s.sent()) * tvl_multiplier;
+            case 3:
+                tvl = (_m.sent()) * tvlMultiplier;
                 // Skip empty pools
                 if (curve.chainId === 1 && tvl < 1000)
-                    return [3 /*break*/, 6];
+                    return [3 /*break*/, 4];
                 if (curve.chainId !== 1 && tvl < 100)
-                    return [3 /*break*/, 6];
-                // LP -> wrapped coin "swaps" (actually remove_liquidity_one_coin)
-                if (!poolData.is_fake && !poolData.is_llamma && wrapped_coin_addresses.length < 6 && inCoin === token_address) {
-                    for (j = 0; j < wrapped_coin_addresses.length; j++) {
-                        // Looking for outputCoinAddress only on the final step
-                        if (step === MAX_STEPS - 1 && wrapped_coin_addresses[j] !== outputCoinAddress)
-                            continue;
-                        outputCoinIdx = wrapped_coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, poolId, swap_address, inCoin, wrapped_coin_addresses[j], [0, j, 6, pool_type, wrapped_coin_addresses.length], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, tvl);
-                        nextCoins.add(wrapped_coin_addresses[j]);
+                    return [3 /*break*/, 4];
+                // Wrapped coin <-> LP "swaps" (actually add_liquidity/remove_liquidity_one_coin)
+                if (!poolData.is_fake && !poolData.is_llamma && wrappedCoinAddresses.length < 6) {
+                    coins = __spreadArray([tokenAddress], wrappedCoinAddresses, true);
+                    for (k = 0; k < coins.length; k++) {
+                        for (l = 0; l < coins.length; l++) {
+                            if (k > 0 && l > 0)
+                                continue;
+                            i = Math.max(k - 1, 0);
+                            j = Math.max(l - 1, 0);
+                            swapType = k == 0 ? 6 : 4;
+                            if (!routerGraph[coins[k]])
+                                routerGraph[coins[k]] = {};
+                            if (!routerGraph[coins[k]][coins[l]])
+                                routerGraph[coins[k]][coins[l]] = [];
+                            routerGraph[coins[k]][coins[l]].push({
+                                poolId: poolId,
+                                swapAddress: swapAddress,
+                                inputCoinAddress: coins[k],
+                                outputCoinAddress: coins[l],
+                                swapParams: [i, j, swapType, poolType, wrappedCoinAddresses.length],
+                                poolAddress: curve.constants.ZERO_ADDRESS,
+                                basePool: curve.constants.ZERO_ADDRESS,
+                                baseToken: curve.constants.ZERO_ADDRESS,
+                                secondBasePool: curve.constants.ZERO_ADDRESS,
+                                secondBaseToken: curve.constants.ZERO_ADDRESS,
+                                tvl: tvl,
+                            });
+                        }
                     }
                 }
-                // LP -> underlying coin "swaps" (actually remove_liquidity_one_coin)
-                if ((poolData.is_fake || is_aave_like_lending) && underlying_coin_addresses.length < 6 && inCoin === token_address) {
-                    for (j = 0; j < underlying_coin_addresses.length; j++) {
-                        // Looking for outputCoinAddress only on the final step
-                        if (step === MAX_STEPS - 1 && underlying_coin_addresses[j] !== outputCoinAddress)
-                            continue;
-                        outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        swapType = is_aave_like_lending ? 7 : 6;
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, poolId, swap_address, inCoin, underlying_coin_addresses[j], [0, j, swapType, pool_type, underlying_coin_addresses.length], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, tvl);
-                        nextCoins.add(underlying_coin_addresses[j]);
-                    }
-                }
-                // Wrapped coin -> LP "swaps" (actually add_liquidity)
-                if (!poolData.is_fake && !poolData.is_llamma && wrapped_coin_addresses.length < 6 && inCoinIndexes.wrapped_coin >= 0) {
-                    // Looking for outputCoinAddress only on the final step
-                    if (!(step === MAX_STEPS - 1 && token_address !== outputCoinAddress)) {
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, poolId, swap_address, inCoin, token_address, [wrapped_coin_addresses.indexOf(inCoin), 0, 4, pool_type, wrapped_coin_addresses.length], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, tvl);
-                        nextCoins.add(token_address);
-                    }
-                }
-                // Underlying coin -> LP "swaps" (actually add_liquidity)
-                if ((poolData.is_fake || is_aave_like_lending) && underlying_coin_addresses.length < 6 && inCoinIndexes.underlying_coin >= 0) {
-                    // Looking for outputCoinAddress only on the final step
-                    if (!(step === MAX_STEPS - 1 && token_address !== outputCoinAddress)) {
-                        swapType = is_aave_like_lending ? 5 : 4;
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, poolId, swap_address, inCoin, token_address, [underlying_coin_addresses.indexOf(inCoin), 0, swapType, pool_type, underlying_coin_addresses.length], curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, curve.constants.ZERO_ADDRESS, tvl);
-                        nextCoins.add(token_address);
+                // Underlying coin <-> LP "swaps" (actually add_liquidity/remove_liquidity_one_coin)
+                if ((poolData.is_fake || isAaveLikeLending) && underlyingCoinAddresses.length < 6) {
+                    coins = __spreadArray([tokenAddress], underlyingCoinAddresses, true);
+                    for (k = 0; k < coins.length; k++) {
+                        for (l = 0; l < coins.length; l++) {
+                            if (k > 0 && l > 0)
+                                continue;
+                            i = Math.max(k - 1, 0);
+                            j = Math.max(l - 1, 0);
+                            swapType = isAaveLikeLending ? 7 : 6;
+                            if (k > 0)
+                                swapType = isAaveLikeLending ? 5 : 4;
+                            if (!routerGraph[coins[k]])
+                                routerGraph[coins[k]] = {};
+                            if (!routerGraph[coins[k]][coins[l]])
+                                routerGraph[coins[k]][coins[l]] = [];
+                            routerGraph[coins[k]][coins[l]].push({
+                                poolId: poolId,
+                                swapAddress: swapAddress,
+                                inputCoinAddress: coins[k],
+                                outputCoinAddress: coins[l],
+                                swapParams: [i, j, swapType, poolType, underlyingCoinAddresses.length],
+                                poolAddress: curve.constants.ZERO_ADDRESS,
+                                basePool: curve.constants.ZERO_ADDRESS,
+                                baseToken: curve.constants.ZERO_ADDRESS,
+                                secondBasePool: curve.constants.ZERO_ADDRESS,
+                                secondBaseToken: curve.constants.ZERO_ADDRESS,
+                                tvl: tvl,
+                            });
+                        }
                     }
                 }
                 // Wrapped swaps
-                if (inCoinIndexes.wrapped_coin >= 0 && !poolData.is_fake) {
-                    for (j = 0; j < wrapped_coin_addresses.length; j++) {
-                        if (j === inCoinIndexes.wrapped_coin)
-                            continue;
-                        // Native swaps spend less gas
-                        if (wrapped_coin_addresses[j] !== outputCoinAddress && wrapped_coin_addresses[j] === curve.constants.NATIVE_TOKEN.wrappedAddress)
-                            continue;
-                        // Looking for outputCoinAddress only on the final step
-                        if (step === MAX_STEPS - 1 && wrapped_coin_addresses[j] !== outputCoinAddress)
-                            continue;
-                        outputCoinIdx = wrapped_coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, poolId, pool_address, inCoin, wrapped_coin_addresses[j], [inCoinIndexes.wrapped_coin, j, 1, pool_type, wrapped_coin_addresses.length], pool_address, base_pool_address, base_token_address, second_base_pool_address, second_base_token_address, tvl);
-                        nextCoins.add(wrapped_coin_addresses[j]);
+                if (!poolData.is_fake) {
+                    for (i = 0; i < wrappedCoinAddresses.length; i++) {
+                        for (j = 0; j < wrappedCoinAddresses.length; j++) {
+                            if (i == j)
+                                continue;
+                            if (!routerGraph[wrappedCoinAddresses[i]])
+                                routerGraph[wrappedCoinAddresses[i]] = {};
+                            if (!routerGraph[wrappedCoinAddresses[i]][wrappedCoinAddresses[j]])
+                                routerGraph[wrappedCoinAddresses[i]][wrappedCoinAddresses[j]] = [];
+                            routerGraph[wrappedCoinAddresses[i]][wrappedCoinAddresses[j]] = routerGraph[wrappedCoinAddresses[i]][wrappedCoinAddresses[j]].concat({
+                                poolId: poolId,
+                                swapAddress: swapAddress,
+                                inputCoinAddress: wrappedCoinAddresses[i],
+                                outputCoinAddress: wrappedCoinAddresses[j],
+                                swapParams: [i, j, 1, poolType, wrappedCoinAddresses.length],
+                                poolAddress: poolAddress,
+                                basePool: basePoolAddress,
+                                baseToken: baseTokenAddress,
+                                secondBasePool: secondBasePoolAddress,
+                                secondBaseToken: secondBaseTokenAddress,
+                                tvl: tvl,
+                            }).sort(function (a, b) { return b.tvl - a.tvl; }).slice(0, GRAPH_MAX_EDGES);
+                        }
                     }
                 }
                 // Only for underlying swaps
-                swap_address = (poolData.is_crypto && poolData.is_meta) || ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ?
+                swapAddress = (poolData.is_crypto && poolData.is_meta) || ((basePool === null || basePool === void 0 ? void 0 : basePool.is_lending) && poolData.is_factory) ?
                     poolData.deposit_address : poolData.swap_address;
                 // Underlying swaps
-                if (!poolData.is_plain && inCoinIndexes.underlying_coin >= 0) {
-                    for (j = 0; j < underlying_coin_addresses.length; j++) {
-                        if (j === inCoinIndexes.underlying_coin)
-                            continue;
-                        // Don't swap metacoins since they can be swapped directly in base pool
-                        if (inCoinIndexes.meta_coin >= 0 && meta_coin_addresses.includes(underlying_coin_addresses[j]))
-                            continue;
-                        // Looking for outputCoinAddress only on the final step
-                        if (step === MAX_STEPS - 1 && underlying_coin_addresses[j] !== outputCoinAddress)
-                            continue;
-                        outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        // Skip empty pools
-                        if (tvl === 0)
-                            continue;
-                        hasEth = (inCoin === curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve.constants.NATIVE_TOKEN.address);
-                        swapType = (poolData.is_crypto && poolData.is_meta && poolData.is_factory) || ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ? 3
-                            : hasEth && poolId !== 'avaxcrypto' ? 1
-                                : 2;
-                        _updateRoutes(inputCoinAddress, routesByTvl, routesByLength, poolId, swap_address, inCoin, underlying_coin_addresses[j], [inCoinIndexes.underlying_coin, j, swapType, pool_type, underlying_coin_addresses.length], pool_address, base_pool_address, base_token_address, second_base_pool_address, second_base_token_address, tvl);
-                        nextCoins.add(underlying_coin_addresses[j]);
+                if (!poolData.is_plain) {
+                    for (i = 0; i < underlyingCoinAddresses.length; i++) {
+                        for (j = 0; j < underlyingCoinAddresses.length; j++) {
+                            if (i === j)
+                                continue;
+                            // Don't swap metacoins since they can be swapped directly in base pool
+                            if (metaCoinAddresses.includes(underlyingCoinAddresses[i]) && metaCoinAddresses.includes(underlyingCoinAddresses[j]))
+                                continue;
+                            hasEth = [underlyingCoinAddresses[i], underlyingCoinAddresses[j]].includes(curve.constants.NATIVE_TOKEN.address);
+                            swapType = (poolData.is_crypto && poolData.is_meta && poolData.is_factory) || ((basePool === null || basePool === void 0 ? void 0 : basePool.is_lending) && poolData.is_factory) ? 3
+                                : hasEth && poolId !== 'avaxcrypto' ? 1 : 2;
+                            if (!routerGraph[underlyingCoinAddresses[i]])
+                                routerGraph[underlyingCoinAddresses[i]] = {};
+                            if (!routerGraph[underlyingCoinAddresses[i]][underlyingCoinAddresses[j]])
+                                routerGraph[underlyingCoinAddresses[i]][underlyingCoinAddresses[j]] = [];
+                            routerGraph[underlyingCoinAddresses[i]][underlyingCoinAddresses[j]] = routerGraph[underlyingCoinAddresses[i]][underlyingCoinAddresses[j]].concat({
+                                poolId: poolId,
+                                swapAddress: swapAddress,
+                                inputCoinAddress: underlyingCoinAddresses[i],
+                                outputCoinAddress: underlyingCoinAddresses[j],
+                                swapParams: [i, j, swapType, poolType, underlyingCoinAddresses.length],
+                                poolAddress: poolAddress,
+                                basePool: basePoolAddress,
+                                baseToken: baseTokenAddress,
+                                secondBasePool: secondBasePoolAddress,
+                                secondBaseToken: secondBaseTokenAddress,
+                                tvl: tvl,
+                            }).sort(function (a, b) { return b.tvl - a.tvl; }).slice(0, GRAPH_MAX_EDGES);
+                        }
                     }
                 }
-                _s.label = 6;
-            case 6:
-                _e++;
-                return [3 /*break*/, 4];
-            case 7:
-                _i++;
-                return [3 /*break*/, 3];
-            case 8:
-                curCoins = Array.from(nextCoins);
-                nextCoins = new Set();
-                _s.label = 9;
-            case 9:
-                step++;
+                _m.label = 4;
+            case 4:
+                _f++;
                 return [3 /*break*/, 2];
-            case 10:
-                routes = __spreadArray(__spreadArray([], ((_q = routesByTvl[outputCoinAddress]) !== null && _q !== void 0 ? _q : []), true), ((_r = routesByLength[outputCoinAddress]) !== null && _r !== void 0 ? _r : []), true);
-                return [2 /*return*/, routes.map(function (r) { return r.route; })];
+            case 5: return [2 /*return*/, routerGraph];
+        }
+    });
+}); }, {
+    promise: true,
+    maxAge: 5 * 1000, // 5m
+});
+var _isVisitedCoin = function (coinAddress, route) {
+    return route.route.map(function (r) { return r.inputCoinAddress; }).includes(coinAddress);
+};
+var _isVisitedPool = function (poolId, route) {
+    return route.route.map(function (r) { return r.poolId; }).includes(poolId);
+};
+// Breadth-first search
+var _findRoutes = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
+    var routes, targetRoutes, routerGraph, ALL_POOLS, route, inCoin, outCoin, _i, _a, step, poolData, routePoolIdsPlusSwapType, poolCoins;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                inputCoinAddress = inputCoinAddress.toLowerCase();
+                outputCoinAddress = outputCoinAddress.toLowerCase();
+                routes = [{ route: [], minTvl: Infinity, totalTvl: 0 }];
+                targetRoutes = [];
+                return [4 /*yield*/, _buildRouteGraph()];
+            case 1:
+                routerGraph = _b.sent();
+                ALL_POOLS = curve.getPoolsData();
+                while (routes.length > 0) {
+                    route = routes.pop();
+                    inCoin = route.route.length > 0 ? route.route[route.route.length - 1].outputCoinAddress : inputCoinAddress;
+                    if (inCoin === outputCoinAddress) {
+                        targetRoutes.push(route);
+                    }
+                    else if (route.route.length < 5) {
+                        for (outCoin in routerGraph[inCoin]) {
+                            if (_isVisitedCoin(outCoin, route))
+                                continue;
+                            for (_i = 0, _a = routerGraph[inCoin][outCoin]; _i < _a.length; _i++) {
+                                step = _a[_i];
+                                poolData = ALL_POOLS[step.poolId];
+                                if (!(poolData === null || poolData === void 0 ? void 0 : poolData.is_lending) && _isVisitedPool(step.poolId, route))
+                                    continue;
+                                routePoolIdsPlusSwapType = route.route.map(function (s) { return s.poolId + "+" + _handleSwapType(s.swapParams[2]); });
+                                if (routePoolIdsPlusSwapType.includes(step.poolId + "+" + _handleSwapType(step.swapParams[2])))
+                                    continue;
+                                poolCoins = poolData ? poolData.wrapped_coin_addresses.concat(poolData.underlying_coin_addresses) : [];
+                                // Exclude such cases as:
+                                // cvxeth -> tricrypto2 -> tusd -> susd (cvxeth -> tricrypto2 -> tusd instead)
+                                if (!(poolData === null || poolData === void 0 ? void 0 : poolData.is_lending) && poolCoins.includes(outputCoinAddress) && outCoin !== outputCoinAddress)
+                                    continue;
+                                // Exclude such cases as:
+                                // aave -> aave -> 3pool (aave -> aave instead)
+                                if ((poolData === null || poolData === void 0 ? void 0 : poolData.is_lending) && poolCoins.includes(outputCoinAddress) && outCoin !== outputCoinAddress && outCoin !== poolData.token_address)
+                                    continue;
+                                routes.push({
+                                    route: __spreadArray(__spreadArray([], route.route, true), [step], false),
+                                    minTvl: Math.min(step.tvl, route.minTvl),
+                                    totalTvl: route.totalTvl + step.tvl,
+                                });
+                            }
+                        }
+                    }
+                }
+                targetRoutes = _removeDuplications(__spreadArray(__spreadArray([], targetRoutes.sort(_sortByTvl).slice(0, MAX_ROUTES_FOR_ONE_COIN), true), targetRoutes.sort(_sortByLength).slice(0, MAX_ROUTES_FOR_ONE_COIN), true));
+                return [2 /*return*/, targetRoutes.map(function (r) { return r.route; })];
         }
     });
 }); };
@@ -461,7 +585,7 @@ var _getBestRoute = memoize(function (inputCoinAddress, outputCoinAddress, amoun
                 _amount = parseUnits(amount, inputCoinDecimals);
                 if (_amount === curve.parseUnits("0"))
                     return [2 /*return*/, []];
-                return [4 /*yield*/, _findAllRoutes(inputCoinAddress, outputCoinAddress)];
+                return [4 /*yield*/, _findRoutes(inputCoinAddress, outputCoinAddress)];
             case 1:
                 routesRaw = (_j.sent()).map(function (route) { return ({ route: route, _output: curve.parseUnits("0"), outputUsd: 0, txCostUsd: 0 }); });
                 routes = [];

package/lib/utils.js

@@ -428,14 +428,14 @@ export var _getUsdPricesFromApi = function () { return __awaiter(void 0, void 0,
                         if (lpTokenAddress.toLowerCase() in priceDict) {
                             priceDict[lpTokenAddress.toLowerCase()].push({
                                 price: pool.usdTotal && totalSupply ? pool.usdTotal / totalSupply : 0,
-                                tvl: pool.usdTotal
+                                tvl: pool.usdTotal,
                             });
                         }
                         else {
                             priceDict[lpTokenAddress.toLowerCase()] = [];
                             priceDict[lpTokenAddress.toLowerCase()].push({
                                 price: pool.usdTotal && totalSupply ? pool.usdTotal / totalSupply : 0,
-                                tvl: pool.usdTotal
+                                tvl: pool.usdTotal,
                             });
                         }
                         for (_c = 0, _d = pool.coins; _c < _d.length; _c++) {
@@ -444,14 +444,14 @@ export var _getUsdPricesFromApi = function () { return __awaiter(void 0, void 0,
                                 if (coin.address.toLowerCase() in priceDict) {
                                     priceDict[coin.address.toLowerCase()].push({
                                         price: coin.usdPrice,
-                                        tvl: pool.usdTotal
+                                        tvl: pool.usdTotal,
                                     });
                                 }
                                 else {
                                     priceDict[coin.address.toLowerCase()] = [];
                                     priceDict[coin.address.toLowerCase()].push({
                                         price: coin.usdPrice,
-                                        tvl: pool.usdTotal
+                                        tvl: pool.usdTotal,
                                     });
                                 }
                             }
@@ -462,14 +462,14 @@ export var _getUsdPricesFromApi = function () { return __awaiter(void 0, void 0,
                                 if (coin.tokenAddress.toLowerCase() in priceDict) {
                                     priceDict[coin.tokenAddress.toLowerCase()].push({
                                         price: coin.tokenPrice,
-                                        tvl: pool.usdTotal
+                                        tvl: pool.usdTotal,
                                     });
                                 }
                                 else {
                                     priceDict[coin.tokenAddress.toLowerCase()] = [];
                                     priceDict[coin.tokenAddress.toLowerCase()].push({
                                         price: coin.tokenPrice,
-                                        tvl: pool.usdTotal
+                                        tvl: pool.usdTotal,
                                     });
                                 }
                             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/api",
-  "version": "2.47.4",
+  "version": "2.48.0",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "author": "Macket",