@curvefi/api 2.22.0 → 2.23.0

package/README.md

@@ -1020,8 +1020,10 @@ import curve from "@curvefi/api";
     // ]
     const swapTx = await curve.router.swap('DAI', 'CRV', '1000');
     // OR const swapTx = await curve.router.swap('0x6B175474E89094C44Da98b954EedeAC495271d0F', '0xD533a949740bb3306d119CC777fa900bA034cd52', '1000');
-    console.log(swapTx);
+    console.log(swapTx.hash);
     // 0xc7ba1d60871c0295ac5471bb602c37ec0f00a71543b3a041308ebd91833f26ba
+    const swappedAmount = await curve.router.getSwappedAmount(swapTx, 'CRV');
+    // 1573.668171170839785062
 
     await curve.getBalances(['DAI', 'CRV']);
     // [ '8900.0', '100428.626463428100672494' ]

package/lib/curve.js

@@ -159,6 +159,12 @@ exports.NATIVE_TOKENS = {
         address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
         wrappedAddress: '0xc86c7C0eFbd6A49B35E8714C5f59D99De09A225b'.toLowerCase(),
     },
+    42161: {
+        symbol: 'ETH',
+        wrappedSymbol: 'WETH',
+        address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+        wrappedAddress: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1'.toLowerCase(),
+    },
     42220: {
         symbol: 'CELO',
         wrappedSymbol: 'WCELO',
@@ -171,12 +177,6 @@ exports.NATIVE_TOKENS = {
         address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
         wrappedAddress: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7'.toLowerCase(),
     },
-    42161: {
-        symbol: 'ETH',
-        wrappedSymbol: 'WETH',
-        address: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
-        wrappedAddress: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1'.toLowerCase(),
-    },
     1313161554: {
         symbol: 'ETH',
         wrappedSymbol: 'WETH',
@@ -255,6 +255,16 @@ exports.NETWORK_CONSTANTS = {
         ycTokens: kava_1.ycTokensKava,
         aTokens: kava_1.aTokensKava,
     },
+    42161: {
+        NAME: 'arbitrum',
+        ALIASES: aliases_1.ALIASES_ARBITRUM,
+        POOLS_DATA: pools_1.POOLS_DATA_ARBITRUM,
+        COINS: arbitrum_1.COINS_ARBITRUM,
+        cTokens: arbitrum_1.cTokensArbitrum,
+        yTokens: arbitrum_1.yTokensArbitrum,
+        ycTokens: arbitrum_1.ycTokensArbitrum,
+        aTokens: arbitrum_1.aTokensArbitrum,
+    },
     42220: {
         NAME: 'celo',
         ALIASES: aliases_1.ALIASES_CELO,
@@ -275,16 +285,6 @@ exports.NETWORK_CONSTANTS = {
         ycTokens: avalanche_1.ycTokensAvalanche,
         aTokens: avalanche_1.aTokensAvalanche,
     },
-    42161: {
-        NAME: 'arbitrum',
-        ALIASES: aliases_1.ALIASES_ARBITRUM,
-        POOLS_DATA: pools_1.POOLS_DATA_ARBITRUM,
-        COINS: arbitrum_1.COINS_ARBITRUM,
-        cTokens: arbitrum_1.cTokensArbitrum,
-        yTokens: arbitrum_1.yTokensArbitrum,
-        ycTokens: arbitrum_1.ycTokensArbitrum,
-        aTokens: arbitrum_1.aTokensArbitrum,
-    },
     1313161554: {
         NAME: 'aurora',
         ALIASES: aliases_1.ALIASES_AURORA,
@@ -407,6 +407,8 @@ var Curve = /** @class */ (function () {
                         this.constants.POOLS_DATA = exports.NETWORK_CONSTANTS[this.chainId].POOLS_DATA;
                         this.constants.COINS = exports.NETWORK_CONSTANTS[this.chainId].COINS;
                         this.constants.DECIMALS = (0, utils_1.extractDecimals)(this.constants.POOLS_DATA);
+                        this.constants.DECIMALS[this.constants.NATIVE_TOKEN.address] = 18;
+                        this.constants.DECIMALS[this.constants.NATIVE_TOKEN.wrappedAddress] = 18;
                         this.constants.GAUGES = (0, utils_1.extractGauges)(this.constants.POOLS_DATA);
                         _c = [
                             exports.NETWORK_CONSTANTS[this.chainId].cTokens,
@@ -521,6 +523,7 @@ var Curve = /** @class */ (function () {
                                 };
                             }
                         }
+                        this.setContract(this.constants.NATIVE_TOKEN.wrappedAddress, ERC20_json_1.default);
                         this.contracts[this.constants.ALIASES.crv] = {
                             contract: new ethers_1.Contract(this.constants.ALIASES.crv, ERC20_json_1.default, this.signer || this.provider),
                             multicallContract: new ethcall_1.Contract(this.constants.ALIASES.crv, ERC20_json_1.default),

package/lib/index.d.ts

@@ -122,7 +122,8 @@ declare const curve: {
         priceImpact: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;
         isApproved: (inputCoin: string, amount: string | number) => Promise<boolean>;
         approve: (inputCoin: string, amount: string | number) => Promise<string[]>;
-        swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number) => Promise<string>;
+        swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number) => Promise<ethers.ContractTransaction>;
+        getSwappedAmount: (tx: ethers.ContractTransaction, outputCoin: string) => Promise<string>;
         estimateGas: {
             approve: (inputCoin: string, amount: string | number) => Promise<number>;
             swap: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;

package/lib/index.js

@@ -199,6 +199,7 @@ var curve = {
         isApproved: router_1.swapIsApproved,
         approve: router_1.swapApprove,
         swap: router_1.swap,
+        getSwappedAmount: router_1.getSwappedAmount,
         estimateGas: {
             approve: router_1.swapApproveEstimateGas,
             swap: router_1.swapEstimateGas,

package/lib/interfaces.d.ts

@@ -127,7 +127,7 @@ export interface IRouteStep {
     outputCoinAddress: string;
     i: number;
     j: number;
-    swapType: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+    swapType: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
     swapAddress: string;
 }
 export interface IRoute_ {

package/lib/router.d.ts

@@ -1,3 +1,4 @@
+import { ethers } from "ethers";
 import { IRouteStep } from "./interfaces";
 export declare const _findAllRoutesTheShorterTheBetter: (inputCoinAddress: string, outputCoinAddress: string) => Promise<IRouteStep[][]>;
 export declare const _findAllRoutesTvl: (inputCoinAddress: string, outputCoinAddress: string) => Promise<IRouteStep[][]>;
@@ -12,4 +13,5 @@ export declare const swapIsApproved: (inputCoin: string, amount: number | string
 export declare const swapApproveEstimateGas: (inputCoin: string, amount: number | string) => Promise<number>;
 export declare const swapApprove: (inputCoin: string, amount: number | string) => Promise<string[]>;
 export declare const swapEstimateGas: (inputCoin: string, outputCoin: string, amount: number | string) => Promise<number>;
-export declare const swap: (inputCoin: string, outputCoin: string, amount: number | string, slippage?: number) => Promise<string>;
+export declare const swap: (inputCoin: string, outputCoin: string, amount: number | string, slippage?: number) => Promise<ethers.ContractTransaction>;
+export declare const getSwappedAmount: (tx: ethers.ContractTransaction, outputCoin: string) => Promise<string>;

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,54 +317,57 @@ 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;
-    return __generator(this, function (_s) {
-        switch (_s.label) {
+    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, _s;
+    return __generator(this, function (_t) {
+        switch (_t.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();
-                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);
+                amplificationCoefficientDict = _t.sent();
                 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;
+                _t.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;
-                    return __generator(this, function (_v) {
-                        switch (_v.label) {
+                    var outCoin_1, newRoutesByTvl, newRoutesByLength, _loop_2, _u, ALL_POOLS_3, _v, poolId, poolData;
+                    return __generator(this, function (_w) {
+                        switch (_w.label) {
                             case 0:
+                                if ([curve_1.curve.constants.NATIVE_TOKEN.address, curve_1.curve.constants.NATIVE_TOKEN.wrappedAddress].includes(inCoin)) {
+                                    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;
-                                    return __generator(this, function (_x) {
-                                        switch (_x.label) {
+                                    var wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_lending, tvlMultiplier, inCoinIndexes, tvl, _x, poolAddress, coin_addresses, _loop_3, j, inCoinIndex, swapType_1, newRoutesByTvl, newRoutesByLength, _loop_4, j, _loop_5, j;
+                                    return __generator(this, function (_y) {
+                                        switch (_y.label) {
                                             case 0:
                                                 wrapped_coin_addresses = poolData.wrapped_coin_addresses.map(function (a) { return a.toLowerCase(); });
                                                 underlying_coin_addresses = poolData.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); });
                                                 base_pool = poolData.is_meta ? curve_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;
-                                                tvlMultiplier = poolData.is_crypto ? 1 : ((_e = amplificationCoefficientDict[poolData.swap_address]) !== null && _e !== void 0 ? _e : 1);
+                                                is_lending = (_e = poolData.is_lending) !== null && _e !== void 0 ? _e : false;
+                                                tvlMultiplier = poolData.is_crypto ? 1 : ((_f = amplificationCoefficientDict[poolData.swap_address]) !== null && _f !== void 0 ? _f : 1);
                                                 inCoinIndexes = {
                                                     wrapped_coin: wrapped_coin_addresses.indexOf(inCoin),
                                                     underlying_coin: underlying_coin_addresses.indexOf(inCoin),
@@ -373,46 +376,51 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                 // 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;
+                                                _x = Number;
                                                 return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
                                             case 1:
-                                                tvl = _w.apply(void 0, [_x.sent()]) * tvlMultiplier;
+                                                tvl = _x.apply(void 0, [_y.sent()]) * tvlMultiplier;
                                                 // 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_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_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([], ((_h = routesByTvl[coin_addresses[j]]) !== null && _h !== void 0 ? _h : []), true), newRoutesByTvl, true);
+                                                        routesByTvl[coin_addresses[j]] = filterRoutes(routesByTvl[coin_addresses[j]], inputCoinAddress, sortByTvl);
+                                                        routesByLength[coin_addresses[j]] = __spreadArray(__spreadArray([], ((_j = routesByLength[coin_addresses[j]]) !== null && _j !== void 0 ? _j : []), 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_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); });
-                                                        routesByTvl[token_address] = __spreadArray(__spreadArray([], ((_j = routesByTvl[token_address]) !== null && _j !== void 0 ? _j : []), true), newRoutesByTvl, true);
+                                                        swapType_1 = is_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([], ((_k = routesByTvl[token_address]) !== null && _k !== void 0 ? _k : []), 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] = __spreadArray(__spreadArray([], ((_l = routesByLength[token_address]) !== null && _l !== void 0 ? _l : []), true), newRoutesByLength, true);
                                                         routesByLength[token_address] = filterRoutes(routesByLength[token_address], inputCoinAddress, sortByLength);
                                                         nextCoins.add(token_address);
                                                     }
@@ -435,9 +443,9 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                         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]] = __spreadArray(__spreadArray([], ((_m = routesByTvl[wrapped_coin_addresses[j]]) !== null && _m !== void 0 ? _m : []), 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]] = __spreadArray(__spreadArray([], ((_o = routesByLength[wrapped_coin_addresses[j]]) !== null && _o !== void 0 ? _o : []), true), newRoutesByLength, true);
                                                         routesByLength[wrapped_coin_addresses[j]] = filterRoutes(routesByLength[wrapped_coin_addresses[j]], inputCoinAddress, sortByLength);
                                                         nextCoins.add(wrapped_coin_addresses[j]);
                                                     };
@@ -445,13 +453,14 @@ 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];
                                                 _loop_5 = function (j) {
-                                                    var outputCoinIdx, tvl_1, _y, hasEth, swapType, newRoutesByTvl, newRoutesByLength;
-                                                    return __generator(this, function (_z) {
-                                                        switch (_z.label) {
+                                                    var outputCoinIdx, tvl_1, _z, hasEth, swapType, newRoutesByTvl, newRoutesByLength;
+                                                    return __generator(this, function (_0) {
+                                                        switch (_0.label) {
                                                             case 0:
                                                                 if (j === inCoinIndexes.underlying_coin)
                                                                     return [2 /*return*/, "continue"];
@@ -464,10 +473,10 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                 outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
                                                                 if (outputCoinIdx >= 0 && j !== outputCoinIdx)
                                                                     return [2 /*return*/, "continue"];
-                                                                _y = Number;
+                                                                _z = Number;
                                                                 return [4 /*yield*/, ((0, pools_1.getPool)(poolId)).stats.totalLiquidity()];
                                                             case 1:
-                                                                tvl_1 = _y.apply(void 0, [_z.sent()]);
+                                                                tvl_1 = _z.apply(void 0, [_0.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);
@@ -478,9 +487,9 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                                                 : 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]] = __spreadArray(__spreadArray([], ((_p = routesByTvl[underlying_coin_addresses[j]]) !== null && _p !== void 0 ? _p : []), 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]] = __spreadArray(__spreadArray([], ((_q = routesByLength[underlying_coin_addresses[j]]) !== null && _q !== void 0 ? _q : []), 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*/];
@@ -488,13 +497,13 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                                     });
                                                 };
                                                 j = 0;
-                                                _x.label = 2;
+                                                _y.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;
+                                                _y.sent();
+                                                _y.label = 4;
                                             case 4:
                                                 j++;
                                                 return [3 /*break*/, 2];
@@ -502,59 +511,53 @@ var _findAllRoutesTvl = function (inputCoinAddress, outputCoinAddress) { return
                                         }
                                     });
                                 };
-                                _t = 0, ALL_POOLS_4 = ALL_POOLS;
-                                _v.label = 1;
+                                _u = 0, ALL_POOLS_3 = ALL_POOLS;
+                                _w.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 (!(_u < ALL_POOLS_3.length)) return [3 /*break*/, 4];
+                                _v = ALL_POOLS_3[_u], poolId = _v[0], poolData = _v[1];
                                 return [5 /*yield**/, _loop_2(poolId, poolData)];
                             case 2:
-                                _v.sent();
-                                _v.label = 3;
+                                _w.sent();
+                                _w.label = 3;
                             case 3:
-                                _t++;
+                                _u++;
                                 return [3 /*break*/, 1];
                             case 4: return [2 /*return*/];
                         }
                     });
                 };
-                _a = 0, curCoins_2 = curCoins;
-                _s.label = 3;
+                _i = 0, curCoins_2 = curCoins;
+                _t.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;
+                _t.sent();
+                _t.label = 5;
             case 5:
-                _a++;
+                _i++;
                 return [3 /*break*/, 3];
             case 6:
                 curCoins = Array.from(nextCoins);
                 nextCoins = new Set();
-                _s.label = 7;
+                _t.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);
+                routes = __spreadArray(__spreadArray([], ((_r = routesByTvl[outputCoinAddress]) !== null && _r !== void 0 ? _r : []), true), ((_s = routesByLength[outputCoinAddress]) !== null && _s !== void 0 ? _s : []), true);
                 return [2 /*return*/, routes.map(function (r) { return r.steps; })];
         }
     });
 }); };
 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.23.0",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "author": "Macket",