@curvefi/api 2.46.6 → 2.47.0

package/lib/router.js

@@ -61,49 +61,36 @@ import { curve } from "./curve.js";
 import { _getCoinAddresses, _getCoinDecimals, _getUsdRate, ensureAllowance, ensureAllowanceEstimateGas, fromBN, hasAllowance, isEth, toBN, BN, parseUnits, _cutZeros, ETH_ADDRESS, _get_small_x, _get_price_impact, } from "./utils.js";
 import { getPool } from "./pools/index.js";
 import { _getAmplificationCoefficientsFromApi } from "./pools/utils.js";
-var getNewRoute = function (routeTvl, poolId, poolAddress, inputCoinAddress, outputCoinAddress, i, j, swapType, swapAddress, tvl) {
-    var routePoolIds = routeTvl.route.map(function (s) { return s.poolId; });
-    // Steps <= 4
-    if (routePoolIds.length >= 4)
+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 (routePoolIds.includes(poolId))
+    if (routePoolIdsPlusSwapType.includes(poolId + "+" + _handleSwapType(swapParams[2])))
         return { route: [], minTvl: Infinity, totalTvl: 0 };
     return {
-        route: __spreadArray(__spreadArray([], routeTvl.route, true), [{ poolId: poolId, poolAddress: poolAddress, inputCoinAddress: inputCoinAddress, outputCoinAddress: outputCoinAddress, i: i, j: j, swapType: swapType, swapAddress: swapAddress }], false),
+        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,
     };
 };
-// TODO REMOVE IT!!!
-var filterMaticFactory83Route = function (routes) {
-    return routes.filter(function (r) {
-        for (var _i = 0, _a = r.route; _i < _a.length; _i++) {
-            var step = _a[_i];
-            if (step.poolId === "factory-crypto-83" && step.inputCoinAddress === curve.constants.NATIVE_TOKEN.address)
-                return false;
-        }
-        return true;
-    });
-};
-// TODO REMOVE IT!!!
-var filterAvax = function (routes) {
-    return routes.filter(function (r) {
-        for (var _i = 0, _a = r.route; _i < _a.length; _i++) {
-            var step = _a[_i];
-            if (step.poolId == 'avaxcrypto' && step.swapType == 4 && (step.i === 3 || step.j === 3))
-                return false;
-        }
-        return true;
-    });
-};
 var MAX_ROUTES_FOR_ONE_COIN = 3;
-var filterRoutes = function (routes, inputCoinAddress, sortFn) {
-    // TODO REMOVE IT!!!
-    if (curve.chainId === 137)
-        routes = filterMaticFactory83Route(routes);
-    if (curve.chainId === 43114)
-        routes = filterAvax(routes);
+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
@@ -113,8 +100,22 @@ var filterRoutes = function (routes, inputCoinAddress, sortFn) {
     }) // 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 _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:
@@ -126,11 +127,31 @@ var _getTVL = memoize(function (poolId) { return __awaiter(void 0, void 0, void
     promise: true,
     maxAge: 5 * 60 * 1000, // 5m
 });
+var SNX = {
+    1: {
+        swap: "0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F".toLowerCase(),
+        coins: [
+            "0x57Ab1ec28D129707052df4dF418D58a2D46d5f51",
+            "0xD71eCFF9342A5Ced620049e616c5035F1dB98620",
+            "0x5e74C9036fb86BD7eCdcb084a0673EFc32eA31cb",
+            "0xfE18be6b3Bd88A2D2A7f928d00292E7a9963CfC6", // sBTC
+        ].map(function (a) { return a.toLowerCase(); }),
+    },
+    10: {
+        swap: "0x8700dAec35aF8Ff88c16BdF0418774CB3D7599B4".toLowerCase(),
+        coins: [
+            "0x8c6f28f2f1a3c87f0f938b96d27520d9751ec8d9",
+            "0xFBc4198702E81aE77c06D58f81b629BDf36f0a71",
+            "0xe405de8f52ba7559f9df3c368500b6e6ae6cee49",
+            "0x298b9b95708152ff6968aafd889c6586e9169f1d", // sBTC
+        ].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, _loop_1, _i, curCoins_1, inCoin, routes;
-    var _a, _b;
-    var _c, _d, _e, _f, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    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) {
             case 0:
@@ -145,212 +166,205 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
                 amplificationCoefficientDict = _s.sent();
                 curCoins = [inputCoinAddress];
                 nextCoins = new Set();
-                routesByTvl = (_a = {},
-                    _a[inputCoinAddress] = [{ route: [], minTvl: Infinity, totalTvl: 0 }],
-                    _a);
-                routesByLength = (_b = {},
-                    _b[inputCoinAddress] = [{ route: [], minTvl: Infinity, totalTvl: 0 }],
-                    _b);
+                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 < 4)) return [3 /*break*/, 8];
-                _loop_1 = function (inCoin) {
-                    var outCoin_1, newRoutesByTvl, newRoutesByLength, _loop_2, _t, ALL_POOLS_1, _u, poolId, poolData;
-                    return __generator(this, function (_v) {
-                        switch (_v.label) {
-                            case 0:
-                                if (curve.chainId !== 42220 && [curve.constants.NATIVE_TOKEN.address, curve.constants.NATIVE_TOKEN.wrappedAddress].includes(inCoin)) { // Exclude Celo
-                                    outCoin_1 = inCoin === curve.constants.NATIVE_TOKEN.address ? curve.constants.NATIVE_TOKEN.wrappedAddress : curve.constants.NATIVE_TOKEN.address;
-                                    newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, "wrapper", curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin_1, 0, 0, 15, curve.constants.ZERO_ADDRESS, Infinity); });
-                                    newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, "wrapper", curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin_1, 0, 0, 15, curve.constants.ZERO_ADDRESS, Infinity); });
-                                    routesByTvl[outCoin_1] = __spreadArray(__spreadArray([], ((_c = routesByTvl[outCoin_1]) !== null && _c !== void 0 ? _c : []), true), newRoutesByTvl, true);
-                                    routesByTvl[outCoin_1] = filterRoutes(routesByTvl[outCoin_1], inputCoinAddress, sortByTvl);
-                                    routesByLength[outCoin_1] = __spreadArray(__spreadArray([], ((_d = routesByLength[outCoin_1]) !== null && _d !== void 0 ? _d : []), true), newRoutesByLength, true);
-                                    routesByLength[outCoin_1] = filterRoutes(routesByLength[outCoin_1], inputCoinAddress, sortByLength);
-                                    nextCoins.add(outCoin_1);
-                                }
-                                _loop_2 = function (poolId, poolData) {
-                                    var wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_aave_like_lending, tvlMultiplier, inCoinIndexes, tvl, _w, poolAddress, coin_addresses, _loop_3, j, inCoinIndex, swapType_1, newRoutesByTvl, newRoutesByLength, _loop_4, j, _loop_5, j;
-                                    return __generator(this, function (_x) {
-                                        switch (_x.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(); });
-                                                base_pool = poolData.is_meta ? __assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA)[poolData.base_pool] : null;
-                                                meta_coin_addresses = base_pool ? base_pool.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); }) : [];
-                                                token_address = poolData.token_address.toLowerCase();
-                                                is_aave_like_lending = poolData.is_lending && wrapped_coin_addresses.length === 3 && !poolData.deposit_address;
-                                                tvlMultiplier = poolData.is_crypto ? 1 : ((_e = amplificationCoefficientDict[poolData.swap_address]) !== null && _e !== void 0 ? _e : 1);
-                                                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 [2 /*return*/, "continue"];
-                                                if (!poolId.startsWith('factory-crvusd-')) return [3 /*break*/, 1];
-                                                _w = 500000 * 100;
-                                                return [3 /*break*/, 3];
-                                            case 1: return [4 /*yield*/, _getTVL(poolId)];
-                                            case 2:
-                                                _w = (_x.sent()) * tvlMultiplier;
-                                                _x.label = 3;
-                                            case 3:
-                                                tvl = _w;
-                                                // Skip empty pools
-                                                if (tvl === 0)
-                                                    return [2 /*return*/, "continue"];
-                                                poolAddress = poolData.is_fake ? poolData.deposit_address : poolData.swap_address;
-                                                coin_addresses = (is_aave_like_lending || poolData.is_fake) ? underlying_coin_addresses : wrapped_coin_addresses;
-                                                // LP -> wrapped coin (underlying for lending or fake pool) "swaps" (actually remove_liquidity_one_coin)
-                                                if (coin_addresses.length < 6 && inCoin === token_address) {
-                                                    _loop_3 = function (j) {
-                                                        // Looking for outputCoinAddress only on the final step
-                                                        if (step === 3 && coin_addresses[j] !== outputCoinAddress)
-                                                            return "continue";
-                                                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
-                                                        var outputCoinIdx = coin_addresses.indexOf(outputCoinAddress);
-                                                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                                                            return "continue";
-                                                        var swapType = poolData.is_crypto ? 14 : is_aave_like_lending ? 13 : 12;
-                                                        var newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, coin_addresses[j], 0, j, swapType, curve.constants.ZERO_ADDRESS, tvl); });
-                                                        var newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, coin_addresses[j], 0, j, swapType, curve.constants.ZERO_ADDRESS, tvl); });
-                                                        routesByTvl[coin_addresses[j]] = __spreadArray(__spreadArray([], ((_f = routesByTvl[coin_addresses[j]]) !== null && _f !== void 0 ? _f : []), true), newRoutesByTvl, true);
-                                                        routesByTvl[coin_addresses[j]] = filterRoutes(routesByTvl[coin_addresses[j]], inputCoinAddress, sortByTvl);
-                                                        routesByLength[coin_addresses[j]] = __spreadArray(__spreadArray([], ((_h = routesByLength[coin_addresses[j]]) !== null && _h !== void 0 ? _h : []), true), newRoutesByLength, true);
-                                                        routesByLength[coin_addresses[j]] = filterRoutes(routesByLength[coin_addresses[j]], inputCoinAddress, sortByLength);
-                                                        nextCoins.add(coin_addresses[j]);
-                                                    };
-                                                    for (j = 0; j < coin_addresses.length; j++) {
-                                                        _loop_3(j);
-                                                    }
-                                                }
-                                                inCoinIndex = (is_aave_like_lending || poolData.is_fake) ? inCoinIndexes.underlying_coin : inCoinIndexes.wrapped_coin;
-                                                if (coin_addresses.length < 6 && inCoinIndex >= 0 && !poolData.is_llamma) {
-                                                    // Looking for outputCoinAddress only on the final step
-                                                    if (!(step === 3 && token_address !== outputCoinAddress)) {
-                                                        swapType_1 = is_aave_like_lending ? 9
-                                                            : coin_addresses.length === 2 ? 7
-                                                                : coin_addresses.length === 3 ? 8
-                                                                    : coin_addresses.length === 4 ? 10 : 11;
-                                                        newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, token_address, coin_addresses.indexOf(inCoin), 0, swapType_1, curve.constants.ZERO_ADDRESS, tvl); });
-                                                        newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, token_address, coin_addresses.indexOf(inCoin), 0, swapType_1, curve.constants.ZERO_ADDRESS, tvl); });
-                                                        routesByTvl[token_address] = __spreadArray(__spreadArray([], ((_j = routesByTvl[token_address]) !== null && _j !== void 0 ? _j : []), true), newRoutesByTvl, true);
-                                                        routesByTvl[token_address] = filterRoutes(routesByTvl[token_address], inputCoinAddress, sortByTvl);
-                                                        routesByLength[token_address] = __spreadArray(__spreadArray([], ((_k = routesByLength[token_address]) !== null && _k !== void 0 ? _k : []), true), newRoutesByLength, true);
-                                                        routesByLength[token_address] = filterRoutes(routesByLength[token_address], inputCoinAddress, sortByLength);
-                                                        nextCoins.add(token_address);
-                                                    }
-                                                }
-                                                // Wrapped swaps
-                                                if (inCoinIndexes.wrapped_coin >= 0 && !poolData.is_fake) {
-                                                    _loop_4 = function (j) {
-                                                        if (j === inCoinIndexes.wrapped_coin)
-                                                            return "continue";
-                                                        // Native swaps spend less gas
-                                                        // TODO uncomment
-                                                        // 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 === 3 && wrapped_coin_addresses[j] !== outputCoinAddress)
-                                                            return "continue";
-                                                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
-                                                        var outputCoinIdx = wrapped_coin_addresses.indexOf(outputCoinAddress);
-                                                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                                                            return "continue";
-                                                        var swapType = poolData.is_crypto ? 3 : 1;
-                                                        var newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolData.swap_address, inCoin, wrapped_coin_addresses[j], inCoinIndexes.wrapped_coin, j, swapType, curve.constants.ZERO_ADDRESS, tvl); });
-                                                        var newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolData.swap_address, inCoin, wrapped_coin_addresses[j], inCoinIndexes.wrapped_coin, j, swapType, curve.constants.ZERO_ADDRESS, tvl); });
-                                                        routesByTvl[wrapped_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_l = routesByTvl[wrapped_coin_addresses[j]]) !== null && _l !== void 0 ? _l : []), true), newRoutesByTvl, true);
-                                                        routesByTvl[wrapped_coin_addresses[j]] = filterRoutes(routesByTvl[wrapped_coin_addresses[j]], inputCoinAddress, sortByTvl);
-                                                        routesByLength[wrapped_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_m = routesByLength[wrapped_coin_addresses[j]]) !== null && _m !== void 0 ? _m : []), true), newRoutesByLength, true);
-                                                        routesByLength[wrapped_coin_addresses[j]] = filterRoutes(routesByLength[wrapped_coin_addresses[j]], inputCoinAddress, sortByLength);
-                                                        nextCoins.add(wrapped_coin_addresses[j]);
-                                                    };
-                                                    for (j = 0; j < wrapped_coin_addresses.length; j++) {
-                                                        _loop_4(j);
-                                                    }
-                                                }
-                                                // Only for underlying swaps
-                                                poolAddress = (poolData.is_crypto && poolData.is_meta) || ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ?
-                                                    poolData.deposit_address : poolData.swap_address;
-                                                // Underlying swaps
-                                                if (!poolData.is_plain && inCoinIndexes.underlying_coin >= 0) {
-                                                    _loop_5 = function (j) {
-                                                        if (j === inCoinIndexes.underlying_coin)
-                                                            return "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]))
-                                                            return "continue";
-                                                        // Looking for outputCoinAddress only on the final step
-                                                        if (step === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
-                                                            return "continue";
-                                                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
-                                                        var outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
-                                                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                                                            return "continue";
-                                                        // Skip empty pools
-                                                        if (tvl === 0)
-                                                            return "continue";
-                                                        var hasEth = (inCoin === curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve.constants.NATIVE_TOKEN.address);
-                                                        var swapType = (poolData.is_crypto && poolData.is_meta && poolData.is_factory) ? 6
-                                                            : ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ? 5
-                                                                : hasEth && poolId !== 'avaxcrypto' ? 3
-                                                                    : poolData.is_crypto ? 4
-                                                                        : 2;
-                                                        var newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, underlying_coin_addresses[j], inCoinIndexes.underlying_coin, j, swapType, (swapType === 5 || swapType === 6) ? poolData.swap_address : curve.constants.ZERO_ADDRESS, tvl); });
-                                                        var newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, underlying_coin_addresses[j], inCoinIndexes.underlying_coin, j, swapType, (swapType === 5 || swapType === 6) ? poolData.swap_address : curve.constants.ZERO_ADDRESS, tvl); });
-                                                        routesByTvl[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_o = routesByTvl[underlying_coin_addresses[j]]) !== null && _o !== void 0 ? _o : []), true), newRoutesByTvl, true);
-                                                        routesByTvl[underlying_coin_addresses[j]] = filterRoutes(routesByTvl[underlying_coin_addresses[j]], inputCoinAddress, sortByTvl);
-                                                        routesByLength[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_p = routesByLength[underlying_coin_addresses[j]]) !== null && _p !== void 0 ? _p : []), true), newRoutesByLength, true);
-                                                        routesByLength[underlying_coin_addresses[j]] = filterRoutes(routesByLength[underlying_coin_addresses[j]], inputCoinAddress, sortByLength);
-                                                        nextCoins.add(underlying_coin_addresses[j]);
-                                                    };
-                                                    for (j = 0; j < underlying_coin_addresses.length; j++) {
-                                                        _loop_5(j);
-                                                    }
-                                                }
-                                                return [2 /*return*/];
-                                        }
-                                    });
-                                };
-                                _t = 0, ALL_POOLS_1 = ALL_POOLS;
-                                _v.label = 1;
-                            case 1:
-                                if (!(_t < ALL_POOLS_1.length)) return [3 /*break*/, 4];
-                                _u = ALL_POOLS_1[_t], poolId = _u[0], poolData = _u[1];
-                                return [5 /*yield**/, _loop_2(poolId, poolData)];
-                            case 2:
-                                _v.sent();
-                                _v.label = 3;
-                            case 3:
-                                _t++;
-                                return [3 /*break*/, 1];
-                            case 4: return [2 /*return*/];
-                        }
-                    });
-                };
+                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*/, 6];
+                if (!(_i < curCoins_1.length)) return [3 /*break*/, 8];
                 inCoin = curCoins_1[_i];
-                return [5 /*yield**/, _loop_1(inCoin)];
+                // 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);
+                }
+                // 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()]);
+                    }
+                }
+                // 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);
+                }
+                // 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);
+                }
+                // 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)) {
+                    // @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", 
+                        // @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);
+                    }
+                }
+                _e = 0, ALL_POOLS_1 = ALL_POOLS;
+                _s.label = 4;
             case 4:
-                _s.sent();
-                _s.label = 5;
+                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;
+                // 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];
+                return [4 /*yield*/, _getTVL(poolId)];
             case 5:
+                tvl = (_s.sent()) * tvl_multiplier;
+                // Skip empty pools
+                if (curve.chainId === 1 && tvl < 1000)
+                    return [3 /*break*/, 6];
+                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]);
+                    }
+                }
+                // 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);
+                    }
+                }
+                // 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]);
+                    }
+                }
+                // 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) ?
+                    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]);
+                    }
+                }
+                _s.label = 6;
+            case 6:
+                _e++;
+                return [3 /*break*/, 4];
+            case 7:
                 _i++;
                 return [3 /*break*/, 3];
-            case 6:
+            case 8:
                 curCoins = Array.from(nextCoins);
                 nextCoins = new Set();
-                _s.label = 7;
-            case 7:
+                _s.label = 9;
+            case 9:
                 step++;
                 return [3 /*break*/, 2];
-            case 8:
+            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; })];
         }
@@ -366,42 +380,54 @@ var _getRouteKey = function (route, inputCoinAddress, outputCoinAddress) {
     key += sortedCoins[1];
     return key;
 };
-var _getExchangeMultipleArgs = function (route) {
+var _getExchangeArgs = function (route) {
     var _route = [];
     if (route.length > 0)
         _route.push(route[0].inputCoinAddress);
     var _swapParams = [];
-    var _factorySwapAddresses = [];
+    var _pools = [];
+    var _basePools = [];
+    var _baseTokens = [];
+    var _secondBasePools = [];
+    var _secondBaseTokens = [];
     for (var _i = 0, route_2 = route; _i < route_2.length; _i++) {
         var routeStep = route_2[_i];
-        _route.push(routeStep.poolAddress, routeStep.outputCoinAddress);
-        _swapParams.push([routeStep.i, routeStep.j, routeStep.swapType]);
-        _factorySwapAddresses.push(routeStep.swapAddress);
+        _route.push(routeStep.swapAddress, routeStep.outputCoinAddress);
+        _swapParams.push(routeStep.swapParams);
+        _pools.push(routeStep.poolAddress);
+        _basePools.push(routeStep.basePool);
+        _baseTokens.push(routeStep.baseToken);
+        _secondBasePools.push(routeStep.secondBasePool);
+        _secondBaseTokens.push(routeStep.secondBaseToken);
     }
-    _route = _route.concat(Array(9 - _route.length).fill(curve.constants.ZERO_ADDRESS));
-    _swapParams = _swapParams.concat(Array(4 - _swapParams.length).fill([0, 0, 0]));
-    _factorySwapAddresses = _factorySwapAddresses.concat(Array(4 - _factorySwapAddresses.length).fill(curve.constants.ZERO_ADDRESS));
-    return { _route: _route, _swapParams: _swapParams, _factorySwapAddresses: _factorySwapAddresses };
+    _route = _route.concat(Array(ROUTE_LENGTH - _route.length).fill(curve.constants.ZERO_ADDRESS));
+    _swapParams = _swapParams.concat(Array(MAX_STEPS - _swapParams.length).fill([0, 0, 0, 0, 0]));
+    _pools = _pools.concat(Array(MAX_STEPS - _pools.length).fill(curve.constants.ZERO_ADDRESS));
+    _basePools = _basePools.concat(Array(MAX_STEPS - _basePools.length).fill(curve.constants.ZERO_ADDRESS));
+    _baseTokens = _baseTokens.concat(Array(MAX_STEPS - _baseTokens.length).fill(curve.constants.ZERO_ADDRESS));
+    _secondBasePools = _secondBasePools.concat(Array(MAX_STEPS - _secondBasePools.length).fill(curve.constants.ZERO_ADDRESS));
+    _secondBaseTokens = _secondBaseTokens.concat(Array(MAX_STEPS - _secondBaseTokens.length).fill(curve.constants.ZERO_ADDRESS));
+    return { _route: _route, _swapParams: _swapParams, _pools: _pools, _basePools: _basePools, _baseTokens: _baseTokens, _secondBasePools: _secondBasePools, _secondBaseTokens: _secondBaseTokens };
 };
 var _estimatedGasForDifferentRoutesCache = {};
 var _estimateGasForDifferentRoutes = function (routes, inputCoinAddress, outputCoinAddress, _amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var contract, gasPromises, value, _i, routes_1, route, routeKey, gasPromise, _a, _route, _swapParams, _factorySwapAddresses, _gasAmounts_1, err_1;
+    var contract, gasPromises, value, _i, routes_1, route, routeKey, gasPromise, _a, _route, _swapParams, _pools, _gasAmounts_1, err_1;
     var _b;
     return __generator(this, function (_c) {
         switch (_c.label) {
             case 0:
                 inputCoinAddress = inputCoinAddress.toLowerCase();
                 outputCoinAddress = outputCoinAddress.toLowerCase();
-                contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
+                contract = curve.contracts[curve.constants.ALIASES.router].contract;
                 gasPromises = [];
                 value = isEth(inputCoinAddress) ? _amount : curve.parseUnits("0");
                 for (_i = 0, routes_1 = routes; _i < routes_1.length; _i++) {
                     route = routes_1[_i];
                     routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
                     gasPromise = void 0;
-                    _a = _getExchangeMultipleArgs(route), _route = _a._route, _swapParams = _a._swapParams, _factorySwapAddresses = _a._factorySwapAddresses;
+                    _a = _getExchangeArgs(route), _route = _a._route, _swapParams = _a._swapParams, _pools = _a._pools;
                     if ((((_b = _estimatedGasForDifferentRoutesCache[routeKey]) === null || _b === void 0 ? void 0 : _b.time) || 0) + 3600000 < Date.now()) {
-                        gasPromise = contract.exchange_multiple.estimateGas(_route, _swapParams, _amount, 0, _factorySwapAddresses, __assign(__assign({}, curve.constantOptions), { value: value }));
+                        gasPromise = contract.exchange.estimateGas(_route, _swapParams, _amount, 0, _pools, __assign(__assign({}, curve.constantOptions), { value: value }));
                     }
                     else {
                         gasPromise = Promise.resolve(_estimatedGasForDifferentRoutesCache[routeKey].gas);
@@ -427,7 +453,7 @@ var _estimateGasForDifferentRoutes = function (routes, inputCoinAddress, outputC
     });
 }); };
 var _getBestRoute = memoize(function (inputCoinAddress, outputCoinAddress, amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, inputCoinDecimals, outputCoinDecimals, _amount, routesRaw, routes, calls, multicallContract, _i, routesRaw_1, r, _b, _route, _swapParams, _factorySwapAddresses, _outputAmounts, i, err_2, contract, _outputs, _c, routesRaw_2, r, _d, _route, _swapParams, _factorySwapAddresses, _e, _f, e_1, i, _h, gasAmounts, outputCoinUsdRate, gasData, ethUsdRate, gasPrice, expectedAmounts, expectedAmountsUsd, txCostsUsd;
+    var _a, inputCoinDecimals, outputCoinDecimals, _amount, routesRaw, routes, calls, multicallContract, _i, routesRaw_1, r, _b, _route, _swapParams, _pools, _outputAmounts, i, err_2, contract, _outputs, _c, routesRaw_2, r, _d, _route, _swapParams, _pools, _e, _f, e_1, i, _h, gasAmounts, outputCoinUsdRate, gasData, ethUsdRate, gasPrice, expectedAmounts, expectedAmountsUsd, txCostsUsd;
     return __generator(this, function (_j) {
         switch (_j.label) {
             case 0:
@@ -443,11 +469,11 @@ var _getBestRoute = memoize(function (inputCoinAddress, outputCoinAddress, amoun
             case 2:
                 _j.trys.push([2, 4, , 11]);
                 calls = [];
-                multicallContract = curve.contracts[curve.constants.ALIASES.registry_exchange].multicallContract;
+                multicallContract = curve.contracts[curve.constants.ALIASES.router].multicallContract;
                 for (_i = 0, routesRaw_1 = routesRaw; _i < routesRaw_1.length; _i++) {
                     r = routesRaw_1[_i];
-                    _b = _getExchangeMultipleArgs(r.route), _route = _b._route, _swapParams = _b._swapParams, _factorySwapAddresses = _b._factorySwapAddresses;
-                    calls.push(multicallContract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses));
+                    _b = _getExchangeArgs(r.route), _route = _b._route, _swapParams = _b._swapParams, _pools = _b._pools;
+                    calls.push(multicallContract.get_dy(_route, _swapParams, _amount, _pools));
                 }
                 return [4 /*yield*/, curve.multicallProvider.all(calls)];
             case 3:
@@ -459,19 +485,19 @@ var _getBestRoute = memoize(function (inputCoinAddress, outputCoinAddress, amoun
                 return [3 /*break*/, 11];
             case 4:
                 err_2 = _j.sent();
-                contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
+                contract = curve.contracts[curve.constants.ALIASES.router].contract;
                 _outputs = [];
                 _c = 0, routesRaw_2 = routesRaw;
                 _j.label = 5;
             case 5:
                 if (!(_c < routesRaw_2.length)) return [3 /*break*/, 10];
                 r = routesRaw_2[_c];
-                _d = _getExchangeMultipleArgs(r.route), _route = _d._route, _swapParams = _d._swapParams, _factorySwapAddresses = _d._factorySwapAddresses;
+                _d = _getExchangeArgs(r.route), _route = _d._route, _swapParams = _d._swapParams, _pools = _d._pools;
                 _j.label = 6;
             case 6:
                 _j.trys.push([6, 8, , 9]);
                 _f = (_e = _outputs).push;
-                return [4 /*yield*/, contract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses, curve.constantOptions)];
+                return [4 /*yield*/, contract.get_dy(_route, _swapParams, _amount, _pools, curve.constantOptions)];
             case 7:
                 _f.apply(_e, [_j.sent()]);
                 return [3 /*break*/, 9];
@@ -528,13 +554,13 @@ var _getBestRoute = memoize(function (inputCoinAddress, outputCoinAddress, amoun
     maxAge: 5 * 60 * 1000, // 5m
 });
 var _getOutputForRoute = memoize(function (route, _amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var contract, _a, _route, _swapParams, _factorySwapAddresses;
+    var contract, _a, _route, _swapParams, _pools;
     return __generator(this, function (_b) {
         switch (_b.label) {
             case 0:
-                contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
-                _a = _getExchangeMultipleArgs(route), _route = _a._route, _swapParams = _a._swapParams, _factorySwapAddresses = _a._factorySwapAddresses;
-                return [4 /*yield*/, contract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses, curve.constantOptions)];
+                contract = curve.contracts[curve.constants.ALIASES.router].contract;
+                _a = _getExchangeArgs(route), _route = _a._route, _swapParams = _a._swapParams, _pools = _a._pools;
+                return [4 /*yield*/, contract.get_dy(_route, _swapParams, _amount, _pools, curve.constantOptions)];
             case 1: return [2 /*return*/, _b.sent()];
         }
     });
@@ -561,6 +587,9 @@ export var getBestRouteAndOutput = function (inputCoin, outputCoin, amount) { re
         }
     });
 }); };
+export var getArgs = function (route) {
+    return _getExchangeArgs(route);
+};
 export var swapExpected = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {
@@ -569,8 +598,33 @@ export var swapExpected = function (inputCoin, outputCoin, amount) { return __aw
         }
     });
 }); };
+export var swapRequired = function (route, outAmount) { return __awaiter(void 0, void 0, void 0, function () {
+    var inputCoinAddress, outputCoinAddress, _a, inputCoinDecimals, outputCoinDecimals, _outAmount, contract, _b, _route, _swapParams, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens, _required;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                inputCoinAddress = route[0].inputCoinAddress;
+                outputCoinAddress = route[route.length - 1].outputCoinAddress;
+                _a = _getCoinDecimals(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _a[0], outputCoinDecimals = _a[1];
+                _outAmount = parseUnits(outAmount, outputCoinDecimals);
+                contract = curve.contracts[curve.constants.ALIASES.router].contract;
+                _b = _getExchangeArgs(route), _route = _b._route, _swapParams = _b._swapParams, _pools = _b._pools, _basePools = _b._basePools, _baseTokens = _b._baseTokens, _secondBasePools = _b._secondBasePools, _secondBaseTokens = _b._secondBaseTokens;
+                _required = 0;
+                if (!("get_dx(address[11],uint256[5][5],uint256,address[5],address[5],address[5],address[5],address[5])" in contract)) return [3 /*break*/, 2];
+                return [4 /*yield*/, contract.get_dx(_route, _swapParams, _outAmount, _pools, _basePools, _baseTokens, _secondBasePools, _secondBaseTokens, curve.constantOptions)];
+            case 1:
+                _required = _c.sent();
+                return [3 /*break*/, 4];
+            case 2: return [4 /*yield*/, contract.get_dx(_route, _swapParams, _outAmount, _pools, _basePools, _baseTokens, curve.constantOptions)];
+            case 3:
+                _required = _c.sent();
+                _c.label = 4;
+            case 4: return [2 /*return*/, curve.formatUnits(_required, inputCoinDecimals)];
+        }
+    });
+}); };
 export var swapPriceImpact = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _c, route, output, _amount, _output, smallAmountIntBN, amountIntBN, contract, _smallAmount, _d, _route, _swapParams, _factorySwapAddresses, _smallOutput, e_2, priceImpactBN;
+    var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _c, route, output, _amount, _output, smallAmountIntBN, amountIntBN, contract, _smallAmount, _d, _route, _swapParams, _pools, _smallOutput, e_2, priceImpactBN;
     return __generator(this, function (_e) {
         switch (_e.label) {
             case 0:
@@ -585,20 +639,20 @@ export var swapPriceImpact = function (inputCoin, outputCoin, amount) { return _
                 amountIntBN = toBN(_amount, 0);
                 if (smallAmountIntBN.gte(amountIntBN))
                     return [2 /*return*/, 0];
-                contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
+                contract = curve.contracts[curve.constants.ALIASES.router].contract;
                 _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
-                _d = _getExchangeMultipleArgs(route), _route = _d._route, _swapParams = _d._swapParams, _factorySwapAddresses = _d._factorySwapAddresses;
+                _d = _getExchangeArgs(route), _route = _d._route, _swapParams = _d._swapParams, _pools = _d._pools;
                 _e.label = 2;
             case 2:
                 _e.trys.push([2, 4, , 6]);
-                return [4 /*yield*/, contract.get_exchange_multiple_amount(_route, _swapParams, _smallAmount, _factorySwapAddresses, curve.constantOptions)];
+                return [4 /*yield*/, contract.get_dy(_route, _swapParams, _smallAmount, _pools, curve.constantOptions)];
             case 3:
                 _smallOutput = _e.sent();
                 return [3 /*break*/, 6];
             case 4:
                 e_2 = _e.sent();
                 _smallAmount = curve.parseUnits("1", inputCoinDecimals); // Dirty hack
-                return [4 /*yield*/, contract.get_exchange_multiple_amount(_route, _swapParams, _smallAmount, _factorySwapAddresses, curve.constantOptions)];
+                return [4 /*yield*/, contract.get_dy(_route, _swapParams, _smallAmount, _pools, curve.constantOptions)];
             case 5:
                 _smallOutput = _e.sent();
                 return [3 /*break*/, 6];
@@ -611,7 +665,7 @@ export var swapPriceImpact = function (inputCoin, outputCoin, amount) { return _
 export var swapIsApproved = function (inputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, hasAllowance([inputCoin], [amount], curve.signerAddress, curve.constants.ALIASES.registry_exchange)];
+            case 0: return [4 /*yield*/, hasAllowance([inputCoin], [amount], curve.signerAddress, curve.constants.ALIASES.router)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
@@ -619,7 +673,7 @@ export var swapIsApproved = function (inputCoin, amount) { return __awaiter(void
 export var swapApproveEstimateGas = function (inputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([inputCoin], [amount], curve.constants.ALIASES.registry_exchange)];
+            case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([inputCoin], [amount], curve.constants.ALIASES.router)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
@@ -627,7 +681,7 @@ export var swapApproveEstimateGas = function (inputCoin, amount) { return __awai
 export var swapApprove = function (inputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         switch (_a.label) {
-            case 0: return [4 /*yield*/, ensureAllowance([inputCoin], [amount], curve.constants.ALIASES.registry_exchange)];
+            case 0: return [4 /*yield*/, ensureAllowance([inputCoin], [amount], curve.constants.ALIASES.router)];
             case 1: return [2 /*return*/, _a.sent()];
         }
     });
@@ -655,7 +709,7 @@ export var swapEstimateGas = function (inputCoin, outputCoin, amount) { return _
 export var swap = function (inputCoin, outputCoin, amount, slippage) {
     if (slippage === void 0) { slippage = 0.5; }
     return __awaiter(void 0, void 0, void 0, function () {
-        var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _c, route, output, _d, _route, _swapParams, _factorySwapAddresses, _amount, minRecvAmountBN, _minRecvAmount, contract, value, gasLimit;
+        var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, _c, route, output, _d, _route, _swapParams, _pools, _amount, minRecvAmountBN, _minRecvAmount, contract, value, gasLimit;
         return __generator(this, function (_e) {
             switch (_e.label) {
                 case 0:
@@ -670,19 +724,19 @@ export var swap = function (inputCoin, outputCoin, amount, slippage) {
                     if (route.length === 0) {
                         throw new Error("This pair can't be exchanged");
                     }
-                    _d = _getExchangeMultipleArgs(route), _route = _d._route, _swapParams = _d._swapParams, _factorySwapAddresses = _d._factorySwapAddresses;
+                    _d = _getExchangeArgs(route), _route = _d._route, _swapParams = _d._swapParams, _pools = _d._pools;
                     _amount = parseUnits(amount, inputCoinDecimals);
                     minRecvAmountBN = BN(output).times(100 - slippage).div(100);
                     _minRecvAmount = fromBN(minRecvAmountBN, outputCoinDecimals);
-                    contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
+                    contract = curve.contracts[curve.constants.ALIASES.router].contract;
                     value = isEth(inputCoinAddress) ? _amount : curve.parseUnits("0");
                     return [4 /*yield*/, curve.updateFeeData()];
                 case 3:
                     _e.sent();
-                    return [4 /*yield*/, contract.exchange_multiple.estimateGas(_route, _swapParams, _amount, _minRecvAmount, _factorySwapAddresses, __assign(__assign({}, curve.constantOptions), { value: value }))];
+                    return [4 /*yield*/, contract.exchange.estimateGas(_route, _swapParams, _amount, _minRecvAmount, _pools, __assign(__assign({}, curve.constantOptions), { value: value }))];
                 case 4:
                     gasLimit = (_e.sent()) * (curve.chainId === 1 ? curve.parseUnits("130", 0) : curve.parseUnits("160", 0)) / curve.parseUnits("100", 0);
-                    return [4 /*yield*/, contract.exchange_multiple(_route, _swapParams, _amount, _minRecvAmount, _factorySwapAddresses, __assign(__assign({}, curve.options), { value: value, gasLimit: gasLimit }))];
+                    return [4 /*yield*/, contract.exchange(_route, _swapParams, _amount, _minRecvAmount, _pools, __assign(__assign({}, curve.options), { value: value, gasLimit: gasLimit }))];
                 case 5: return [2 /*return*/, _e.sent()];
             }
         });
@@ -703,7 +757,7 @@ export var getSwappedAmount = function (tx, outputCoin) { return __awaiter(void
                 for (i = 1; i <= txInfo.logs.length; i++) {
                     try {
                         abiCoder = ethers.AbiCoder.defaultAbiCoder();
-                        res = abiCoder.decode(['address[9]', 'uint256[3][4]', 'address[4]', 'uint256', 'uint256'], ethers.dataSlice(txInfo.logs[txInfo.logs.length - i].data, 0));
+                        res = abiCoder.decode(["address[".concat(ROUTE_LENGTH, "]"), "uint256[".concat(MAX_STEPS, "][").concat(MAX_STEPS, "]"), "address[".concat(MAX_STEPS, "]"), 'uint256', 'uint256'], ethers.dataSlice(txInfo.logs[txInfo.logs.length - i].data, 0));
                         break;
                     }
                     catch (err) { }