@curvefi/api 2.31.1 → 2.33.0

package/lib/router.js

@@ -1,3 +1,59 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import axios from "axios";
 import memoize from "memoizee";
 import { ethers } from "ethers";
@@ -5,8 +61,8 @@ 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";
-const getNewRoute = (routeTvl, poolId, poolAddress, inputCoinAddress, outputCoinAddress, i, j, swapType, swapAddress, tvl) => {
-    const routePoolIds = routeTvl.route.map((s) => s.poolId);
+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)
         return { route: [], minTvl: Infinity, totalTvl: 0 };
@@ -14,15 +70,16 @@ const getNewRoute = (routeTvl, poolId, poolAddress, inputCoinAddress, outputCoin
     if (routePoolIds.includes(poolId))
         return { route: [], minTvl: Infinity, totalTvl: 0 };
     return {
-        route: [...routeTvl.route, { poolId, poolAddress, inputCoinAddress, outputCoinAddress, i, j, swapType, swapAddress }],
+        route: __spreadArray(__spreadArray([], routeTvl.route, true), [{ poolId: poolId, poolAddress: poolAddress, inputCoinAddress: inputCoinAddress, outputCoinAddress: outputCoinAddress, i: i, j: j, swapType: swapType, swapAddress: swapAddress }], false),
         minTvl: Math.min(tvl, routeTvl.minTvl),
         totalTvl: routeTvl.totalTvl + tvl,
     };
 };
 // TODO REMOVE IT!!!
-const filterMaticFactory83Route = (routes) => {
-    return routes.filter((r) => {
-        for (const step of r.route) {
+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;
         }
@@ -30,213 +87,296 @@ const filterMaticFactory83Route = (routes) => {
     });
 };
 // TODO REMOVE IT!!!
-const filterAvax = (routes) => {
-    return routes.filter((r) => {
-        for (const step of r.route) {
+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;
     });
 };
-const MAX_ROUTES_FOR_ONE_COIN = 3;
-const filterRoutes = (routes, inputCoinAddress, sortFn) => {
+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);
     return routes
-        .filter((r) => r.route.length > 0)
-        .filter((r) => r.route[0].inputCoinAddress === inputCoinAddress) // Truncated routes
-        .filter((r, i, _routes) => {
-        const routesByPoolIds = _routes.map((r) => r.route.map((s) => s.poolId).toString());
-        return routesByPoolIds.indexOf(r.route.map((s) => s.poolId).toString()) === i;
+        .filter(function (r) { return r.route.length > 0; })
+        .filter(function (r) { return r.route[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
+        .filter(function (r, i, _routes) {
+        var routesByPoolIds = _routes.map(function (r) { return r.route.map(function (s) { return s.poolId; }).toString(); });
+        return routesByPoolIds.indexOf(r.route.map(function (s) { return s.poolId; }).toString()) === i;
     }) // Route duplications
         .sort(sortFn).slice(0, MAX_ROUTES_FOR_ONE_COIN);
 };
-const sortByTvl = (a, b) => b.minTvl - a.minTvl || b.totalTvl - a.totalTvl || a.route.length - b.route.length;
-const sortByLength = (a, b) => 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; };
 // Inspired by Dijkstra's algorithm
-const _findAllRoutes = async (inputCoinAddress, outputCoinAddress) => {
-    inputCoinAddress = inputCoinAddress.toLowerCase();
-    outputCoinAddress = outputCoinAddress.toLowerCase();
-    const ALL_POOLS = Object.entries({
-        ...curve.constants.POOLS_DATA,
-        ...curve.constants.FACTORY_POOLS_DATA,
-        ...curve.constants.CRYPTO_FACTORY_POOLS_DATA,
-    });
-    const amplificationCoefficientDict = await _getAmplificationCoefficientsFromApi();
-    // Coins we are searching routes for on the current step
-    let curCoins = [inputCoinAddress];
-    // Coins we will search routes for on the next step
-    let nextCoins = new Set();
-    // Routes for all coins found
-    const routesByTvl = {
-        [inputCoinAddress]: [{ route: [], minTvl: Infinity, totalTvl: 0 }],
-    };
-    const routesByLength = {
-        [inputCoinAddress]: [{ route: [], minTvl: Infinity, totalTvl: 0 }],
-    };
-    // No more than 4 steps (swaps)
-    for (let step = 0; step < 4; step++) {
-        for (const inCoin of curCoins) {
-            if (curve.chainId !== 42220 && [curve.constants.NATIVE_TOKEN.address, curve.constants.NATIVE_TOKEN.wrappedAddress].includes(inCoin)) { // Exclude Celo
-                const outCoin = inCoin === curve.constants.NATIVE_TOKEN.address ? curve.constants.NATIVE_TOKEN.wrappedAddress : curve.constants.NATIVE_TOKEN.address;
-                const newRoutesByTvl = routesByTvl[inCoin].map((route) => getNewRoute(route, "wrapper", curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin, 0, 0, 15, curve.constants.ZERO_ADDRESS, Infinity));
-                const newRoutesByLength = routesByLength[inCoin].map((route) => getNewRoute(route, "wrapper", curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin, 0, 0, 15, curve.constants.ZERO_ADDRESS, Infinity));
-                routesByTvl[outCoin] = [...(routesByTvl[outCoin] ?? []), ...newRoutesByTvl];
-                routesByTvl[outCoin] = filterRoutes(routesByTvl[outCoin], inputCoinAddress, sortByTvl);
-                routesByLength[outCoin] = [...(routesByLength[outCoin] ?? []), ...newRoutesByLength];
-                routesByLength[outCoin] = filterRoutes(routesByLength[outCoin], inputCoinAddress, sortByLength);
-                nextCoins.add(outCoin);
-            }
-            for (const [poolId, poolData] of ALL_POOLS) {
-                const wrapped_coin_addresses = poolData.wrapped_coin_addresses.map((a) => a.toLowerCase());
-                const underlying_coin_addresses = poolData.underlying_coin_addresses.map((a) => a.toLowerCase());
-                const base_pool = poolData.is_meta ? curve.constants.POOLS_DATA[poolData.base_pool] : null;
-                const meta_coin_addresses = base_pool ? base_pool.underlying_coin_addresses.map((a) => a.toLowerCase()) : [];
-                const token_address = poolData.token_address.toLowerCase();
-                const is_aave_like_lending = poolData.is_lending && wrapped_coin_addresses.length === 3 && !poolData.deposit_address;
-                const tvlMultiplier = poolData.is_crypto ? 1 : (amplificationCoefficientDict[poolData.swap_address] ?? 1);
-                const 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,
+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;
+    return __generator(this, function (_s) {
+        switch (_s.label) {
+            case 0:
+                inputCoinAddress = inputCoinAddress.toLowerCase();
+                outputCoinAddress = outputCoinAddress.toLowerCase();
+                ALL_POOLS = Object.entries(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA));
+                return [4 /*yield*/, _getAmplificationCoefficientsFromApi()];
+            case 1:
+                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);
+                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, _x, poolAddress, coin_addresses, _loop_3, j, inCoinIndex, swapType_1, newRoutesByTvl, newRoutesByLength, _loop_4, j, _loop_5, j;
+                                    return __generator(this, function (_y) {
+                                        switch (_y.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 ? curve.constants.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:
+                                                _x = Number;
+                                                return [4 /*yield*/, (getPool(poolId)).stats.totalLiquidity()];
+                                            case 2:
+                                                _w = _x.apply(void 0, [_y.sent()]) * tvlMultiplier;
+                                                _y.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) {
+                                                    // 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;
+                                                if (!(!poolData.is_plain && inCoinIndexes.underlying_coin >= 0)) return [3 /*break*/, 7];
+                                                _loop_5 = function (j) {
+                                                    var outputCoinIdx, tvl_1, _z, hasEth, swapType, newRoutesByTvl, newRoutesByLength;
+                                                    return __generator(this, function (_0) {
+                                                        switch (_0.label) {
+                                                            case 0:
+                                                                if (j === inCoinIndexes.underlying_coin)
+                                                                    return [2 /*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 [2 /*return*/, "continue"];
+                                                                // Looking for outputCoinAddress only on the final step
+                                                                if (step === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
+                                                                    return [2 /*return*/, "continue"];
+                                                                outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
+                                                                if (outputCoinIdx >= 0 && j !== outputCoinIdx)
+                                                                    return [2 /*return*/, "continue"];
+                                                                _z = Number;
+                                                                return [4 /*yield*/, (getPool(poolId)).stats.totalLiquidity()];
+                                                            case 1:
+                                                                tvl_1 = _z.apply(void 0, [_0.sent()]);
+                                                                if (tvl_1 === 0)
+                                                                    return [2 /*return*/, "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) ? 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;
+                                                                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_1); });
+                                                                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_1); });
+                                                                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]);
+                                                                return [2 /*return*/];
+                                                        }
+                                                    });
+                                                };
+                                                j = 0;
+                                                _y.label = 4;
+                                            case 4:
+                                                if (!(j < underlying_coin_addresses.length)) return [3 /*break*/, 7];
+                                                return [5 /*yield**/, _loop_5(j)];
+                                            case 5:
+                                                _y.sent();
+                                                _y.label = 6;
+                                            case 6:
+                                                j++;
+                                                return [3 /*break*/, 4];
+                                            case 7: 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*/];
+                        }
+                    });
                 };
-                // Skip pools which don't contain inCoin
-                if (inCoinIndexes.wrapped_coin === -1 && inCoinIndexes.underlying_coin === -1 && inCoinIndexes.meta_coin === -1 && inCoin !== token_address)
-                    continue;
-                const tvl = Number(await (getPool(poolId)).stats.totalLiquidity()) * tvlMultiplier;
-                // Skip empty pools
-                if (tvl === 0)
-                    continue;
-                let poolAddress = poolData.is_fake ? poolData.deposit_address : poolData.swap_address;
-                const 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) {
-                    for (let j = 0; j < coin_addresses.length; j++) {
-                        // Looking for outputCoinAddress only on the final step
-                        if (step === 3 && coin_addresses[j] !== outputCoinAddress)
-                            continue;
-                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
-                        const outputCoinIdx = coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        const swapType = poolData.is_crypto ? 14 : is_aave_like_lending ? 13 : 12;
-                        const newRoutesByTvl = routesByTvl[inCoin].map((route) => getNewRoute(route, poolId, poolAddress, inCoin, coin_addresses[j], 0, j, swapType, curve.constants.ZERO_ADDRESS, tvl));
-                        const newRoutesByLength = routesByLength[inCoin].map((route) => getNewRoute(route, poolId, poolAddress, inCoin, coin_addresses[j], 0, j, swapType, curve.constants.ZERO_ADDRESS, tvl));
-                        routesByTvl[coin_addresses[j]] = [...(routesByTvl[coin_addresses[j]] ?? []), ...newRoutesByTvl];
-                        routesByTvl[coin_addresses[j]] = filterRoutes(routesByTvl[coin_addresses[j]], inputCoinAddress, sortByTvl);
-                        routesByLength[coin_addresses[j]] = [...(routesByLength[coin_addresses[j]] ?? []), ...newRoutesByLength];
-                        routesByLength[coin_addresses[j]] = filterRoutes(routesByLength[coin_addresses[j]], inputCoinAddress, sortByLength);
-                        nextCoins.add(coin_addresses[j]);
-                    }
-                }
-                // Wrapped coin (underlying for lending or fake pool) -> LP "swaps" (actually add_liquidity)
-                const inCoinIndex = (is_aave_like_lending || poolData.is_fake) ? inCoinIndexes.underlying_coin : inCoinIndexes.wrapped_coin;
-                if (coin_addresses.length < 6 && inCoinIndex >= 0) {
-                    // Looking for outputCoinAddress only on the final step
-                    if (!(step === 3 && token_address !== outputCoinAddress)) {
-                        const swapType = is_aave_like_lending ? 9
-                            : coin_addresses.length === 2 ? 7
-                                : coin_addresses.length === 3 ? 8
-                                    : coin_addresses.length === 4 ? 10 : 11;
-                        const newRoutesByTvl = routesByTvl[inCoin].map((route) => getNewRoute(route, poolId, poolAddress, inCoin, token_address, coin_addresses.indexOf(inCoin), 0, swapType, curve.constants.ZERO_ADDRESS, tvl));
-                        const newRoutesByLength = routesByLength[inCoin].map((route) => getNewRoute(route, poolId, poolAddress, inCoin, token_address, coin_addresses.indexOf(inCoin), 0, swapType, curve.constants.ZERO_ADDRESS, tvl));
-                        routesByTvl[token_address] = [...(routesByTvl[token_address] ?? []), ...newRoutesByTvl];
-                        routesByTvl[token_address] = filterRoutes(routesByTvl[token_address], inputCoinAddress, sortByTvl);
-                        routesByLength[token_address] = [...(routesByLength[token_address] ?? []), ...newRoutesByLength];
-                        routesByLength[token_address] = filterRoutes(routesByLength[token_address], inputCoinAddress, sortByLength);
-                        nextCoins.add(token_address);
-                    }
-                }
-                // Wrapped swaps
-                if (inCoinIndexes.wrapped_coin >= 0 && !poolData.is_fake) {
-                    for (let j = 0; j < wrapped_coin_addresses.length; j++) {
-                        if (j === inCoinIndexes.wrapped_coin)
-                            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)
-                            continue;
-                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
-                        const outputCoinIdx = wrapped_coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        const swapType = poolData.is_crypto ? 3 : 1;
-                        const newRoutesByTvl = routesByTvl[inCoin].map((route) => getNewRoute(route, poolId, poolData.swap_address, inCoin, wrapped_coin_addresses[j], inCoinIndexes.wrapped_coin, j, swapType, curve.constants.ZERO_ADDRESS, tvl));
-                        const newRoutesByLength = routesByLength[inCoin].map((route) => 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]] = [...(routesByTvl[wrapped_coin_addresses[j]] ?? []), ...newRoutesByTvl];
-                        routesByTvl[wrapped_coin_addresses[j]] = filterRoutes(routesByTvl[wrapped_coin_addresses[j]], inputCoinAddress, sortByTvl);
-                        routesByLength[wrapped_coin_addresses[j]] = [...(routesByLength[wrapped_coin_addresses[j]] ?? []), ...newRoutesByLength];
-                        routesByLength[wrapped_coin_addresses[j]] = filterRoutes(routesByLength[wrapped_coin_addresses[j]], inputCoinAddress, sortByLength);
-                        nextCoins.add(wrapped_coin_addresses[j]);
-                    }
-                }
-                // Only for underlying swaps
-                poolAddress = (poolData.is_crypto && poolData.is_meta) || (base_pool?.is_lending && poolData.is_factory) ?
-                    poolData.deposit_address : poolData.swap_address;
-                // Underlying swaps
-                if (!poolData.is_plain && inCoinIndexes.underlying_coin >= 0) {
-                    for (let 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 === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
-                            continue;
-                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
-                        const outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
-                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                            continue;
-                        // Skip empty pools
-                        const tvl = Number(await (getPool(poolId)).stats.totalLiquidity());
-                        if (tvl === 0)
-                            continue;
-                        const hasEth = (inCoin === curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve.constants.NATIVE_TOKEN.address);
-                        const swapType = (poolData.is_crypto && poolData.is_meta && poolData.is_factory) ? 6
-                            : (base_pool?.is_lending && poolData.is_factory) ? 5
-                                : hasEth && poolId !== 'avaxcrypto' ? 3
-                                    : poolData.is_crypto ? 4
-                                        : 2;
-                        const newRoutesByTvl = routesByTvl[inCoin].map((route) => 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));
-                        const newRoutesByLength = routesByLength[inCoin].map((route) => 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]] = [...(routesByTvl[underlying_coin_addresses[j]] ?? []), ...newRoutesByTvl];
-                        routesByTvl[underlying_coin_addresses[j]] = filterRoutes(routesByTvl[underlying_coin_addresses[j]], inputCoinAddress, sortByTvl);
-                        routesByLength[underlying_coin_addresses[j]] = [...(routesByLength[underlying_coin_addresses[j]] ?? []), ...newRoutesByLength];
-                        routesByLength[underlying_coin_addresses[j]] = filterRoutes(routesByLength[underlying_coin_addresses[j]], inputCoinAddress, sortByLength);
-                        nextCoins.add(underlying_coin_addresses[j]);
-                    }
-                }
-            }
+                _i = 0, curCoins_1 = curCoins;
+                _s.label = 3;
+            case 3:
+                if (!(_i < curCoins_1.length)) return [3 /*break*/, 6];
+                inCoin = curCoins_1[_i];
+                return [5 /*yield**/, _loop_1(inCoin)];
+            case 4:
+                _s.sent();
+                _s.label = 5;
+            case 5:
+                _i++;
+                return [3 /*break*/, 3];
+            case 6:
+                curCoins = Array.from(nextCoins);
+                nextCoins = new Set();
+                _s.label = 7;
+            case 7:
+                step++;
+                return [3 /*break*/, 2];
+            case 8:
+                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; })];
         }
-        curCoins = Array.from(nextCoins);
-        nextCoins = new Set();
-    }
-    const routes = [...(routesByTvl[outputCoinAddress] ?? []), ...(routesByLength[outputCoinAddress] ?? [])];
-    return routes.map((r) => r.route);
-};
-const _getRouteKey = (route, inputCoinAddress, outputCoinAddress) => {
-    const sortedCoins = [inputCoinAddress, outputCoinAddress].sort();
-    let key = `${sortedCoins[0]}-->`;
-    for (const routeStep of route) {
-        key += `${routeStep.poolId}-->`;
+    });
+}); };
+var _getRouteKey = function (route, inputCoinAddress, outputCoinAddress) {
+    var sortedCoins = [inputCoinAddress, outputCoinAddress].sort();
+    var key = "".concat(sortedCoins[0], "-->");
+    for (var _i = 0, route_1 = route; _i < route_1.length; _i++) {
+        var routeStep = route_1[_i];
+        key += "".concat(routeStep.poolId, "-->");
     }
     key += sortedCoins[1];
     return key;
 };
-const _getExchangeMultipleArgs = (route) => {
-    let _route = [];
+var _getExchangeMultipleArgs = function (route) {
+    var _route = [];
     if (route.length > 0)
         _route.push(route[0].inputCoinAddress);
-    let _swapParams = [];
-    let _factorySwapAddresses = [];
-    for (const routeStep of route) {
+    var _swapParams = [];
+    var _factorySwapAddresses = [];
+    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);
@@ -244,204 +384,322 @@ const _getExchangeMultipleArgs = (route) => {
     _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, _swapParams, _factorySwapAddresses };
+    return { _route: _route, _swapParams: _swapParams, _factorySwapAddresses: _factorySwapAddresses };
 };
-const _estimatedGasForDifferentRoutesCache = {};
-const _estimateGasForDifferentRoutes = async (routes, inputCoinAddress, outputCoinAddress, _amount) => {
-    inputCoinAddress = inputCoinAddress.toLowerCase();
-    outputCoinAddress = outputCoinAddress.toLowerCase();
-    const contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
-    const gasPromises = [];
-    const value = isEth(inputCoinAddress) ? _amount : 0n;
-    for (const route of routes) {
-        const routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
-        let gasPromise;
-        const { _route, _swapParams, _factorySwapAddresses } = _getExchangeMultipleArgs(route);
-        if ((_estimatedGasForDifferentRoutesCache[routeKey]?.time || 0) + 3600000 < Date.now()) {
-            gasPromise = contract.exchange_multiple.estimateGas(_route, _swapParams, _amount, 0, _factorySwapAddresses, { ...curve.constantOptions, value });
-        }
-        else {
-            gasPromise = Promise.resolve(_estimatedGasForDifferentRoutesCache[routeKey].gas);
-        }
-        gasPromises.push(gasPromise);
-    }
-    try {
-        const _gasAmounts = await Promise.all(gasPromises);
-        routes.forEach((route, i) => {
-            const routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
-            _estimatedGasForDifferentRoutesCache[routeKey] = { 'gas': _gasAmounts[i], 'time': Date.now() };
-        });
-        return _gasAmounts.map((_g) => Number(curve.formatUnits(_g, 0)));
-    }
-    catch (err) { // No allowance
-        return routes.map(() => 0);
-    }
-};
-const _getBestRoute = memoize(async (inputCoinAddress, outputCoinAddress, amount) => {
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    if (_amount === 0n)
-        return [];
-    const routesRaw = (await _findAllRoutes(inputCoinAddress, outputCoinAddress)).map((route) => ({ route, _output: 0n, outputUsd: 0, txCostUsd: 0 }));
-    const routes = [];
-    try {
-        const calls = [];
-        const multicallContract = curve.contracts[curve.constants.ALIASES.registry_exchange].multicallContract;
-        for (const r of routesRaw) {
-            const { _route, _swapParams, _factorySwapAddresses } = _getExchangeMultipleArgs(r.route);
-            calls.push(multicallContract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses));
-        }
-        const _outputAmounts = await curve.multicallProvider.all(calls);
-        for (let i = 0; i < _outputAmounts.length; i++) {
-            routesRaw[i]._output = _outputAmounts[i];
-            routes.push(routesRaw[i]);
-        }
-    }
-    catch (err) {
-        const promises = [];
-        const contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
-        for (const r of routesRaw) {
-            const { _route, _swapParams, _factorySwapAddresses } = _getExchangeMultipleArgs(r.route);
-            promises.push(contract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses, curve.constantOptions));
+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 _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;
+                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;
+                    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 }));
+                    }
+                    else {
+                        gasPromise = Promise.resolve(_estimatedGasForDifferentRoutesCache[routeKey].gas);
+                    }
+                    gasPromises.push(gasPromise);
+                }
+                _c.label = 1;
+            case 1:
+                _c.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, Promise.all(gasPromises)];
+            case 2:
+                _gasAmounts_1 = _c.sent();
+                routes.forEach(function (route, i) {
+                    var routeKey = _getRouteKey(route, inputCoinAddress, outputCoinAddress);
+                    _estimatedGasForDifferentRoutesCache[routeKey] = { 'gas': _gasAmounts_1[i], 'time': Date.now() };
+                });
+                return [2 /*return*/, _gasAmounts_1.map(function (_g) { return Number(curve.formatUnits(_g, 0)); })];
+            case 3:
+                err_1 = _c.sent();
+                return [2 /*return*/, routes.map(function () { return 0; })];
+            case 4: return [2 /*return*/];
         }
-        // @ts-ignore
-        const res = await Promise.allSettled(promises);
-        for (let i = 0; i < res.length; i++) {
-            if (res[i].status === 'rejected') {
-                console.log(`Route ${(routesRaw[i].route.map((s) => s.poolId)).join(" --> ")} is unavailable`);
-                continue;
-            }
-            routesRaw[i]._output = res[i].value;
-            routes.push(routesRaw[i]);
+    });
+}); };
+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, promises, contract, _c, routesRaw_2, r, _d, _route, _swapParams, _factorySwapAddresses, res, i, _e, gasAmounts, outputCoinUsdRate, gasData, ethUsdRate, gasPrice, expectedAmounts, expectedAmountsUsd, txCostsUsd;
+    return __generator(this, function (_f) {
+        switch (_f.label) {
+            case 0:
+                _a = _getCoinDecimals(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _a[0], outputCoinDecimals = _a[1];
+                _amount = parseUnits(amount, inputCoinDecimals);
+                if (_amount === curve.parseUnits("0"))
+                    return [2 /*return*/, []];
+                return [4 /*yield*/, _findAllRoutes(inputCoinAddress, outputCoinAddress)];
+            case 1:
+                routesRaw = (_f.sent()).map(function (route) { return ({ route: route, _output: curve.parseUnits("0"), outputUsd: 0, txCostUsd: 0 }); });
+                routes = [];
+                _f.label = 2;
+            case 2:
+                _f.trys.push([2, 4, , 6]);
+                calls = [];
+                multicallContract = curve.contracts[curve.constants.ALIASES.registry_exchange].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));
+                }
+                return [4 /*yield*/, curve.multicallProvider.all(calls)];
+            case 3:
+                _outputAmounts = _f.sent();
+                for (i = 0; i < _outputAmounts.length; i++) {
+                    routesRaw[i]._output = _outputAmounts[i];
+                    routes.push(routesRaw[i]);
+                }
+                return [3 /*break*/, 6];
+            case 4:
+                err_2 = _f.sent();
+                promises = [];
+                contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
+                for (_c = 0, routesRaw_2 = routesRaw; _c < routesRaw_2.length; _c++) {
+                    r = routesRaw_2[_c];
+                    _d = _getExchangeMultipleArgs(r.route), _route = _d._route, _swapParams = _d._swapParams, _factorySwapAddresses = _d._factorySwapAddresses;
+                    promises.push(contract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses, curve.constantOptions));
+                }
+                return [4 /*yield*/, Promise.allSettled(promises)];
+            case 5:
+                res = _f.sent();
+                for (i = 0; i < res.length; i++) {
+                    if (res[i].status === 'rejected') {
+                        console.log("Route ".concat((routesRaw[i].route.map(function (s) { return s.poolId; })).join(" --> "), " is unavailable"));
+                        continue;
+                    }
+                    routesRaw[i]._output = res[i].value;
+                    routes.push(routesRaw[i]);
+                }
+                return [3 /*break*/, 6];
+            case 6:
+                if (routes.length === 0)
+                    return [2 /*return*/, []];
+                if (routes.length === 1)
+                    return [2 /*return*/, routes[0].route];
+                return [4 /*yield*/, Promise.all([
+                        _estimateGasForDifferentRoutes(routes.map(function (r) { return r.route; }), inputCoinAddress, outputCoinAddress, _amount),
+                        _getUsdRate(outputCoinAddress),
+                        axios.get("https://api.curve.fi/api/getGas"),
+                        _getUsdRate(ETH_ADDRESS),
+                    ])];
+            case 7:
+                _e = _f.sent(), gasAmounts = _e[0], outputCoinUsdRate = _e[1], gasData = _e[2], ethUsdRate = _e[3];
+                gasPrice = gasData.data.data.gas.standard;
+                expectedAmounts = (routes).map(function (route) { return Number(curve.formatUnits(route._output, outputCoinDecimals)); });
+                expectedAmountsUsd = expectedAmounts.map(function (a) { return a * outputCoinUsdRate; });
+                txCostsUsd = gasAmounts.map(function (a) { return ethUsdRate * a * gasPrice / 1e18; });
+                routes.forEach(function (route, i) {
+                    route.outputUsd = expectedAmountsUsd[i];
+                    route.txCostUsd = txCostsUsd[i];
+                });
+                return [2 /*return*/, routes.reduce(function (route1, route2) {
+                        var diff = (route1.outputUsd - route1.txCostUsd) - (route2.outputUsd - route2.txCostUsd);
+                        if (diff > 0)
+                            return route1;
+                        if (diff === 0 && route1.route.length < route2.route.length)
+                            return route1;
+                        return route2;
+                    }).route];
         }
-    }
-    if (routes.length === 0)
-        return [];
-    if (routes.length === 1)
-        return routes[0].route;
-    const [gasAmounts, outputCoinUsdRate, gasData, ethUsdRate] = await Promise.all([
-        _estimateGasForDifferentRoutes(routes.map((r) => r.route), inputCoinAddress, outputCoinAddress, _amount),
-        _getUsdRate(outputCoinAddress),
-        axios.get("https://api.curve.fi/api/getGas"),
-        _getUsdRate(ETH_ADDRESS),
-    ]);
-    const gasPrice = gasData.data.data.gas.standard;
-    const expectedAmounts = (routes).map((route) => Number(curve.formatUnits(route._output, outputCoinDecimals)));
-    const expectedAmountsUsd = expectedAmounts.map((a) => a * outputCoinUsdRate);
-    const txCostsUsd = gasAmounts.map((a) => ethUsdRate * a * gasPrice / 1e18);
-    routes.forEach((route, i) => {
-        route.outputUsd = expectedAmountsUsd[i];
-        route.txCostUsd = txCostsUsd[i];
     });
-    return routes.reduce((route1, route2) => {
-        const diff = (route1.outputUsd - route1.txCostUsd) - (route2.outputUsd - route2.txCostUsd);
-        if (diff > 0)
-            return route1;
-        if (diff === 0 && route1.route.length < route2.route.length)
-            return route1;
-        return route2;
-    }).route;
-}, {
+}); }, {
     promise: true,
     maxAge: 5 * 60 * 1000, // 5m
 });
-const _getOutputForRoute = memoize(async (route, _amount) => {
-    const contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
-    const { _route, _swapParams, _factorySwapAddresses } = _getExchangeMultipleArgs(route);
-    return await contract.get_exchange_multiple_amount(_route, _swapParams, _amount, _factorySwapAddresses, curve.constantOptions);
-}, {
+var _getOutputForRoute = memoize(function (route, _amount) { return __awaiter(void 0, void 0, void 0, function () {
+    var contract, _a, _route, _swapParams, _factorySwapAddresses;
+    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)];
+            case 1: return [2 /*return*/, _b.sent()];
+        }
+    });
+}); }, {
     promise: true,
     maxAge: 15 * 1000, // 15s
 });
-export const getBestRouteAndOutput = async (inputCoin, outputCoin, amount) => {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const route = await _getBestRoute(inputCoinAddress, outputCoinAddress, amount); // 5 minutes cache
-    if (route.length === 0)
-        return { route, output: '0.0' };
-    const _output = await _getOutputForRoute(route, parseUnits(amount, inputCoinDecimals)); // 15 seconds cache, so we call it to get fresh output estimation
-    return { route, output: curve.formatUnits(_output, outputCoinDecimals) };
-};
-export const swapExpected = async (inputCoin, outputCoin, amount) => {
-    return (await getBestRouteAndOutput(inputCoin, outputCoin, amount))['output'];
-};
-export const swapPriceImpact = async (inputCoin, outputCoin, amount) => {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const { route, output } = await getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount);
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    const _output = parseUnits(output, outputCoinDecimals);
-    const smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
-    const amountIntBN = toBN(_amount, 0);
-    if (smallAmountIntBN.gte(amountIntBN))
-        return 0;
-    const contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
-    let _smallAmount = fromBN(smallAmountIntBN.div(10 ** inputCoinDecimals), inputCoinDecimals);
-    const { _route, _swapParams, _factorySwapAddresses } = _getExchangeMultipleArgs(route);
-    let _smallOutput;
-    try {
-        _smallOutput = await contract.get_exchange_multiple_amount(_route, _swapParams, _smallAmount, _factorySwapAddresses, curve.constantOptions);
-    }
-    catch (e) {
-        _smallAmount = curve.parseUnits("1", inputCoinDecimals); // Dirty hack
-        _smallOutput = await contract.get_exchange_multiple_amount(_route, _swapParams, _smallAmount, _factorySwapAddresses, curve.constantOptions);
-    }
-    const priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
-    return Number(_cutZeros(priceImpactBN.toFixed(4)));
-};
-export const swapIsApproved = async (inputCoin, amount) => {
-    return await hasAllowance([inputCoin], [amount], curve.signerAddress, curve.constants.ALIASES.registry_exchange);
-};
-export const swapApproveEstimateGas = async (inputCoin, amount) => {
-    return await ensureAllowanceEstimateGas([inputCoin], [amount], curve.constants.ALIASES.registry_exchange);
-};
-export const swapApprove = async (inputCoin, amount) => {
-    return await ensureAllowance([inputCoin], [amount], curve.constants.ALIASES.registry_exchange);
-};
-export const swapEstimateGas = async (inputCoin, outputCoin, amount) => {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    const { route } = await getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount);
-    if (route.length === 0)
-        return 0;
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    const [gas] = await _estimateGasForDifferentRoutes([route], inputCoinAddress, outputCoinAddress, _amount);
-    return gas;
-};
-export const swap = async (inputCoin, outputCoin, amount, slippage = 0.5) => {
-    const [inputCoinAddress, outputCoinAddress] = _getCoinAddresses(inputCoin, outputCoin);
-    const [inputCoinDecimals, outputCoinDecimals] = _getCoinDecimals(inputCoinAddress, outputCoinAddress);
-    await swapApprove(inputCoin, amount);
-    const { route, output } = await getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount);
-    if (route.length === 0) {
-        throw new Error("This pair can't be exchanged");
-    }
-    const { _route, _swapParams, _factorySwapAddresses } = _getExchangeMultipleArgs(route);
-    const _amount = parseUnits(amount, inputCoinDecimals);
-    const minRecvAmountBN = BN(output).times(100 - slippage).div(100);
-    const _minRecvAmount = fromBN(minRecvAmountBN, outputCoinDecimals);
-    const contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
-    const value = isEth(inputCoinAddress) ? _amount : 0n;
-    await curve.updateFeeData();
-    const gasLimit = (await contract.exchange_multiple.estimateGas(_route, _swapParams, _amount, _minRecvAmount, _factorySwapAddresses, { ...curve.constantOptions, value })) * (curve.chainId === 1 ? 130n : 160n) / 100n;
-    return await contract.exchange_multiple(_route, _swapParams, _amount, _minRecvAmount, _factorySwapAddresses, { ...curve.options, value, gasLimit });
-};
-export const getSwappedAmount = async (tx, outputCoin) => {
-    const [outputCoinAddress] = _getCoinAddresses(outputCoin);
-    const [outputCoinDecimals] = _getCoinDecimals(outputCoinAddress);
-    const txInfo = await tx.wait();
-    if (txInfo === null)
-        return '0.0';
-    let res;
-    for (let i = 1; i <= txInfo.logs.length; i++) {
-        try {
-            const 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));
-            break;
+export var getBestRouteAndOutput = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, inputCoinAddress, outputCoinAddress, _b, inputCoinDecimals, outputCoinDecimals, route, _output;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = _getCoinAddresses(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
+                _b = _getCoinDecimals(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                return [4 /*yield*/, _getBestRoute(inputCoinAddress, outputCoinAddress, amount)];
+            case 1:
+                route = _c.sent();
+                if (route.length === 0)
+                    return [2 /*return*/, { route: route, output: '0.0' }];
+                return [4 /*yield*/, _getOutputForRoute(route, parseUnits(amount, inputCoinDecimals))];
+            case 2:
+                _output = _c.sent();
+                return [2 /*return*/, { route: route, output: curve.formatUnits(_output, outputCoinDecimals) }];
         }
-        catch (err) { }
-    }
-    if (res === undefined)
-        return '0.0';
-    return curve.formatUnits(res[res.length - 1], outputCoinDecimals);
+    });
+}); };
+export var swapExpected = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, getBestRouteAndOutput(inputCoin, outputCoin, amount)];
+            case 1: return [2 /*return*/, (_a.sent())['output']];
+        }
+    });
+}); };
+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_1, priceImpactBN;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _a = _getCoinAddresses(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
+                _b = _getCoinDecimals(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                return [4 /*yield*/, getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount)];
+            case 1:
+                _c = _e.sent(), route = _c.route, output = _c.output;
+                _amount = parseUnits(amount, inputCoinDecimals);
+                _output = parseUnits(output, outputCoinDecimals);
+                smallAmountIntBN = _get_small_x(_amount, _output, inputCoinDecimals, outputCoinDecimals);
+                amountIntBN = toBN(_amount, 0);
+                if (smallAmountIntBN.gte(amountIntBN))
+                    return [2 /*return*/, 0];
+                contract = curve.contracts[curve.constants.ALIASES.registry_exchange].contract;
+                _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inputCoinDecimals)), inputCoinDecimals);
+                _d = _getExchangeMultipleArgs(route), _route = _d._route, _swapParams = _d._swapParams, _factorySwapAddresses = _d._factorySwapAddresses;
+                _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)];
+            case 3:
+                _smallOutput = _e.sent();
+                return [3 /*break*/, 6];
+            case 4:
+                e_1 = _e.sent();
+                _smallAmount = curve.parseUnits("1", inputCoinDecimals); // Dirty hack
+                return [4 /*yield*/, contract.get_exchange_multiple_amount(_route, _swapParams, _smallAmount, _factorySwapAddresses, curve.constantOptions)];
+            case 5:
+                _smallOutput = _e.sent();
+                return [3 /*break*/, 6];
+            case 6:
+                priceImpactBN = _get_price_impact(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
+                return [2 /*return*/, Number(_cutZeros(priceImpactBN.toFixed(4)))];
+        }
+    });
+}); };
+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 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+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 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+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 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var swapEstimateGas = function (inputCoin, outputCoin, amount) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, inputCoinAddress, outputCoinAddress, inputCoinDecimals, route, _amount, gas;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = _getCoinAddresses(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
+                inputCoinDecimals = _getCoinDecimals(inputCoinAddress, outputCoinAddress)[0];
+                return [4 /*yield*/, getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount)];
+            case 1:
+                route = (_b.sent()).route;
+                if (route.length === 0)
+                    return [2 /*return*/, 0];
+                _amount = parseUnits(amount, inputCoinDecimals);
+                return [4 /*yield*/, _estimateGasForDifferentRoutes([route], inputCoinAddress, outputCoinAddress, _amount)];
+            case 2:
+                gas = (_b.sent())[0];
+                return [2 /*return*/, gas];
+        }
+    });
+}); };
+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;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    _a = _getCoinAddresses(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
+                    _b = _getCoinDecimals(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
+                    return [4 /*yield*/, swapApprove(inputCoin, amount)];
+                case 1:
+                    _e.sent();
+                    return [4 /*yield*/, getBestRouteAndOutput(inputCoinAddress, outputCoinAddress, amount)];
+                case 2:
+                    _c = _e.sent(), route = _c.route, output = _c.output;
+                    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;
+                    _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;
+                    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 }))];
+                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 }))];
+                case 5: return [2 /*return*/, _e.sent()];
+            }
+        });
+    });
 };
+export var getSwappedAmount = function (tx, outputCoin) { return __awaiter(void 0, void 0, void 0, function () {
+    var outputCoinAddress, outputCoinDecimals, txInfo, res, i, abiCoder;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outputCoinAddress = _getCoinAddresses(outputCoin)[0];
+                outputCoinDecimals = _getCoinDecimals(outputCoinAddress)[0];
+                return [4 /*yield*/, tx.wait()];
+            case 1:
+                txInfo = _a.sent();
+                if (txInfo === null)
+                    return [2 /*return*/, '0.0'];
+                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));
+                        break;
+                    }
+                    catch (err) { }
+                }
+                if (res === undefined)
+                    return [2 /*return*/, '0.0'];
+                return [2 /*return*/, curve.formatUnits(res[res.length - 1], outputCoinDecimals)];
+        }
+    });
+}); };