@curvefi/api 2.22.0 → 2.24.0

package/lib/router.js

@@ -59,7 +59,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.swap = exports.swapEstimateGas = exports.swapApprove = exports.swapApproveEstimateGas = exports.swapIsApproved = exports.swapPriceImpact = exports.swapExpected = exports.getBestRouteAndOutput = exports._findAllRoutes = exports._findAllRoutesTvl = exports._findAllRoutesTheShorterTheBetter = void 0;
+exports.getSwappedAmount = exports.swap = exports.swapEstimateGas = exports.swapApprove = exports.swapApproveEstimateGas = exports.swapIsApproved = exports.swapPriceImpact = exports.swapExpected = exports.getBestRouteAndOutput = exports._findAllRoutes = exports._findAllRoutesTvl = exports._findAllRoutesTheShorterTheBetter = void 0;
 var axios_1 = __importDefault(require("axios"));
 var memoizee_1 = __importDefault(require("memoizee"));
 var ethers_1 = require("ethers");
@@ -82,7 +82,7 @@ var _findAllRoutesTheShorterTheBetter = function (inputCoinAddress, outputCoinAd
                 basePoolsSet = new Set();
                 for (_i = 0, ALL_POOLS_1 = ALL_POOLS; _i < ALL_POOLS_1.length; _i++) {
                     pool = ALL_POOLS_1[_i];
-                    if (pool[1].wrapped_coin_addresses.length < 4)
+                    if (pool[1].wrapped_coin_addresses.length < 6)
                         basePoolsSet.add(pool[0]);
                 }
                 basePoolIds = Array.from(basePoolsSet);
@@ -317,9 +317,9 @@ var sortByTvl = function (a, b) { return b.minTvl - a.minTvl || b.totalTvl - a.t
 var sortByLength = function (a, b) { return a.steps.length - b.steps.length || b.minTvl - a.minTvl || b.totalTvl - a.totalTvl; };
 // Inspired by Dijkstra's algorithm
 var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
-    var ALL_POOLS, amplificationCoefficientDict, basePoolsSet, _i, ALL_POOLS_3, pool, basePoolIds, curCoins, nextCoins, routesByTvl, routesByLength, step, _loop_1, _a, curCoins_2, inCoin, routes;
-    var _b, _c;
-    var _d, _e, _f, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    var ALL_POOLS, amplificationCoefficientDict, curCoins, nextCoins, routesByTvl, routesByLength, step, _loop_1, _i, curCoins_2, 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:
@@ -329,32 +329,35 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                 return [4 /*yield*/, (0, utils_2._getAmplificationCoefficientsFromApi)()];
             case 1:
                 amplificationCoefficientDict = _s.sent();
-                basePoolsSet = new Set();
-                for (_i = 0, ALL_POOLS_3 = ALL_POOLS; _i < ALL_POOLS_3.length; _i++) {
-                    pool = ALL_POOLS_3[_i];
-                    if (pool[1].wrapped_coin_addresses.length < 4)
-                        basePoolsSet.add(pool[0]);
-                }
-                basePoolIds = Array.from(basePoolsSet);
                 curCoins = [inputCoinAddress];
                 nextCoins = new Set();
-                routesByTvl = (_b = {},
+                routesByTvl = (_a = {},
+                    _a[inputCoinAddress] = [{ steps: [], minTvl: Infinity, totalTvl: 0 }],
+                    _a);
+                routesByLength = (_b = {},
                     _b[inputCoinAddress] = [{ steps: [], minTvl: Infinity, totalTvl: 0 }],
                     _b);
-                routesByLength = (_c = {},
-                    _c[inputCoinAddress] = [{ steps: [], minTvl: Infinity, totalTvl: 0 }],
-                    _c);
                 step = 0;
                 _s.label = 2;
             case 2:
                 if (!(step < 4)) return [3 /*break*/, 8];
                 _loop_1 = function (inCoin) {
-                    var _loop_2, _t, ALL_POOLS_4, _u, poolId, poolData;
+                    var outCoin_1, newRoutesByTvl, newRoutesByLength, _loop_2, _t, ALL_POOLS_3, _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_lending, tvlMultiplier, inCoinIndexes, tvl, _w, _loop_3, j, swapType_1, newRoutesByTvl, newRoutesByLength, _loop_4, j, poolAddress, _loop_5, j;
+                                    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:
@@ -363,7 +366,7 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                 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_lending = (_d = poolData.is_lending) !== null && _d !== void 0 ? _d : false;
+                                                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),
@@ -380,36 +383,41 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                 // Skip empty pools
                                                 if (tvl === 0)
                                                     return [2 /*return*/, "continue"];
-                                                // LP -> wrapped coin "swaps" (actually remove_liquidity_one_coin)
-                                                if (basePoolIds.includes(poolId) && inCoin === token_address) {
+                                                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 && wrapped_coin_addresses[j] !== outputCoinAddress)
+                                                        if (step === 3 && 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);
+                                                        var outputCoinIdx = coin_addresses.indexOf(outputCoinAddress);
                                                         if (outputCoinIdx >= 0 && j !== outputCoinIdx)
                                                             return "continue";
-                                                        var swapType = poolId === 'aave' ? 11 : 10;
-                                                        var newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolData.swap_address, inCoin, wrapped_coin_addresses[j], 0, 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], 0, j, swapType, ethers_1.ethers.constants.AddressZero, tvl); });
-                                                        routesByTvl[wrapped_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_f = routesByTvl[wrapped_coin_addresses[j]]) !== null && _f !== void 0 ? _f : []), true), newRoutesByTvl, true);
-                                                        routesByTvl[wrapped_coin_addresses[j]] = filterRoutes(routesByTvl[wrapped_coin_addresses[j]], inputCoinAddress, sortByTvl);
-                                                        routesByLength[wrapped_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_h = routesByLength[wrapped_coin_addresses[j]]) !== null && _h !== void 0 ? _h : []), true), newRoutesByLength, true);
-                                                        routesByLength[wrapped_coin_addresses[j]] = filterRoutes(routesByLength[wrapped_coin_addresses[j]], inputCoinAddress, sortByLength);
-                                                        nextCoins.add(wrapped_coin_addresses[j]);
+                                                        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 < wrapped_coin_addresses.length; j++) {
+                                                    for (j = 0; j < coin_addresses.length; j++) {
                                                         _loop_3(j);
                                                     }
                                                 }
-                                                // Wrapped coin -> LP "swaps" (actually add_liquidity)
-                                                if (basePoolIds.includes(poolId) && inCoinIndexes.wrapped_coin >= 0) {
+                                                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_lending ? 9 : wrapped_coin_addresses.length === 2 ? 7 : 8;
-                                                        newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolData.swap_address, inCoin, token_address, wrapped_coin_addresses.indexOf(inCoin), 0, swapType_1, ethers_1.ethers.constants.AddressZero, tvl); });
-                                                        newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolData.swap_address, inCoin, token_address, wrapped_coin_addresses.indexOf(inCoin), 0, swapType_1, ethers_1.ethers.constants.AddressZero, tvl); });
+                                                        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);
@@ -445,6 +453,7 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                         _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];
@@ -502,11 +511,11 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                         }
                                     });
                                 };
-                                _t = 0, ALL_POOLS_4 = ALL_POOLS;
+                                _t = 0, ALL_POOLS_3 = ALL_POOLS;
                                 _v.label = 1;
                             case 1:
-                                if (!(_t < ALL_POOLS_4.length)) return [3 /*break*/, 4];
-                                _u = ALL_POOLS_4[_t], poolId = _u[0], poolData = _u[1];
+                                if (!(_t < ALL_POOLS_3.length)) return [3 /*break*/, 4];
+                                _u = ALL_POOLS_3[_t], poolId = _u[0], poolData = _u[1];
                                 return [5 /*yield**/, _loop_2(poolId, poolData)];
                             case 2:
                                 _v.sent();
@@ -518,17 +527,17 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                         }
                     });
                 };
-                _a = 0, curCoins_2 = curCoins;
+                _i = 0, curCoins_2 = curCoins;
                 _s.label = 3;
             case 3:
-                if (!(_a < curCoins_2.length)) return [3 /*break*/, 6];
-                inCoin = curCoins_2[_a];
+                if (!(_i < curCoins_2.length)) return [3 /*break*/, 6];
+                inCoin = curCoins_2[_i];
                 return [5 /*yield**/, _loop_1(inCoin)];
             case 4:
                 _s.sent();
                 _s.label = 5;
             case 5:
-                _a++;
+                _i++;
                 return [3 /*break*/, 3];
             case 6:
                 curCoins = Array.from(nextCoins);
@@ -545,16 +554,10 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
 }); };
 exports._findAllRoutesTvl = _findAllRoutesTvl;
 var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
-    var routes;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0: return [4 /*yield*/, (0, exports._findAllRoutesTvl)(inputCoinAddress, outputCoinAddress)];
-            case 1:
-                routes = _a.sent();
-                if (routes.length > 0)
-                    return [2 /*return*/, routes];
-                return [4 /*yield*/, (0, exports._findAllRoutesTheShorterTheBetter)(inputCoinAddress, outputCoinAddress)];
-            case 2: return [2 /*return*/, _a.sent()];
+            case 1: return [2 /*return*/, _a.sent()];
         }
     });
 }); };
@@ -711,7 +714,14 @@ var _getBestRouteAndOutput = (0, memoizee_1.default)(function (inputCoinAddress,
                     route.outputUsd = expectedAmountsUsd[i];
                     route.txCostUsd = txCostsUsd[i];
                 });
-                return [2 /*return*/, routes.reduce(function (route1, route2) { return (route1.outputUsd - route1.txCostUsd) - (route2.outputUsd - route2.txCostUsd) >= 0 ? route1 : route2; })];
+                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.steps.length < route2.steps.length)
+                            return route1;
+                        return route2;
+                    })];
         }
     });
 }); }, {
@@ -849,9 +859,25 @@ var swap = function (inputCoin, outputCoin, amount, slippage) {
                 case 4:
                     gasLimit = (_d.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*/, (_d.sent()).hash];
+                case 5: return [2 /*return*/, _d.sent()];
             }
         });
     });
 };
 exports.swap = swap;
+var getSwappedAmount = function (tx, outputCoin) { return __awaiter(void 0, void 0, void 0, function () {
+    var outputCoinAddress, outputCoinDecimals, txInfo, res;
+    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();
+                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 - 1].data, 0));
+                return [2 /*return*/, ethers_1.ethers.utils.formatUnits(res[res.length - 1], outputCoinDecimals)];
+        }
+    });
+}); };
+exports.getSwappedAmount = getSwappedAmount;

package/package.json

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