@curvefi/api 2.18.2 → 2.19.1

package/lib/constants/pools/ethereum.js

@@ -1559,8 +1559,8 @@ exports.POOLS_DATA_ETHEREUM = (0, utils_1.lowerCasePoolDataAddresses)({
         token_address: "0xf43211935C781D5ca1a41d2041F397B8A7366C7A",
         gauge_address: "0x2932a86df44Fe8D2A706d8e9c5d51c24883423F5",
         is_plain: true,
-        underlying_coins: ['ETH', 'frxrETH'],
-        wrapped_coins: ['ETH', 'frxrETH'],
+        underlying_coins: ['ETH', 'frxETH'],
+        wrapped_coins: ['ETH', 'frxETH'],
         underlying_coin_addresses: [
             '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
             '0x5E8422345238F34275888049021821E8E08CAa1f',

package/lib/interfaces.d.ts

@@ -107,6 +107,7 @@ export interface IPoolDataFromApi {
     gaugeRewards?: IReward[];
     usdTotal: number;
     totalSupply: number;
+    amplificationCoefficient: string;
 }
 export interface ISubgraphPoolData {
     address: string;

package/lib/pools/utils.d.ts

@@ -1,3 +1,4 @@
+import { IDict } from "../interfaces";
 export declare const getPoolList: () => string[];
 export declare const getFactoryPoolList: () => string[];
 export declare const getCryptoFactoryPoolList: () => string[];
@@ -11,3 +12,4 @@ export declare const getUserClaimable: (pools: string[], address?: string) => Pr
     price: number;
 }[][]>;
 export declare const getUserPoolList: (address?: string) => Promise<string[]>;
+export declare const _getAmplificationCoefficientsFromApi: () => Promise<IDict<number>>;

package/lib/pools/utils.js

@@ -59,11 +59,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUserPoolList = exports.getUserClaimable = exports.getUserPoolListByClaimable = exports.getUserLiquidityUSD = exports.getUserPoolListByLiquidity = exports.getCryptoFactoryPoolList = exports.getFactoryPoolList = exports.getPoolList = void 0;
+exports._getAmplificationCoefficientsFromApi = exports.getUserPoolList = exports.getUserClaimable = exports.getUserPoolListByClaimable = exports.getUserLiquidityUSD = exports.getUserPoolListByLiquidity = exports.getCryptoFactoryPoolList = exports.getFactoryPoolList = exports.getPoolList = void 0;
 var ethers_1 = require("ethers");
 var poolConstructor_1 = require("./poolConstructor");
 var curve_1 = require("../curve");
 var utils_1 = require("../utils");
+var external_api_1 = require("../external-api");
 var ERC20_json_1 = __importDefault(require("../constants/abis/ERC20.json"));
 var getPoolList = function () { return Object.keys(curve_1.curve.constants.POOLS_DATA); };
 exports.getPoolList = getPoolList;
@@ -394,3 +395,31 @@ var getUserPoolList = function (address) {
     });
 };
 exports.getUserPoolList = getUserPoolList;
+var _getAmplificationCoefficientsFromApi = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var network, promises, allTypesExtendedPoolData, amplificationCoefficientDict, _i, allTypesExtendedPoolData_1, extendedPoolData, _a, _b, pool;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                network = curve_1.curve.constants.NETWORK_NAME;
+                promises = [
+                    (0, external_api_1._getPoolsFromApi)(network, "main"),
+                    (0, external_api_1._getPoolsFromApi)(network, "crypto"),
+                    (0, external_api_1._getPoolsFromApi)(network, "factory"),
+                    (0, external_api_1._getPoolsFromApi)(network, "factory-crypto"),
+                ];
+                return [4 /*yield*/, Promise.all(promises)];
+            case 1:
+                allTypesExtendedPoolData = _c.sent();
+                amplificationCoefficientDict = {};
+                for (_i = 0, allTypesExtendedPoolData_1 = allTypesExtendedPoolData; _i < allTypesExtendedPoolData_1.length; _i++) {
+                    extendedPoolData = allTypesExtendedPoolData_1[_i];
+                    for (_a = 0, _b = extendedPoolData.poolData; _a < _b.length; _a++) {
+                        pool = _b[_a];
+                        amplificationCoefficientDict[pool.address] = Number(pool.amplificationCoefficient);
+                    }
+                }
+                return [2 /*return*/, amplificationCoefficientDict];
+        }
+    });
+}); };
+exports._getAmplificationCoefficientsFromApi = _getAmplificationCoefficientsFromApi;

package/lib/router.js

@@ -66,7 +66,9 @@ var ethers_1 = require("ethers");
 var curve_1 = require("./curve");
 var utils_1 = require("./utils");
 var pools_1 = require("./pools");
+var utils_2 = require("./pools/utils");
 var MAX_ROUTES_FOR_ONE_COIN = 3;
+var MIN_TVL_THRESHOLD = 5000000;
 // Inspired by Dijkstra's algorithm
 var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
     var ALL_POOLS, basePoolsSet, _i, ALL_POOLS_1, pool, basePoolIds, markedCoins, curCoins, nextCoins, routes, step, _a, curCoins_1, inCoin, _b, ALL_POOLS_2, _c, poolId, poolData, wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_lending, inCoinIndexes, j, swapType, _d, _e, inCoinRoute, swapType, _f, _h, inCoinRoute, j, tvl, _j, swapType, _k, _l, inCoinRoute, poolAddress, j, tvl, _m, hasEth, swapType, _o, _p, inCoinRoute;
@@ -81,8 +83,8 @@ var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAd
                 basePoolsSet = new Set();
                 for (_i = 0, ALL_POOLS_1 = ALL_POOLS; _i < ALL_POOLS_1.length; _i++) {
                     pool = ALL_POOLS_1[_i];
-                    if (pool[1].base_pool)
-                        basePoolsSet.add(pool[1].base_pool);
+                    if (pool[1].wrapped_coin_addresses.length < 4)
+                        basePoolsSet.add(pool[0]);
                 }
                 basePoolIds = Array.from(basePoolsSet);
                 markedCoins = [];
@@ -116,24 +118,24 @@ var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAd
                     underlying_coin: underlying_coin_addresses.indexOf(inCoin),
                     meta_coin: meta_coin_addresses ? meta_coin_addresses.indexOf(inCoin) : -1,
                 };
-                // LP -> underlying coin "swaps" (actually remove_liquidity_one_coin)
+                // LP -> wrapped coin "swaps" (actually remove_liquidity_one_coin)
                 if (basePoolIds.includes(poolId) && inCoin === token_address) {
-                    for (j = 0; j < underlying_coin_addresses.length; j++) {
+                    for (j = 0; j < wrapped_coin_addresses.length; j++) {
                         // If this coin already marked or will be marked on the current step, no need to consider it on the next step
-                        if (markedCoins.includes(underlying_coin_addresses[j]) || curCoins.includes(underlying_coin_addresses[j]))
+                        if (markedCoins.includes(wrapped_coin_addresses[j]) || curCoins.includes(wrapped_coin_addresses[j]))
                             continue;
                         // Looking for outputCoinAddress only on the final step
-                        if (step === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
+                        if (step === 3 && wrapped_coin_addresses[j] !== outputCoinAddress)
                             continue;
                         swapType = poolId === 'aave' ? 11 : 10;
                         for (_d = 0, _e = routes[inCoin]; _d < _e.length; _d++) {
                             inCoinRoute = _e[_d];
-                            routes[underlying_coin_addresses[j]] = ((_s = routes[underlying_coin_addresses[j]]) !== null && _s !== void 0 ? _s : []).concat([__spreadArray(__spreadArray([], inCoinRoute, true), [
+                            routes[wrapped_coin_addresses[j]] = ((_s = routes[wrapped_coin_addresses[j]]) !== null && _s !== void 0 ? _s : []).concat([__spreadArray(__spreadArray([], inCoinRoute, true), [
                                     {
                                         poolId: poolId,
                                         poolAddress: poolData.swap_address,
                                         inputCoinAddress: inCoin,
-                                        outputCoinAddress: underlying_coin_addresses[j],
+                                        outputCoinAddress: wrapped_coin_addresses[j],
                                         i: 0,
                                         j: j,
                                         swapType: swapType,
@@ -141,18 +143,18 @@ var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAd
                                     },
                                 ], false)]);
                         }
-                        nextCoins.add(underlying_coin_addresses[j]);
+                        nextCoins.add(wrapped_coin_addresses[j]);
                     }
                 }
-                // Underlying coin -> LP "swaps" (actually add_liquidity)
-                if (basePoolIds.includes(poolId) && underlying_coin_addresses.includes(inCoin)) {
+                // Wrapped coin -> LP "swaps" (actually add_liquidity)
+                if (basePoolIds.includes(poolId) && wrapped_coin_addresses.includes(inCoin)) {
                     // If this coin already marked or will be marked on the current step, no need to consider it on the next step
                     if (markedCoins.includes(token_address) || curCoins.includes(token_address))
                         return [3 /*break*/, 11];
                     // Looking for outputCoinAddress only on the final step
                     if (step === 3 && token_address !== outputCoinAddress)
                         return [3 /*break*/, 11];
-                    swapType = is_lending ? 9 : underlying_coin_addresses.length === 2 ? 7 : 8;
+                    swapType = is_lending ? 9 : wrapped_coin_addresses.length === 2 ? 7 : 8;
                     for (_f = 0, _h = routes[inCoin]; _f < _h.length; _f++) {
                         inCoinRoute = _h[_f];
                         routes[token_address] = ((_t = routes[token_address]) !== null && _t !== void 0 ? _t : []).concat([__spreadArray(__spreadArray([], inCoinRoute, true), [
@@ -161,7 +163,7 @@ var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAd
                                     poolAddress: poolData.swap_address,
                                     inputCoinAddress: inCoin,
                                     outputCoinAddress: token_address,
-                                    i: underlying_coin_addresses.indexOf(inCoin),
+                                    i: wrapped_coin_addresses.indexOf(inCoin),
                                     j: 0,
                                     swapType: swapType,
                                     swapAddress: ethers_1.ethers.constants.AddressZero,
@@ -287,15 +289,18 @@ var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAd
 exports._findAllRoutesTheShorterTheBetter = _findAllRoutesTheShorterTheBetter;
 // Inspired by Dijkstra's algorithm
 var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
-    var ALL_POOLS, basePoolsSet, _i, ALL_POOLS_3, pool, basePoolIds, curCoins, nextCoins, routes, step, _loop_1, _a, curCoins_2, inCoin;
+    var ALL_POOLS, amplificationCoefficientDict, basePoolsSet, _i, ALL_POOLS_3, pool, basePoolIds, curCoins, nextCoins, routes, step, _loop_1, _a, curCoins_2, inCoin;
     var _b;
-    var _c, _d, _e, _f, _h;
-    return __generator(this, function (_j) {
-        switch (_j.label) {
+    var _c, _d, _e, _f, _h, _j;
+    return __generator(this, function (_k) {
+        switch (_k.label) {
             case 0:
                 inputCoinAddress = inputCoinAddress.toLowerCase();
                 outputCoinAddress = outputCoinAddress.toLowerCase();
                 ALL_POOLS = Object.entries(__assign(__assign(__assign({}, curve_1.curve.constants.POOLS_DATA), curve_1.curve.constants.FACTORY_POOLS_DATA), curve_1.curve.constants.CRYPTO_FACTORY_POOLS_DATA));
+                return [4 /*yield*/, (0, utils_2._getAmplificationCoefficientsFromApi)()];
+            case 1:
+                amplificationCoefficientDict = _k.sent();
                 basePoolsSet = new Set();
                 for (_i = 0, ALL_POOLS_3 = ALL_POOLS; _i < ALL_POOLS_3.length; _i++) {
                     pool = ALL_POOLS_3[_i];
@@ -309,18 +314,18 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                     _b[inputCoinAddress] = [{ steps: [], minTvl: Infinity }],
                     _b);
                 step = 0;
-                _j.label = 1;
-            case 1:
-                if (!(step < 4)) return [3 /*break*/, 7];
+                _k.label = 2;
+            case 2:
+                if (!(step < 4)) return [3 /*break*/, 8];
                 _loop_1 = function (inCoin) {
-                    var _loop_2, _k, ALL_POOLS_4, _l, poolId, poolData;
-                    return __generator(this, function (_m) {
-                        switch (_m.label) {
+                    var _loop_2, _l, ALL_POOLS_4, _m, poolId, poolData;
+                    return __generator(this, function (_o) {
+                        switch (_o.label) {
                             case 0:
                                 _loop_2 = function (poolId, poolData) {
-                                    var wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_lending, inCoinIndexes, _loop_3, j, tvl_1, _o, swapType_1, newRoutes, routesByPoolIds_1, _loop_4, j, poolAddress, _loop_5, j;
-                                    return __generator(this, function (_p) {
-                                        switch (_p.label) {
+                                    var wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_lending, minTvlMultiplier, inCoinIndexes, _loop_3, j, tvl_1, _p, swapType_1, newRoutes, routesByPoolIds_1, _loop_4, j, poolAddress, _loop_5, j;
+                                    return __generator(this, function (_q) {
+                                        switch (_q.label) {
                                             case 0:
                                                 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(); });
@@ -328,6 +333,7 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                 meta_coin_addresses = base_pool ? base_pool.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); }) : [];
                                                 token_address = poolData.token_address.toLowerCase();
                                                 is_lending = (_c = poolData.is_lending) !== null && _c !== void 0 ? _c : false;
+                                                minTvlMultiplier = poolData.is_crypto ? 1 : ((_d = amplificationCoefficientDict[poolData.swap_address]) !== null && _d !== void 0 ? _d : 1);
                                                 inCoinIndexes = {
                                                     wrapped_coin: wrapped_coin_addresses.indexOf(inCoin),
                                                     underlying_coin: underlying_coin_addresses.indexOf(inCoin),
@@ -338,9 +344,9 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                     return [2 /*return*/, "continue"];
                                                 if (!(basePoolIds.includes(poolId) && inCoin === token_address)) return [3 /*break*/, 4];
                                                 _loop_3 = function (j) {
-                                                    var outputCoinIdx, tvl, _q, swapType, newRoutes, routesByPoolIds;
-                                                    return __generator(this, function (_r) {
-                                                        switch (_r.label) {
+                                                    var outputCoinIdx, tvl, _r, swapType, newRoutes, routesByPoolIds;
+                                                    return __generator(this, function (_s) {
+                                                        switch (_s.label) {
                                                             case 0:
                                                                 // Looking for outputCoinAddress only on the final step
                                                                 if (step === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
@@ -348,10 +354,10 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                 outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
                                                                 if (outputCoinIdx >= 0 && j !== outputCoinIdx)
                                                                     return [2 /*return*/, "continue"];
-                                                                _q = Number;
+                                                                _r = Number;
                                                                 return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
                                                             case 1:
-                                                                tvl = _q.apply(void 0, [_r.sent()]);
+                                                                tvl = _r.apply(void 0, [_s.sent()]);
                                                                 swapType = poolId === 'aave' ? 11 : 10;
                                                                 newRoutes = routes[inCoin].map(function (route) {
                                                                     var routePoolIds = route.steps.map(function (s) { return s.poolId; });
@@ -374,29 +380,29 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                                 swapAddress: ethers_1.ethers.constants.AddressZero,
                                                                             },
                                                                         ], false),
-                                                                        minTvl: Math.min(tvl, route.minTvl),
+                                                                        minTvl: Math.min(tvl, route.minTvl * minTvlMultiplier),
                                                                     };
                                                                 });
-                                                                routes[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_d = routes[underlying_coin_addresses[j]]) !== null && _d !== void 0 ? _d : []), true), newRoutes, true);
+                                                                routes[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_e = routes[underlying_coin_addresses[j]]) !== null && _e !== void 0 ? _e : []), true), newRoutes, true);
                                                                 routesByPoolIds = routes[underlying_coin_addresses[j]].map(function (r) { return r.steps.map(function (s) { return s.poolId; }).toString(); });
                                                                 routes[underlying_coin_addresses[j]] = routes[underlying_coin_addresses[j]]
                                                                     .filter(function (r) { return r.steps.length > 0; })
                                                                     .filter(function (r) { return r.steps[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
                                                                     .filter(function (r, i) { return routesByPoolIds.indexOf(r.steps.map(function (s) { return s.poolId; }).toString()) === i; }) // Route duplications
-                                                                    .sort(function (a, b) { return b.minTvl - a.minTvl || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
+                                                                    .sort(function (a, b) { return Math.min(b.minTvl, MIN_TVL_THRESHOLD) - Math.min(a.minTvl, MIN_TVL_THRESHOLD) || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
                                                                 nextCoins.add(underlying_coin_addresses[j]);
                                                                 return [2 /*return*/];
                                                         }
                                                     });
                                                 };
                                                 j = 0;
-                                                _p.label = 1;
+                                                _q.label = 1;
                                             case 1:
                                                 if (!(j < underlying_coin_addresses.length)) return [3 /*break*/, 4];
                                                 return [5 /*yield**/, _loop_3(j)];
                                             case 2:
-                                                _p.sent();
-                                                _p.label = 3;
+                                                _q.sent();
+                                                _q.label = 3;
                                             case 3:
                                                 j++;
                                                 return [3 /*break*/, 1];
@@ -405,10 +411,10 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                 // Looking for outputCoinAddress only on the final step
                                                 if (step === 3 && token_address !== outputCoinAddress)
                                                     return [2 /*return*/, "continue"];
-                                                _o = Number;
+                                                _p = Number;
                                                 return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
                                             case 5:
-                                                tvl_1 = _o.apply(void 0, [_p.sent()]);
+                                                tvl_1 = _p.apply(void 0, [_q.sent()]);
                                                 swapType_1 = is_lending ? 9 : underlying_coin_addresses.length === 2 ? 7 : 8;
                                                 newRoutes = routes[inCoin].map(function (route) {
                                                     var routePoolIds = route.steps.map(function (s) { return s.poolId; });
@@ -431,24 +437,24 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                 swapAddress: ethers_1.ethers.constants.AddressZero,
                                                             },
                                                         ], false),
-                                                        minTvl: Math.min(tvl_1, route.minTvl),
+                                                        minTvl: Math.min(tvl_1, route.minTvl * minTvlMultiplier),
                                                     };
                                                 });
-                                                routes[token_address] = __spreadArray(__spreadArray([], ((_e = routes[token_address]) !== null && _e !== void 0 ? _e : []), true), newRoutes, true);
+                                                routes[token_address] = __spreadArray(__spreadArray([], ((_f = routes[token_address]) !== null && _f !== void 0 ? _f : []), true), newRoutes, true);
                                                 routesByPoolIds_1 = routes[token_address].map(function (r) { return r.steps.map(function (s) { return s.poolId; }).toString(); });
                                                 routes[token_address] = routes[token_address]
                                                     .filter(function (r) { return r.steps.length > 0; })
                                                     .filter(function (r) { return r.steps[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
                                                     .filter(function (r, i) { return routesByPoolIds_1.indexOf(r.steps.map(function (s) { return s.poolId; }).toString()) === i; }) // Route duplications
-                                                    .sort(function (a, b) { return b.minTvl - a.minTvl || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
+                                                    .sort(function (a, b) { return Math.min(b.minTvl, MIN_TVL_THRESHOLD) - Math.min(a.minTvl, MIN_TVL_THRESHOLD) || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
                                                 nextCoins.add(token_address);
-                                                _p.label = 6;
+                                                _q.label = 6;
                                             case 6:
                                                 if (!(inCoinIndexes.wrapped_coin >= 0 && !poolData.is_fake)) return [3 /*break*/, 10];
                                                 _loop_4 = function (j) {
-                                                    var outputCoinIdx, tvl, _s, swapType, newRoutes, routesByPoolIds;
-                                                    return __generator(this, function (_t) {
-                                                        switch (_t.label) {
+                                                    var outputCoinIdx, tvl, _t, swapType, newRoutes, routesByPoolIds;
+                                                    return __generator(this, function (_u) {
+                                                        switch (_u.label) {
                                                             case 0:
                                                                 if (j === inCoinIndexes.wrapped_coin)
                                                                     return [2 /*return*/, "continue"];
@@ -461,10 +467,10 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                 outputCoinIdx = wrapped_coin_addresses.indexOf(outputCoinAddress);
                                                                 if (outputCoinIdx >= 0 && j !== outputCoinIdx)
                                                                     return [2 /*return*/, "continue"];
-                                                                _s = Number;
+                                                                _t = Number;
                                                                 return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
                                                             case 1:
-                                                                tvl = _s.apply(void 0, [_t.sent()]);
+                                                                tvl = _t.apply(void 0, [_u.sent()]);
                                                                 // Skip empty pools
                                                                 if (tvl === 0)
                                                                     return [2 /*return*/, "continue"];
@@ -490,29 +496,29 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                                 swapAddress: ethers_1.ethers.constants.AddressZero,
                                                                             },
                                                                         ], false),
-                                                                        minTvl: Math.min(tvl, route.minTvl),
+                                                                        minTvl: Math.min(tvl, route.minTvl * minTvlMultiplier),
                                                                     };
                                                                 });
-                                                                routes[wrapped_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_f = routes[wrapped_coin_addresses[j]]) !== null && _f !== void 0 ? _f : []), true), newRoutes, true);
+                                                                routes[wrapped_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_h = routes[wrapped_coin_addresses[j]]) !== null && _h !== void 0 ? _h : []), true), newRoutes, true);
                                                                 routesByPoolIds = routes[wrapped_coin_addresses[j]].map(function (r) { return r.steps.map(function (s) { return s.poolId; }).toString(); });
                                                                 routes[wrapped_coin_addresses[j]] = routes[wrapped_coin_addresses[j]]
                                                                     .filter(function (r) { return r.steps.length > 0; })
                                                                     .filter(function (r) { return r.steps[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
                                                                     .filter(function (r, i) { return routesByPoolIds.indexOf(r.steps.map(function (s) { return s.poolId; }).toString()) === i; }) // Route duplications
-                                                                    .sort(function (a, b) { return b.minTvl - a.minTvl || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
+                                                                    .sort(function (a, b) { return Math.min(b.minTvl, MIN_TVL_THRESHOLD) - Math.min(a.minTvl, MIN_TVL_THRESHOLD) || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
                                                                 nextCoins.add(wrapped_coin_addresses[j]);
                                                                 return [2 /*return*/];
                                                         }
                                                     });
                                                 };
                                                 j = 0;
-                                                _p.label = 7;
+                                                _q.label = 7;
                                             case 7:
                                                 if (!(j < wrapped_coin_addresses.length)) return [3 /*break*/, 10];
                                                 return [5 /*yield**/, _loop_4(j)];
                                             case 8:
-                                                _p.sent();
-                                                _p.label = 9;
+                                                _q.sent();
+                                                _q.label = 9;
                                             case 9:
                                                 j++;
                                                 return [3 /*break*/, 7];
@@ -521,9 +527,9 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                     poolData.deposit_address : poolData.swap_address;
                                                 if (!(!poolData.is_plain && inCoinIndexes.underlying_coin >= 0)) return [3 /*break*/, 14];
                                                 _loop_5 = function (j) {
-                                                    var outputCoinIdx, tvl, _u, hasEth, swapType, newRoutes, routesByPoolIds;
-                                                    return __generator(this, function (_v) {
-                                                        switch (_v.label) {
+                                                    var outputCoinIdx, tvl, _v, hasEth, swapType, newRoutes, routesByPoolIds;
+                                                    return __generator(this, function (_w) {
+                                                        switch (_w.label) {
                                                             case 0:
                                                                 if (j === inCoinIndexes.underlying_coin)
                                                                     return [2 /*return*/, "continue"];
@@ -536,10 +542,10 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                 outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
                                                                 if (outputCoinIdx >= 0 && j !== outputCoinIdx)
                                                                     return [2 /*return*/, "continue"];
-                                                                _u = Number;
+                                                                _v = Number;
                                                                 return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
                                                             case 1:
-                                                                tvl = _u.apply(void 0, [_v.sent()]);
+                                                                tvl = _v.apply(void 0, [_w.sent()]);
                                                                 if (tvl === 0)
                                                                     return [2 /*return*/, "continue"];
                                                                 hasEth = (inCoin === curve_1.curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve_1.curve.constants.NATIVE_TOKEN.address);
@@ -569,29 +575,29 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                                 swapAddress: (swapType === 5 || swapType === 6) ? poolData.swap_address : ethers_1.ethers.constants.AddressZero,
                                                                             },
                                                                         ], false),
-                                                                        minTvl: Math.min(tvl, route.minTvl),
+                                                                        minTvl: Math.min(tvl, route.minTvl * minTvlMultiplier),
                                                                     };
                                                                 });
-                                                                routes[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_h = routes[underlying_coin_addresses[j]]) !== null && _h !== void 0 ? _h : []), true), newRoutes, true);
+                                                                routes[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_j = routes[underlying_coin_addresses[j]]) !== null && _j !== void 0 ? _j : []), true), newRoutes, true);
                                                                 routesByPoolIds = routes[underlying_coin_addresses[j]].map(function (r) { return r.steps.map(function (s) { return s.poolId; }).toString(); });
                                                                 routes[underlying_coin_addresses[j]] = routes[underlying_coin_addresses[j]]
                                                                     .filter(function (r) { return r.steps.length > 0; })
                                                                     .filter(function (r) { return r.steps[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
                                                                     .filter(function (r, i) { return routesByPoolIds.indexOf(r.steps.map(function (s) { return s.poolId; }).toString()) === i; }) // Route duplications
-                                                                    .sort(function (a, b) { return b.minTvl - a.minTvl || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
+                                                                    .sort(function (a, b) { return Math.min(b.minTvl, MIN_TVL_THRESHOLD) - Math.min(a.minTvl, MIN_TVL_THRESHOLD) || a.steps.length - b.steps.length; }).slice(0, MAX_ROUTES_FOR_ONE_COIN);
                                                                 nextCoins.add(underlying_coin_addresses[j]);
                                                                 return [2 /*return*/];
                                                         }
                                                     });
                                                 };
                                                 j = 0;
-                                                _p.label = 11;
+                                                _q.label = 11;
                                             case 11:
                                                 if (!(j < underlying_coin_addresses.length)) return [3 /*break*/, 14];
                                                 return [5 /*yield**/, _loop_5(j)];
                                             case 12:
-                                                _p.sent();
-                                                _p.label = 13;
+                                                _q.sent();
+                                                _q.label = 13;
                                             case 13:
                                                 j++;
                                                 return [3 /*break*/, 11];
@@ -599,42 +605,42 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                         }
                                     });
                                 };
-                                _k = 0, ALL_POOLS_4 = ALL_POOLS;
-                                _m.label = 1;
+                                _l = 0, ALL_POOLS_4 = ALL_POOLS;
+                                _o.label = 1;
                             case 1:
-                                if (!(_k < ALL_POOLS_4.length)) return [3 /*break*/, 4];
-                                _l = ALL_POOLS_4[_k], poolId = _l[0], poolData = _l[1];
+                                if (!(_l < ALL_POOLS_4.length)) return [3 /*break*/, 4];
+                                _m = ALL_POOLS_4[_l], poolId = _m[0], poolData = _m[1];
                                 return [5 /*yield**/, _loop_2(poolId, poolData)];
                             case 2:
-                                _m.sent();
-                                _m.label = 3;
+                                _o.sent();
+                                _o.label = 3;
                             case 3:
-                                _k++;
+                                _l++;
                                 return [3 /*break*/, 1];
                             case 4: return [2 /*return*/];
                         }
                     });
                 };
                 _a = 0, curCoins_2 = curCoins;
-                _j.label = 2;
-            case 2:
-                if (!(_a < curCoins_2.length)) return [3 /*break*/, 5];
+                _k.label = 3;
+            case 3:
+                if (!(_a < curCoins_2.length)) return [3 /*break*/, 6];
                 inCoin = curCoins_2[_a];
                 return [5 /*yield**/, _loop_1(inCoin)];
-            case 3:
-                _j.sent();
-                _j.label = 4;
             case 4:
-                _a++;
-                return [3 /*break*/, 2];
+                _k.sent();
+                _k.label = 5;
             case 5:
+                _a++;
+                return [3 /*break*/, 3];
+            case 6:
                 curCoins = Array.from(nextCoins);
                 nextCoins = new Set();
-                _j.label = 6;
-            case 6:
+                _k.label = 7;
+            case 7:
                 step++;
-                return [3 /*break*/, 1];
-            case 7: return [2 /*return*/, routes[outputCoinAddress] ? routes[outputCoinAddress].map(function (r) { return r.steps; }) : []];
+                return [3 /*break*/, 2];
+            case 8: return [2 /*return*/, routes[outputCoinAddress] ? routes[outputCoinAddress].map(function (r) { return r.steps; }) : []];
         }
     });
 }); };

package/package.json

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