@curvefi/api 2.31.0 → 2.31.1

package/lib/router.js

@@ -1,74 +1,12 @@
-"use strict";
-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));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSwappedAmount = exports.swap = exports.swapEstimateGas = exports.swapApprove = exports.swapApproveEstimateGas = exports.swapIsApproved = exports.swapPriceImpact = exports.swapExpected = exports.getBestRouteAndOutput = void 0;
-var axios_1 = __importDefault(require("axios"));
-var memoizee_1 = __importDefault(require("memoizee"));
-var ethers_1 = require("ethers");
-var curve_1 = require("./curve");
-var utils_1 = require("./utils");
-var pools_1 = require("./pools");
-var utils_2 = require("./pools/utils");
-var getNewRoute = function (routeTvl, poolId, poolAddress, inputCoinAddress, outputCoinAddress, i, j, swapType, swapAddress, tvl) {
-    var routePoolIds = routeTvl.route.map(function (s) { return s.poolId; });
+import axios from "axios";
+import memoize from "memoizee";
+import { ethers } from "ethers";
+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);
     // Steps <= 4
     if (routePoolIds.length >= 4)
         return { route: [], minTvl: Infinity, totalTvl: 0 };
@@ -76,635 +14,434 @@ var getNewRoute = function (routeTvl, poolId, poolAddress, inputCoinAddress, out
     if (routePoolIds.includes(poolId))
         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: [...routeTvl.route, { poolId, poolAddress, inputCoinAddress, outputCoinAddress, i, j, swapType, swapAddress }],
         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_1.curve.constants.NATIVE_TOKEN.address)
+const filterMaticFactory83Route = (routes) => {
+    return routes.filter((r) => {
+        for (const step of r.route) {
+            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];
+const filterAvax = (routes) => {
+    return routes.filter((r) => {
+        for (const step of r.route) {
             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) {
+const MAX_ROUTES_FOR_ONE_COIN = 3;
+const filterRoutes = (routes, inputCoinAddress, sortFn) => {
     // TODO REMOVE IT!!!
-    if (curve_1.curve.chainId === 137)
+    if (curve.chainId === 137)
         routes = filterMaticFactory83Route(routes);
-    if (curve_1.curve.chainId === 43114)
+    if (curve.chainId === 43114)
         routes = filterAvax(routes);
     return routes
-        .filter(function (r) { return r.route.length > 0; })
-        .filter(function (r) { return r.route[0].inputCoinAddress === inputCoinAddress; }) // Truncated routes
-        .filter(function (r, i, _routes) {
-        var 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;
+        .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;
     }) // 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; };
+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;
 // 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;
-    return __generator(this, function (_s) {
-        switch (_s.label) {
-            case 0:
-                inputCoinAddress = inputCoinAddress.toLowerCase();
-                outputCoinAddress = outputCoinAddress.toLowerCase();
-                ALL_POOLS = Object.entries(__assign(__assign(__assign({}, curve_1.curve.constants.POOLS_DATA), curve_1.curve.constants.FACTORY_POOLS_DATA), curve_1.curve.constants.CRYPTO_FACTORY_POOLS_DATA));
-                return [4 /*yield*/, (0, utils_2._getAmplificationCoefficientsFromApi)()];
-            case 1:
-                amplificationCoefficientDict = _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_1.curve.chainId !== 42220 && [curve_1.curve.constants.NATIVE_TOKEN.address, curve_1.curve.constants.NATIVE_TOKEN.wrappedAddress].includes(inCoin)) { // Exclude Celo
-                                    outCoin_1 = inCoin === curve_1.curve.constants.NATIVE_TOKEN.address ? curve_1.curve.constants.NATIVE_TOKEN.wrappedAddress : curve_1.curve.constants.NATIVE_TOKEN.address;
-                                    newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, "wrapper", curve_1.curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin_1, 0, 0, 15, ethers_1.ethers.constants.AddressZero, Infinity); });
-                                    newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, "wrapper", curve_1.curve.constants.NATIVE_TOKEN.wrappedAddress, inCoin, outCoin_1, 0, 0, 15, ethers_1.ethers.constants.AddressZero, 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 ? curve_1.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"];
-                                                _w = Number;
-                                                return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
-                                            case 1:
-                                                tvl = _w.apply(void 0, [_x.sent()]) * tvlMultiplier;
-                                                // 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, ethers_1.ethers.constants.AddressZero, tvl); });
-                                                        var newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, coin_addresses[j], 0, j, swapType, ethers_1.ethers.constants.AddressZero, 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, ethers_1.ethers.constants.AddressZero, tvl); });
-                                                        newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, token_address, coin_addresses.indexOf(inCoin), 0, swapType_1, ethers_1.ethers.constants.AddressZero, 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, ethers_1.ethers.constants.AddressZero, 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, ethers_1.ethers.constants.AddressZero, 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*/, 5];
-                                                _loop_5 = function (j) {
-                                                    var outputCoinIdx, tvl_1, _y, hasEth, swapType, newRoutesByTvl, newRoutesByLength;
-                                                    return __generator(this, function (_z) {
-                                                        switch (_z.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"];
-                                                                _y = Number;
-                                                                return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
-                                                            case 1:
-                                                                tvl_1 = _y.apply(void 0, [_z.sent()]);
-                                                                if (tvl_1 === 0)
-                                                                    return [2 /*return*/, "continue"];
-                                                                hasEth = (inCoin === curve_1.curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve_1.curve.constants.NATIVE_TOKEN.address);
-                                                                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 : ethers_1.ethers.constants.AddressZero, 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 : ethers_1.ethers.constants.AddressZero, 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;
-                                                _x.label = 2;
-                                            case 2:
-                                                if (!(j < underlying_coin_addresses.length)) return [3 /*break*/, 5];
-                                                return [5 /*yield**/, _loop_5(j)];
-                                            case 3:
-                                                _x.sent();
-                                                _x.label = 4;
-                                            case 4:
-                                                j++;
-                                                return [3 /*break*/, 2];
-                                            case 5: 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*/];
-                        }
-                    });
+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,
                 };
-                _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; })];
+                // 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]);
+                    }
+                }
+            }
         }
-    });
-}); };
-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, "-->");
+        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}-->`;
     }
     key += sortedCoins[1];
     return key;
 };
-var _getExchangeMultipleArgs = function (route) {
-    var _route = [];
+const _getExchangeMultipleArgs = (route) => {
+    let _route = [];
     if (route.length > 0)
         _route.push(route[0].inputCoinAddress);
-    var _swapParams = [];
-    var _factorySwapAddresses = [];
-    for (var _i = 0, route_2 = route; _i < route_2.length; _i++) {
-        var routeStep = route_2[_i];
+    let _swapParams = [];
+    let _factorySwapAddresses = [];
+    for (const routeStep of route) {
         _route.push(routeStep.poolAddress, routeStep.outputCoinAddress);
         _swapParams.push([routeStep.i, routeStep.j, routeStep.swapType]);
         _factorySwapAddresses.push(routeStep.swapAddress);
     }
-    _route = _route.concat(Array(9 - _route.length).fill(ethers_1.ethers.constants.AddressZero));
+    _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(ethers_1.ethers.constants.AddressZero));
-    return { _route: _route, _swapParams: _swapParams, _factorySwapAddresses: _factorySwapAddresses };
+    _factorySwapAddresses = _factorySwapAddresses.concat(Array(4 - _factorySwapAddresses.length).fill(curve.constants.ZERO_ADDRESS));
+    return { _route, _swapParams, _factorySwapAddresses };
 };
-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_1.curve.contracts[curve_1.curve.constants.ALIASES.registry_exchange].contract;
-                gasPromises = [];
-                value = (0, utils_1.isEth)(inputCoinAddress) ? _amount : ethers_1.ethers.BigNumber.from(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.estimateGas.exchange_multiple(_route, _swapParams, _amount, 0, _factorySwapAddresses, __assign(__assign({}, curve_1.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(ethers_1.ethers.utils.formatUnits(_g, 0)); })];
-            case 3:
-                err_1 = _c.sent();
-                return [2 /*return*/, routes.map(function () { return 0; })];
-            case 4: return [2 /*return*/];
+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 });
         }
-    });
-}); };
-var _getBestRoute = (0, memoizee_1.default)(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 = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _a[0], outputCoinDecimals = _a[1];
-                _amount = (0, utils_1.parseUnits)(amount, inputCoinDecimals);
-                if (_amount.eq(0))
-                    return [2 /*return*/, []];
-                return [4 /*yield*/, _findAllRoutes(inputCoinAddress, outputCoinAddress)];
-            case 1:
-                routesRaw = (_f.sent()).map(function (route) { return ({ route: route, _output: ethers_1.ethers.BigNumber.from(0), outputUsd: 0, txCostUsd: 0 }); });
-                routes = [];
-                _f.label = 2;
-            case 2:
-                _f.trys.push([2, 4, , 6]);
-                calls = [];
-                multicallContract = curve_1.curve.contracts[curve_1.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_1.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_1.curve.contracts[curve_1.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_1.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),
-                        (0, utils_1._getUsdRate)(outputCoinAddress),
-                        axios_1.default.get("https://api.curve.fi/api/getGas"),
-                        (0, utils_1._getUsdRate)(utils_1.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(ethers_1.ethers.utils.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];
+        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));
+        }
+        // @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]);
         }
+    }
+    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
 });
-var _getOutputForRoute = (0, memoizee_1.default)(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_1.curve.contracts[curve_1.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_1.curve.constantOptions)];
-            case 1: return [2 /*return*/, _b.sent()];
-        }
-    });
-}); }, {
+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);
+}, {
     promise: true,
     maxAge: 15 * 1000, // 15s
 });
-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 = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                _b = (0, utils_1._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, (0, utils_1.parseUnits)(amount, inputCoinDecimals))];
-            case 2:
-                _output = _c.sent();
-                return [2 /*return*/, { route: route, output: ethers_1.ethers.utils.formatUnits(_output, outputCoinDecimals) }];
-        }
-    });
-}); };
-exports.getBestRouteAndOutput = getBestRouteAndOutput;
-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*/, (0, exports.getBestRouteAndOutput)(inputCoin, outputCoin, amount)];
-            case 1: return [2 /*return*/, (_a.sent())['output']];
-        }
-    });
-}); };
-exports.swapExpected = swapExpected;
-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 = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
-                return [4 /*yield*/, (0, exports.getBestRouteAndOutput)(inputCoinAddress, outputCoinAddress, amount)];
-            case 1:
-                _c = _e.sent(), route = _c.route, output = _c.output;
-                _amount = (0, utils_1.parseUnits)(amount, inputCoinDecimals);
-                _output = (0, utils_1.parseUnits)(output, outputCoinDecimals);
-                smallAmountIntBN = (0, utils_1._get_small_x)(_amount, _output, inputCoinDecimals, outputCoinDecimals);
-                amountIntBN = (0, utils_1.toBN)(_amount, 0);
-                if (smallAmountIntBN.gte(amountIntBN))
-                    return [2 /*return*/, 0];
-                contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.registry_exchange].contract;
-                _smallAmount = (0, utils_1.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_1.curve.constantOptions)];
-            case 3:
-                _smallOutput = _e.sent();
-                return [3 /*break*/, 6];
-            case 4:
-                e_1 = _e.sent();
-                _smallAmount = ethers_1.ethers.utils.parseUnits("1", inputCoinDecimals); // Dirty hack
-                return [4 /*yield*/, contract.get_exchange_multiple_amount(_route, _swapParams, _smallAmount, _factorySwapAddresses, curve_1.curve.constantOptions)];
-            case 5:
-                _smallOutput = _e.sent();
-                return [3 /*break*/, 6];
-            case 6:
-                priceImpactBN = (0, utils_1._get_price_impact)(_amount, _output, _smallAmount, _smallOutput, inputCoinDecimals, outputCoinDecimals);
-                return [2 /*return*/, Number((0, utils_1._cutZeros)(priceImpactBN.toFixed(4)))];
-        }
-    });
-}); };
-exports.swapPriceImpact = swapPriceImpact;
-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*/, (0, utils_1.hasAllowance)([inputCoin], [amount], curve_1.curve.signerAddress, curve_1.curve.constants.ALIASES.registry_exchange)];
-            case 1: return [2 /*return*/, _a.sent()];
-        }
-    });
-}); };
-exports.swapIsApproved = swapIsApproved;
-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*/, (0, utils_1.ensureAllowanceEstimateGas)([inputCoin], [amount], curve_1.curve.constants.ALIASES.registry_exchange)];
-            case 1: return [2 /*return*/, _a.sent()];
-        }
-    });
-}); };
-exports.swapApproveEstimateGas = swapApproveEstimateGas;
-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*/, (0, utils_1.ensureAllowance)([inputCoin], [amount], curve_1.curve.constants.ALIASES.registry_exchange)];
-            case 1: return [2 /*return*/, _a.sent()];
-        }
-    });
-}); };
-exports.swapApprove = swapApprove;
-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 = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                inputCoinDecimals = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress)[0];
-                return [4 /*yield*/, (0, exports.getBestRouteAndOutput)(inputCoinAddress, outputCoinAddress, amount)];
-            case 1:
-                route = (_b.sent()).route;
-                if (route.length === 0)
-                    return [2 /*return*/, 0];
-                _amount = (0, utils_1.parseUnits)(amount, inputCoinDecimals);
-                return [4 /*yield*/, _estimateGasForDifferentRoutes([route], inputCoinAddress, outputCoinAddress, _amount)];
-            case 2:
-                gas = (_b.sent())[0];
-                return [2 /*return*/, gas];
-        }
-    });
-}); };
-exports.swapEstimateGas = swapEstimateGas;
-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 = (0, utils_1._getCoinAddresses)(inputCoin, outputCoin), inputCoinAddress = _a[0], outputCoinAddress = _a[1];
-                    _b = (0, utils_1._getCoinDecimals)(inputCoinAddress, outputCoinAddress), inputCoinDecimals = _b[0], outputCoinDecimals = _b[1];
-                    return [4 /*yield*/, (0, exports.swapApprove)(inputCoin, amount)];
-                case 1:
-                    _e.sent();
-                    return [4 /*yield*/, (0, exports.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 = (0, utils_1.parseUnits)(amount, inputCoinDecimals);
-                    minRecvAmountBN = (0, utils_1.BN)(output).times(100 - slippage).div(100);
-                    _minRecvAmount = (0, utils_1.fromBN)(minRecvAmountBN, outputCoinDecimals);
-                    contract = curve_1.curve.contracts[curve_1.curve.constants.ALIASES.registry_exchange].contract;
-                    value = (0, utils_1.isEth)(inputCoinAddress) ? _amount : ethers_1.ethers.BigNumber.from(0);
-                    return [4 /*yield*/, curve_1.curve.updateFeeData()];
-                case 3:
-                    _e.sent();
-                    return [4 /*yield*/, contract.estimateGas.exchange_multiple(_route, _swapParams, _amount, _minRecvAmount, _factorySwapAddresses, __assign(__assign({}, curve_1.curve.constantOptions), { value: value }))];
-                case 4:
-                    gasLimit = (_e.sent()).mul(curve_1.curve.chainId === 1 ? 130 : 160).div(100);
-                    return [4 /*yield*/, contract.exchange_multiple(_route, _swapParams, _amount, _minRecvAmount, _factorySwapAddresses, __assign(__assign({}, curve_1.curve.options), { value: value, gasLimit: gasLimit }))];
-                case 5: return [2 /*return*/, _e.sent()];
-            }
-        });
-    });
+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) };
 };
-exports.swap = swap;
-var getSwappedAmount = function (tx, outputCoin) { return __awaiter(void 0, void 0, void 0, function () {
-    var outputCoinAddress, outputCoinDecimals, txInfo, res, i;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                outputCoinAddress = (0, utils_1._getCoinAddresses)(outputCoin)[0];
-                outputCoinDecimals = (0, utils_1._getCoinDecimals)(outputCoinAddress)[0];
-                return [4 /*yield*/, tx.wait()];
-            case 1:
-                txInfo = _a.sent();
-                for (i = 1; i <= txInfo.logs.length; i++) {
-                    try {
-                        res = ethers_1.ethers.utils.defaultAbiCoder.decode(['address[9]', 'uint256[3][4]', 'address[4]', 'uint256', 'uint256'], ethers_1.ethers.utils.hexDataSlice(txInfo.logs[txInfo.logs.length - i].data, 0));
-                        break;
-                    }
-                    catch (err) { }
-                }
-                if (res === undefined)
-                    return [2 /*return*/, '0'];
-                return [2 /*return*/, ethers_1.ethers.utils.formatUnits(res[res.length - 1], 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;
         }
-    });
-}); };
-exports.getSwappedAmount = getSwappedAmount;
+        catch (err) { }
+    }
+    if (res === undefined)
+        return '0.0';
+    return curve.formatUnits(res[res.length - 1], outputCoinDecimals);
+};