@curvefi/api 1.21.0 → 1.24.0

package/README.md

@@ -241,6 +241,9 @@ import curve from "@curvefi/api";
 
 (async () => {
     await curve.init('JsonRpc', {}, {gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0});
+    
+    console.log(await curve.getTVL());
+    // 19281307454.671753
 
     const aave = new curve.Pool('aave');
 
@@ -491,7 +494,66 @@ import curve from "@curvefi/api";
 })()
 ```
 
-## Exchange using all pools
+## Exchange
+
+### Router exchange
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0, chainId: 1 });
+
+    console.log(await curve.getBalances(['DAI', 'CRV']));
+    // [ '9900.0', '100049.744832225238317557' ]
+
+    const { route, output } = await curve.getBestRouteAndOutput('DAI', 'CRV', '1000');
+    // OR await curve.getBestPoolAndOutput('0x6B175474E89094C44Da98b954EedeAC495271d0F', '0xD533a949740bb3306d119CC777fa900bA034cd52', '10000');
+    const expected = await curve.routerExchangeExpected('DAI', 'CRV', '1000');
+    // OR await curve.exchangeExpected('0x6B175474E89094C44Da98b954EedeAC495271d0F', '0xD533a949740bb3306d119CC777fa900bA034cd52', '10000');
+
+    console.log(route, output, expected);
+    // route = [
+    //     {
+    //         poolId: '3pool',
+    //         poolAddress: '0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7',
+    //         outputCoinAddress: '0xdac17f958d2ee523a2206206994597c13d831ec7',
+    //         i: 0,
+    //         j: 2,
+    //         swapType: 1,
+    //         swapAddress: '0x0000000000000000000000000000000000000000'
+    //     },
+    //     {
+    //         poolId: 'tricrypto2',
+    //         poolAddress: '0xD51a44d3FaE010294C616388b506AcdA1bfAAE46',
+    //         outputCoinAddress: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+    //         i: 0,
+    //         j: 2,
+    //         swapType: 3,
+    //         swapAddress: '0x0000000000000000000000000000000000000000'
+    //     },
+    //     {
+    //         poolId: 'crveth',
+    //         poolAddress: '0x8301AE4fc9c624d1D396cbDAa1ed877821D7C511',
+    //         outputCoinAddress: '0xd533a949740bb3306d119cc777fa900ba034cd52',
+    //         i: 0,
+    //         j: 1,
+    //         swapType: 3,
+    //         swapAddress: '0x0000000000000000000000000000000000000000'
+    //     }
+    // ]
+    // 
+    // output = expected = 378.881631202862354937
+
+    await curve.routerExchange('DAI', 'CRV', '1000')
+    // OR await curve.exchange('0x6B175474E89094C44Da98b954EedeAC495271d0F', '0xD533a949740bb3306d119CC777fa900bA034cd52', '10000');
+
+    console.log(await curve.getBalances(['DAI', 'CRV']));
+    // [ '8900.0', '100428.626463428100672494' ]
+})()
+```
+
+### Single-pool exchange
 
 ```ts
 import curve from "@curvefi/api";
@@ -518,7 +580,7 @@ import curve from "@curvefi/api";
 })()
 ```
 
-## Cross-Asset Exchange
+### Cross-Asset Exchange
 
 ```ts
 import curve from "@curvefi/api";
@@ -665,6 +727,10 @@ await pool.exchangeWrappedApprove("0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490",
 
 ### Exchange
 ```ts
+// Router
+await curve.routerExchangeisApproved("DAI", "0x99d8a9c45b2eca8864373a26d1459e3dff1e17f3", "1000"); // DAI -> MIM
+await curve.routerExchangeApprove("DAI", "0x99d8a9c45b2eca8864373a26d1459e3dff1e17f3", "1000"); // DAI -> MIM
+
 // Straight
 await curve.exchangeisApproved("DAI", "0x99d8a9c45b2eca8864373a26d1459e3dff1e17f3", "1000"); // DAI -> MIM
 await curve.exchangeApprove("DAI", "0x99d8a9c45b2eca8864373a26d1459e3dff1e17f3", "1000"); // DAI -> MIM

package/lib/constants/abis/json/registry_exchange.json

@@ -385,6 +385,36 @@
         "stateMutability": "view",
         "type": "function"
     },
+    {
+        "gas": "278915",
+        "inputs": [
+            {
+                "name": "_route",
+                "type": "address[9]"
+            },
+            {
+                "name": "_swap_params",
+                "type": "uint256[3][4]"
+            },
+            {
+                "name": "_amount",
+                "type": "uint256"
+            },
+            {
+                "name": "_pools",
+                "type": "address[4]"
+            }
+        ],
+        "name": "get_exchange_multiple_amount",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
     {
         "gas": "2654",
         "inputs": [

package/lib/curve.js

@@ -115,9 +115,9 @@ var Curve = /** @class */ (function () {
     ) {
         if (options === void 0) { options = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var cTokens, yTokens, ycTokens, aTokens, network, _a, customAbiTokens, _b, _i, _c, pool, _d, _e, coinAddr, _f, _g, coinAddr, _h, _j, coinAddr, _k, _l, rewardTokenAddr, addressProviderContract, _m;
-            return __generator(this, function (_o) {
-                switch (_o.label) {
+            var cTokens, yTokens, ycTokens, aTokens, network, _a, customAbiTokens, _b, _i, _c, pool, _d, _e, coinAddr, _f, _g, coinAddr, _h, _j, coinAddr, _k, _l, rewardTokenAddr, _m, _o, _p, _q, _r, addressProviderContract, _s;
+            return __generator(this, function (_t) {
+                switch (_t.label) {
                     case 0:
                         // JsonRpc provider
                         if (providerType.toLowerCase() === 'JsonRpc'.toLowerCase()) {
@@ -160,8 +160,8 @@ var Curve = /** @class */ (function () {
                         if (_a) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.provider._networkPromise];
                     case 1:
-                        _a = (_o.sent());
-                        _o.label = 2;
+                        _a = (_t.sent());
+                        _t.label = 2;
                     case 2:
                         network = _a;
                         console.log("CURVE-JS IS CONNECTED TO NETWORK:", network);
@@ -217,75 +217,100 @@ var Curve = /** @class */ (function () {
                         this.multicallProvider = new ethcall_1.Provider();
                         return [4 /*yield*/, this.multicallProvider.init(this.provider)];
                     case 3:
-                        _o.sent();
+                        _t.sent();
                         if (!this.signer) return [3 /*break*/, 5];
                         _b = this;
                         return [4 /*yield*/, this.signer.getAddress()];
                     case 4:
-                        _b.signerAddress = _o.sent();
+                        _b.signerAddress = _t.sent();
                         return [3 /*break*/, 6];
                     case 5:
                         this.signerAddress = '';
-                        _o.label = 6;
+                        _t.label = 6;
                     case 6:
                         this.feeData = { gasPrice: options.gasPrice, maxFeePerGas: options.maxFeePerGas, maxPriorityFeePerGas: options.maxPriorityFeePerGas };
                         return [4 /*yield*/, this.updateFeeData()];
                     case 7:
-                        _o.sent();
-                        // TODO delete toLowerCase()
-                        for (_i = 0, _c = Object.values(exports.POOLS_DATA); _i < _c.length; _i++) {
-                            pool = _c[_i];
-                            this.contracts[pool.swap_address] = {
-                                contract: new ethers_1.Contract(pool.swap_address, pool.swap_abi, this.signer || this.provider),
-                                multicallContract: new ethcall_1.Contract(pool.swap_address, pool.swap_abi),
+                        _t.sent();
+                        _i = 0, _c = Object.values(exports.POOLS_DATA);
+                        _t.label = 8;
+                    case 8:
+                        if (!(_i < _c.length)) return [3 /*break*/, 13];
+                        pool = _c[_i];
+                        this.contracts[pool.swap_address] = {
+                            contract: new ethers_1.Contract(pool.swap_address, pool.swap_abi, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(pool.swap_address, pool.swap_abi),
+                        };
+                        this.contracts[pool.swap_address.toLowerCase()] = {
+                            contract: new ethers_1.Contract(pool.swap_address, pool.swap_abi, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(pool.swap_address, pool.swap_abi),
+                        };
+                        if (pool.token_address !== pool.swap_address) {
+                            this.contracts[pool.token_address] = {
+                                contract: new ethers_1.Contract(pool.token_address, ERC20_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(pool.token_address, ERC20_json_1.default),
                             };
-                            this.contracts[pool.swap_address.toLowerCase()] = {
-                                contract: new ethers_1.Contract(pool.swap_address, pool.swap_abi, this.signer || this.provider),
-                                multicallContract: new ethcall_1.Contract(pool.swap_address, pool.swap_abi),
+                            this.contracts[pool.token_address.toLowerCase()] = {
+                                contract: new ethers_1.Contract(pool.token_address, ERC20_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(pool.token_address, ERC20_json_1.default),
                             };
-                            if (pool.token_address !== pool.swap_address) {
-                                this.contracts[pool.token_address] = {
-                                    contract: new ethers_1.Contract(pool.token_address, ERC20_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(pool.token_address, ERC20_json_1.default),
-                                };
-                                this.contracts[pool.token_address.toLowerCase()] = {
-                                    contract: new ethers_1.Contract(pool.token_address, ERC20_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(pool.token_address, ERC20_json_1.default),
-                                };
-                            }
-                            this.contracts[pool.gauge_address] = {
-                                contract: new ethers_1.Contract(pool.gauge_address, pool.gauge_abi, this.signer || this.provider),
-                                multicallContract: new ethcall_1.Contract(pool.gauge_address, pool.gauge_abi),
+                        }
+                        this.contracts[pool.gauge_address] = {
+                            contract: new ethers_1.Contract(pool.gauge_address, pool.gauge_abi, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(pool.gauge_address, pool.gauge_abi),
+                        };
+                        this.contracts[pool.gauge_address.toLowerCase()] = {
+                            contract: new ethers_1.Contract(pool.gauge_address, pool.gauge_abi, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(pool.gauge_address, pool.gauge_abi),
+                        };
+                        if (pool.deposit_address && this.contracts[pool.deposit_address] === undefined) {
+                            this.contracts[pool.deposit_address] = {
+                                contract: new ethers_1.Contract(pool.deposit_address, pool.deposit_abi, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(pool.deposit_address, pool.deposit_abi),
                             };
-                            this.contracts[pool.gauge_address.toLowerCase()] = {
-                                contract: new ethers_1.Contract(pool.gauge_address, pool.gauge_abi, this.signer || this.provider),
-                                multicallContract: new ethcall_1.Contract(pool.gauge_address, pool.gauge_abi),
+                            this.contracts[pool.deposit_address.toLowerCase()] = {
+                                contract: new ethers_1.Contract(pool.deposit_address, pool.deposit_abi, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(pool.deposit_address, pool.deposit_abi),
                             };
-                            if (pool.deposit_address && this.contracts[pool.deposit_address] === undefined) {
-                                this.contracts[pool.deposit_address] = {
-                                    contract: new ethers_1.Contract(pool.deposit_address, pool.deposit_abi, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(pool.deposit_address, pool.deposit_abi),
-                                };
-                                this.contracts[pool.deposit_address.toLowerCase()] = {
-                                    contract: new ethers_1.Contract(pool.deposit_address, pool.deposit_abi, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(pool.deposit_address, pool.deposit_abi),
-                                };
-                            }
-                            for (_d = 0, _e = pool.underlying_coin_addresses; _d < _e.length; _d++) {
-                                coinAddr = _e[_d];
+                        }
+                        for (_d = 0, _e = pool.underlying_coin_addresses; _d < _e.length; _d++) {
+                            coinAddr = _e[_d];
+                            this.contracts[coinAddr] = {
+                                contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
+                            };
+                            this.contracts[coinAddr.toLowerCase()] = {
+                                contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
+                            };
+                        }
+                        for (_f = 0, _g = pool.coin_addresses; _f < _g.length; _f++) {
+                            coinAddr = _g[_f];
+                            if (customAbiTokens.includes(coinAddr))
+                                continue;
+                            this.contracts[coinAddr] = {
+                                contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
+                            };
+                            this.contracts[coinAddr.toLowerCase()] = {
+                                contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
+                            };
+                        }
+                        // TODO add all coins
+                        for (_h = 0, _j = pool.coin_addresses; _h < _j.length; _h++) {
+                            coinAddr = _j[_h];
+                            if (cTokens.includes(coinAddr)) {
                                 this.contracts[coinAddr] = {
-                                    contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
+                                    contract: new ethers_1.Contract(coinAddr, cERC20_json_1.default, this.signer || this.provider),
+                                    multicallContract: new ethcall_1.Contract(coinAddr, cERC20_json_1.default),
                                 };
                                 this.contracts[coinAddr.toLowerCase()] = {
-                                    contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
+                                    contract: new ethers_1.Contract(coinAddr, cERC20_json_1.default, this.signer || this.provider),
+                                    multicallContract: new ethcall_1.Contract(coinAddr, cERC20_json_1.default),
                                 };
                             }
-                            for (_f = 0, _g = pool.coin_addresses; _f < _g.length; _f++) {
-                                coinAddr = _g[_f];
-                                if (customAbiTokens.includes(coinAddr))
-                                    continue;
+                            if (aTokens.includes(coinAddr)) {
                                 this.contracts[coinAddr] = {
                                     contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
                                     multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
@@ -295,62 +320,56 @@ var Curve = /** @class */ (function () {
                                     multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
                                 };
                             }
-                            // TODO add all coins
-                            for (_h = 0, _j = pool.coin_addresses; _h < _j.length; _h++) {
-                                coinAddr = _j[_h];
-                                if (cTokens.includes(coinAddr)) {
-                                    this.contracts[coinAddr] = {
-                                        contract: new ethers_1.Contract(coinAddr, cERC20_json_1.default, this.signer || this.provider),
-                                        multicallContract: new ethcall_1.Contract(coinAddr, cERC20_json_1.default),
-                                    };
-                                    this.contracts[coinAddr.toLowerCase()] = {
-                                        contract: new ethers_1.Contract(coinAddr, cERC20_json_1.default, this.signer || this.provider),
-                                        multicallContract: new ethcall_1.Contract(coinAddr, cERC20_json_1.default),
-                                    };
-                                }
-                                if (aTokens.includes(coinAddr)) {
-                                    this.contracts[coinAddr] = {
-                                        contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
-                                        multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
-                                    };
-                                    this.contracts[coinAddr.toLowerCase()] = {
-                                        contract: new ethers_1.Contract(coinAddr, ERC20_json_1.default, this.signer || this.provider),
-                                        multicallContract: new ethcall_1.Contract(coinAddr, ERC20_json_1.default),
-                                    };
-                                }
-                                if (yTokens.includes(coinAddr) || ycTokens.includes(coinAddr)) {
-                                    this.contracts[coinAddr] = {
-                                        contract: new ethers_1.Contract(coinAddr, yERC20_json_1.default, this.signer || this.provider),
-                                        multicallContract: new ethcall_1.Contract(coinAddr, yERC20_json_1.default),
-                                    };
-                                    this.contracts[coinAddr.toLowerCase()] = {
-                                        contract: new ethers_1.Contract(coinAddr, yERC20_json_1.default, this.signer || this.provider),
-                                        multicallContract: new ethcall_1.Contract(coinAddr, yERC20_json_1.default),
-                                    };
-                                }
-                            }
-                            if (pool.reward_contract) {
-                                this.contracts[pool.reward_contract] = {
-                                    contract: new ethers_1.Contract(pool.reward_contract, streamer_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(pool.reward_contract, streamer_json_1.default),
-                                };
-                                this.contracts[pool.reward_contract.toLowerCase()] = {
-                                    contract: new ethers_1.Contract(pool.reward_contract, streamer_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(pool.reward_contract, streamer_json_1.default),
-                                };
-                            }
-                            for (_k = 0, _l = pool.reward_tokens || []; _k < _l.length; _k++) {
-                                rewardTokenAddr = _l[_k];
-                                this.contracts[rewardTokenAddr] = {
-                                    contract: new ethers_1.Contract(rewardTokenAddr, ERC20_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(rewardTokenAddr, ERC20_json_1.default),
+                            if (yTokens.includes(coinAddr) || ycTokens.includes(coinAddr)) {
+                                this.contracts[coinAddr] = {
+                                    contract: new ethers_1.Contract(coinAddr, yERC20_json_1.default, this.signer || this.provider),
+                                    multicallContract: new ethcall_1.Contract(coinAddr, yERC20_json_1.default),
                                 };
-                                this.contracts[rewardTokenAddr.toLowerCase()] = {
-                                    contract: new ethers_1.Contract(rewardTokenAddr, ERC20_json_1.default, this.signer || this.provider),
-                                    multicallContract: new ethcall_1.Contract(rewardTokenAddr, ERC20_json_1.default),
+                                this.contracts[coinAddr.toLowerCase()] = {
+                                    contract: new ethers_1.Contract(coinAddr, yERC20_json_1.default, this.signer || this.provider),
+                                    multicallContract: new ethcall_1.Contract(coinAddr, yERC20_json_1.default),
                                 };
                             }
                         }
+                        if (pool.reward_contract) {
+                            this.contracts[pool.reward_contract] = {
+                                contract: new ethers_1.Contract(pool.reward_contract, streamer_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(pool.reward_contract, streamer_json_1.default),
+                            };
+                            this.contracts[pool.reward_contract.toLowerCase()] = {
+                                contract: new ethers_1.Contract(pool.reward_contract, streamer_json_1.default, this.signer || this.provider),
+                                multicallContract: new ethcall_1.Contract(pool.reward_contract, streamer_json_1.default),
+                            };
+                        }
+                        _k = 0, _l = pool.reward_tokens || [];
+                        _t.label = 9;
+                    case 9:
+                        if (!(_k < _l.length)) return [3 /*break*/, 12];
+                        rewardTokenAddr = _l[_k];
+                        this.contracts[rewardTokenAddr] = {
+                            contract: new ethers_1.Contract(rewardTokenAddr, ERC20_json_1.default, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(rewardTokenAddr, ERC20_json_1.default),
+                        };
+                        this.contracts[rewardTokenAddr.toLowerCase()] = {
+                            contract: new ethers_1.Contract(rewardTokenAddr, ERC20_json_1.default, this.signer || this.provider),
+                            multicallContract: new ethcall_1.Contract(rewardTokenAddr, ERC20_json_1.default),
+                        };
+                        _m = exports.DECIMALS_LOWER_CASE;
+                        _o = rewardTokenAddr.toLowerCase();
+                        _p = Number;
+                        _r = (_q = ethers_1.ethers.utils).formatUnits;
+                        return [4 /*yield*/, this.contracts[rewardTokenAddr].contract.decimals()];
+                    case 10:
+                        _m[_o] =
+                            _p.apply(void 0, [_r.apply(_q, [_t.sent(), 0])]);
+                        _t.label = 11;
+                    case 11:
+                        _k++;
+                        return [3 /*break*/, 9];
+                    case 12:
+                        _i++;
+                        return [3 /*break*/, 8];
+                    case 13:
                         this.contracts[exports.ALIASES.crv] = {
                             contract: new ethers_1.Contract(exports.ALIASES.crv, ERC20_json_1.default, this.signer || this.provider),
                             multicallContract: new ethcall_1.Contract(exports.ALIASES.crv, ERC20_json_1.default),
@@ -384,10 +403,10 @@ var Curve = /** @class */ (function () {
                             multicallContract: new ethcall_1.Contract(exports.ALIASES.address_provider, address_provider_json_1.default),
                         };
                         addressProviderContract = this.contracts[exports.ALIASES.address_provider].contract;
-                        _m = exports.ALIASES;
+                        _s = exports.ALIASES;
                         return [4 /*yield*/, addressProviderContract.get_address(2, this.constantOptions)];
-                    case 8:
-                        _m.registry_exchange = _o.sent();
+                    case 14:
+                        _s.registry_exchange = _t.sent();
                         this.contracts[exports.ALIASES.registry_exchange] = {
                             contract: new ethers_1.Contract(exports.ALIASES.registry_exchange, registry_exchange_json_1.default, this.signer || this.provider),
                             multicallContract: new ethcall_1.Contract(exports.ALIASES.registry_exchange, registry_exchange_json_1.default),

package/lib/external-api.d.ts

@@ -0,0 +1,3 @@
+import { IExtendedPoolDataFromApi } from "./interfaces";
+import memoize from "memoizee";
+export declare const _getPoolsFromApi: ((network: "ethereum" | "polygon", poolType: "main" | "crypto" | "factory" | "factory-crypto") => Promise<IExtendedPoolDataFromApi>) & memoize.Memoized<(network: "ethereum" | "polygon", poolType: "main" | "crypto" | "factory" | "factory-crypto") => Promise<IExtendedPoolDataFromApi>>;

package/lib/external-api.js

@@ -0,0 +1,67 @@
+"use strict";
+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 (_) 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getPoolsFromApi = void 0;
+var axios_1 = __importDefault(require("axios"));
+var memoizee_1 = __importDefault(require("memoizee"));
+exports._getPoolsFromApi = (0, memoizee_1.default)(function (network, poolType) { return __awaiter(void 0, void 0, void 0, function () {
+    var url, response, err_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                url = "https://api.curve.fi/api/getPools/".concat(network, "/").concat(poolType);
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, axios_1.default.get(url)];
+            case 2:
+                response = _a.sent();
+                return [2 /*return*/, response.data.data];
+            case 3:
+                err_1 = _a.sent();
+                return [2 /*return*/, { poolData: [], tvl: 0, tvlAll: 0 }];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); }, {
+    promise: true,
+    maxAge: 5 * 60 * 1000, // 5m
+});

package/lib/index.d.ts

@@ -30,6 +30,7 @@ declare const curve: {
     getFactoryPoolList: () => string[];
     getCryptoFactoryPoolList: () => string[];
     getUsdRate: (coin: string) => Promise<number>;
+    getTVL: (chainId?: number) => Promise<number>;
     setCustomFeeData: typeof setCustomFeeData;
     signerAddress: string;
     chainId: number;
@@ -57,12 +58,22 @@ declare const curve: {
     crossAssetExchangeApprove: (inputCoin: string, amount: string) => Promise<string[]>;
     crossAssetExchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<string>;
     getUserPoolList: (address?: string | undefined) => Promise<string[]>;
+    getBestRouteAndOutput: (inputCoin: string, outputCoin: string, amount: string) => Promise<{
+        route: import("./interfaces").IRouteStep[];
+        output: string;
+    }>;
+    routerExchangeExpected: (inputCoin: string, outputCoin: string, amount: string) => Promise<string>;
+    routerExchangeIsApproved: (inputCoin: string, amount: string) => Promise<boolean>;
+    routerExchangeApprove: (inputCoin: string, amount: string) => Promise<string[]>;
+    routerExchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<string>;
     estimateGas: {
         ensureAllowance: (coins: string[], amounts: string[], spender: string) => Promise<number>;
         exchangeApprove: (inputCoin: string, outputCoin: string, amount: string) => Promise<number>;
         exchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<number>;
         crossAssetExchangeApprove: (inputCoin: string, amount: string) => Promise<number>;
         crossAssetExchange: (inputCoin: string, outputCoin: string, amount: string, maxSlippage?: number) => Promise<number>;
+        routerExchangeApprove: (inputCoin: string, amount: string) => Promise<number>;
+        routerExchange: (inputCoin: string, outputCoin: string, amount: string) => Promise<number>;
     };
     boosting: {
         getCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").DictInterface<string>>;

package/lib/index.js

@@ -94,6 +94,7 @@ var curve = {
     getFactoryPoolList: utils_1.getFactoryPoolList,
     getCryptoFactoryPoolList: utils_1.getCryptoFactoryPoolList,
     getUsdRate: utils_1.getUsdRate,
+    getTVL: utils_1.getTVL,
     setCustomFeeData: setCustomFeeData,
     signerAddress: '',
     chainId: 0,
@@ -114,12 +115,19 @@ var curve = {
     crossAssetExchangeApprove: pools_1.crossAssetExchangeApprove,
     crossAssetExchange: pools_1.crossAssetExchange,
     getUserPoolList: pools_1.getUserPoolList,
+    getBestRouteAndOutput: pools_1.getBestRouteAndOutput,
+    routerExchangeExpected: pools_1.routerExchangeExpected,
+    routerExchangeIsApproved: pools_1.routerExchangeIsApproved,
+    routerExchangeApprove: pools_1.routerExchangeApprove,
+    routerExchange: pools_1.routerExchange,
     estimateGas: {
         ensureAllowance: utils_1.ensureAllowanceEstimateGas,
         exchangeApprove: pools_1.exchangeApproveEstimateGas,
         exchange: pools_1.exchangeEstimateGas,
         crossAssetExchangeApprove: pools_1.crossAssetExchangeApproveEstimateGas,
         crossAssetExchange: pools_1.crossAssetExchangeEstimateGas,
+        routerExchangeApprove: pools_1.routerExchangeApproveEstimateGas,
+        routerExchange: pools_1.routerExchangeEstimateGas,
     },
     boosting: {
         getCrv: boosting_1.getCrv,

package/lib/interfaces.d.ts

@@ -92,6 +92,7 @@ export interface ICoinFromPoolDataApi {
     address: string;
     symbol: string;
     decimals: string;
+    usdPrice: number | string;
 }
 export interface IPoolDataFromApi {
     id: string;
@@ -104,6 +105,12 @@ export interface IPoolDataFromApi {
     implementation: string;
     implementationAddress: string;
     coins: ICoinFromPoolDataApi[];
+    usdTotal: number;
+}
+export interface IExtendedPoolDataFromApi {
+    poolData: IPoolDataFromApi[];
+    tvl?: number;
+    tvlAll: number;
 }
 export interface RewardsApyInterface {
     token: string;
@@ -127,9 +134,24 @@ export interface ISinglePoolSwapData {
     poolAddress: string;
     i: number;
     j: number;
-    swapType: 1 | 2 | 3 | 4;
+    swapType: 1 | 2 | 3 | 4 | 5;
     swapAddress: string;
 }
 export interface ISinglePoolSwapDataAndOutput extends ISinglePoolSwapData {
     _output: ethers.BigNumber;
 }
+export interface IRouteStep {
+    poolId: string;
+    poolAddress: string;
+    outputCoinAddress: string;
+    i: number;
+    j: number;
+    swapType: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+    swapAddress: string;
+}
+export interface IRoute {
+    steps: IRouteStep[];
+    _output: ethers.BigNumber;
+    outputUsd: number;
+    txCostUsd: number;
+}