@curvefi/api 2.33.1 → 2.34.1

package/lib/constants/coins/ethereum.js

@@ -53,6 +53,7 @@ export var COINS_ETHEREUM = lowerCaseValues({
     reth: "0x9559aaa82d9649c7a7b220e7c461d2e74c9a3593",
     weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
     frxeth: "0x5E8422345238F34275888049021821E8E08CAa1f",
+    sfrxeth: "0xac3E018457B222d93114458476f3E3416Abbe38F",
     // --- BTC ---
     sbtccrv: "0x075b1bb99792c9E1041bA13afEf80C91a1e70fB3",
     hbtc: "0x0316EB71485b0Ab14103307bf65a021042c6d380",

package/lib/constants/pools/ethereum.d.ts

@@ -1,2 +1,3 @@
 import { IDict, IPoolData } from "../../interfaces";
 export declare const POOLS_DATA_ETHEREUM: IDict<IPoolData>;
+export declare const LLAMMAS_DATA_ETHEREUM: IDict<IPoolData>;

package/lib/constants/pools/ethereum.js

@@ -87,6 +87,7 @@ import fraxusdcSwapABI from '../abis/fraxusdc/swap.json' assert { type: 'json' }
 import frxethSwapABI from '../abis/frxeth/swap.json' assert { type: 'json' };
 import sbtc2SwapABI from '../abis/sbtc2/swap.json' assert { type: 'json' };
 import wbethSwapABI from '../abis/wbeth/swap.json' assert { type: 'json' };
+import LlammaABI from '../abis/llamma.json' assert { type: 'json' };
 export var POOLS_DATA_ETHEREUM = lowerCasePoolDataAddresses({
     compound: {
         name: "compound",
@@ -1643,3 +1644,31 @@ export var POOLS_DATA_ETHEREUM = lowerCasePoolDataAddresses({
         gauge_abi: gaugeV5ABI,
     },
 });
+export var LLAMMAS_DATA_ETHEREUM = lowerCasePoolDataAddresses({
+    'sfrxeth-llamma': {
+        name: "sfrxeth",
+        full_name: "sfrxeth",
+        symbol: "sfrxeth",
+        reference_asset: 'CRYPTO',
+        swap_address: '0x77fCFB78151c676f390a6236A78b5d3152e43384',
+        token_address: '0x0000000000000000000000000000000000000000',
+        gauge_address: '0x0000000000000000000000000000000000000000',
+        is_crypto: true,
+        is_plain: true,
+        is_llamma: true,
+        underlying_coins: ['crvUSD', 'sfrxETH'],
+        wrapped_coins: ['crvUSD', 'sfrxETH'],
+        underlying_coin_addresses: [
+            '0xf71040d20Cc3FFBb28c1abcEF46134C7936624e0',
+            '0xac3E018457B222d93114458476f3E3416Abbe38F',
+        ],
+        wrapped_coin_addresses: [
+            '0xf71040d20Cc3FFBb28c1abcEF46134C7936624e0',
+            '0xac3E018457B222d93114458476f3E3416Abbe38F',
+        ],
+        underlying_decimals: [18, 18],
+        wrapped_decimals: [18, 18],
+        swap_abi: LlammaABI,
+        gauge_abi: gaugeV5ABI,
+    },
+});

package/lib/constants/pools/index.d.ts

@@ -1,4 +1,5 @@
 import { POOLS_DATA_ETHEREUM } from "./ethereum.js";
+import { LLAMMAS_DATA_ETHEREUM } from "./ethereum.js";
 import { POOLS_DATA_POLYGON } from "./polygon.js";
 import { POOLS_DATA_FANTOM } from "./fantom.js";
 import { POOLS_DATA_AVALANCHE } from "./avalanche.js";
@@ -9,4 +10,4 @@ import { POOLS_DATA_MOONBEAM } from "./moonbeam.js";
 import { POOLS_DATA_AURORA } from "./aurora.js";
 import { POOLS_DATA_KAVA } from "./kava.js";
 import { POOLS_DATA_CELO } from "./celo.js";
-export { POOLS_DATA_ETHEREUM, POOLS_DATA_POLYGON, POOLS_DATA_FANTOM, POOLS_DATA_AVALANCHE, POOLS_DATA_ARBITRUM, POOLS_DATA_OPTIMISM, POOLS_DATA_XDAI, POOLS_DATA_MOONBEAM, POOLS_DATA_AURORA, POOLS_DATA_KAVA, POOLS_DATA_CELO, };
+export { POOLS_DATA_ETHEREUM, LLAMMAS_DATA_ETHEREUM, POOLS_DATA_POLYGON, POOLS_DATA_FANTOM, POOLS_DATA_AVALANCHE, POOLS_DATA_ARBITRUM, POOLS_DATA_OPTIMISM, POOLS_DATA_XDAI, POOLS_DATA_MOONBEAM, POOLS_DATA_AURORA, POOLS_DATA_KAVA, POOLS_DATA_CELO, };

package/lib/constants/pools/index.js

@@ -1,4 +1,5 @@
 import { POOLS_DATA_ETHEREUM } from "./ethereum.js";
+import { LLAMMAS_DATA_ETHEREUM } from "./ethereum.js";
 import { POOLS_DATA_POLYGON } from "./polygon.js";
 import { POOLS_DATA_FANTOM } from "./fantom.js";
 import { POOLS_DATA_AVALANCHE } from "./avalanche.js";
@@ -9,4 +10,4 @@ import { POOLS_DATA_MOONBEAM } from "./moonbeam.js";
 import { POOLS_DATA_AURORA } from "./aurora.js";
 import { POOLS_DATA_KAVA } from "./kava.js";
 import { POOLS_DATA_CELO } from "./celo.js";
-export { POOLS_DATA_ETHEREUM, POOLS_DATA_POLYGON, POOLS_DATA_FANTOM, POOLS_DATA_AVALANCHE, POOLS_DATA_ARBITRUM, POOLS_DATA_OPTIMISM, POOLS_DATA_XDAI, POOLS_DATA_MOONBEAM, POOLS_DATA_AURORA, POOLS_DATA_KAVA, POOLS_DATA_CELO, };
+export { POOLS_DATA_ETHEREUM, LLAMMAS_DATA_ETHEREUM, POOLS_DATA_POLYGON, POOLS_DATA_FANTOM, POOLS_DATA_AVALANCHE, POOLS_DATA_ARBITRUM, POOLS_DATA_OPTIMISM, POOLS_DATA_XDAI, POOLS_DATA_MOONBEAM, POOLS_DATA_AURORA, POOLS_DATA_KAVA, POOLS_DATA_CELO, };

package/lib/curve.d.ts

@@ -49,6 +49,7 @@ declare class Curve implements ICurve {
         POOLS_DATA: IDict<IPoolData>;
         FACTORY_POOLS_DATA: IDict<IPoolData>;
         CRYPTO_FACTORY_POOLS_DATA: IDict<IPoolData>;
+        LLAMMAS_DATA: IDict<IPoolData>;
         COINS: IDict<string>;
         DECIMALS: IDict<number>;
         GAUGES: string[];

package/lib/curve.js

@@ -76,7 +76,7 @@ import registryExchangeABI from './constants/abis/registry_exchange.json' assert
 import streamerABI from './constants/abis/streamer.json' assert { type: 'json' };
 import factoryABI from './constants/abis/factory.json' assert { type: 'json' };
 import cryptoFactoryABI from './constants/abis/factory-crypto.json' assert { type: 'json' };
-import { POOLS_DATA_ETHEREUM, POOLS_DATA_POLYGON, POOLS_DATA_FANTOM, POOLS_DATA_AVALANCHE, POOLS_DATA_ARBITRUM, POOLS_DATA_OPTIMISM, POOLS_DATA_XDAI, POOLS_DATA_MOONBEAM, POOLS_DATA_AURORA, POOLS_DATA_KAVA, POOLS_DATA_CELO, } from './constants/pools/index.js';
+import { POOLS_DATA_ETHEREUM, LLAMMAS_DATA_ETHEREUM, POOLS_DATA_POLYGON, POOLS_DATA_FANTOM, POOLS_DATA_AVALANCHE, POOLS_DATA_ARBITRUM, POOLS_DATA_OPTIMISM, POOLS_DATA_XDAI, POOLS_DATA_MOONBEAM, POOLS_DATA_AURORA, POOLS_DATA_KAVA, POOLS_DATA_CELO, } from './constants/pools/index.js';
 import { ALIASES_ETHEREUM, ALIASES_OPTIMISM, ALIASES_POLYGON, ALIASES_FANTOM, ALIASES_AVALANCHE, ALIASES_ARBITRUM, ALIASES_XDAI, ALIASES_MOONBEAM, ALIASES_AURORA, ALIASES_KAVA, ALIASES_CELO, } from "./constants/aliases.js";
 import { COINS_ETHEREUM, cTokensEthereum, yTokensEthereum, ycTokensEthereum, aTokensEthereum } from "./constants/coins/ethereum.js";
 import { COINS_OPTIMISM, cTokensOptimism, yTokensOptimism, ycTokensOptimism, aTokensOptimism } from "./constants/coins/optimism.js";
@@ -185,6 +185,7 @@ export var NETWORK_CONSTANTS = {
         NAME: 'ethereum',
         ALIASES: ALIASES_ETHEREUM,
         POOLS_DATA: POOLS_DATA_ETHEREUM,
+        LLAMMAS_DATA: LLAMMAS_DATA_ETHEREUM,
         COINS: COINS_ETHEREUM,
         cTokens: cTokensEthereum,
         yTokens: yTokensEthereum,
@@ -304,38 +305,41 @@ var Curve = /** @class */ (function () {
                         case 0:
                             if (this.chainId === 1313161554)
                                 return [2 /*return*/];
-                            if (!useApi) return [3 /*break*/, 3];
+                            if (!useApi) return [3 /*break*/, 4];
                             _a = this.constants;
                             _b = lowerCasePoolDataAddresses;
                             return [4 /*yield*/, getFactoryPoolsDataFromApi.call(this, false)];
                         case 1:
                             _a.FACTORY_POOLS_DATA = _b.apply(void 0, [_h.sent()]);
+                            if (!(this.chainId === 1)) return [3 /*break*/, 3];
                             _c = lowerCasePoolDataAddresses;
                             return [4 /*yield*/, getFactoryPoolData.call(this, 0, undefined, this.constants.ALIASES.crvusd_factory)];
                         case 2:
                             poolData = _c.apply(void 0, [_h.sent()]);
                             this.constants.FACTORY_POOLS_DATA = __assign(__assign({}, this.constants.FACTORY_POOLS_DATA), poolData);
-                            return [3 /*break*/, 6];
-                        case 3:
+                            _h.label = 3;
+                        case 3: return [3 /*break*/, 7];
+                        case 4:
                             _d = this.constants;
                             _e = lowerCasePoolDataAddresses;
                             return [4 /*yield*/, getFactoryPoolData.call(this)];
-                        case 4:
+                        case 5:
                             _d.FACTORY_POOLS_DATA = _e.apply(void 0, [_h.sent()]);
+                            if (!(this.chainId === 1)) return [3 /*break*/, 7];
                             _f = lowerCasePoolDataAddresses;
                             return [4 /*yield*/, getFactoryPoolData.call(this, 0, undefined, this.constants.ALIASES.crvusd_factory)];
-                        case 5:
+                        case 6:
                             poolData = _f.apply(void 0, [_h.sent()]);
                             this.constants.FACTORY_POOLS_DATA = __assign(__assign({}, this.constants.FACTORY_POOLS_DATA), poolData);
-                            _h.label = 6;
-                        case 6:
+                            _h.label = 7;
+                        case 7:
                             _g = this.constants;
                             return [4 /*yield*/, this._filterHiddenPools(this.constants.FACTORY_POOLS_DATA)];
-                        case 7:
+                        case 8:
                             _g.FACTORY_POOLS_DATA = _h.sent();
                             this._updateDecimalsAndGauges(this.constants.FACTORY_POOLS_DATA);
                             return [4 /*yield*/, _killGauges(this.constants.FACTORY_POOLS_DATA)];
-                        case 8:
+                        case 9:
                             _h.sent();
                             return [2 /*return*/];
                     }
@@ -473,6 +477,7 @@ var Curve = /** @class */ (function () {
             POOLS_DATA: {},
             FACTORY_POOLS_DATA: {},
             CRYPTO_FACTORY_POOLS_DATA: {},
+            LLAMMAS_DATA: {},
             COINS: {},
             DECIMALS: {},
             GAUGES: [],
@@ -507,6 +512,7 @@ var Curve = /** @class */ (function () {
                             POOLS_DATA: {},
                             FACTORY_POOLS_DATA: {},
                             CRYPTO_FACTORY_POOLS_DATA: {},
+                            LLAMMAS_DATA: {},
                             COINS: {},
                             DECIMALS: {},
                             GAUGES: [],
@@ -572,10 +578,12 @@ var Curve = /** @class */ (function () {
                         this.constants.NETWORK_NAME = NETWORK_CONSTANTS[this.chainId].NAME;
                         this.constants.ALIASES = NETWORK_CONSTANTS[this.chainId].ALIASES;
                         this.constants.POOLS_DATA = NETWORK_CONSTANTS[this.chainId].POOLS_DATA;
+                        if (this.chainId === 1)
+                            this.constants.LLAMMAS_DATA = NETWORK_CONSTANTS[this.chainId].LLAMMAS_DATA;
                         for (poolId in this.constants.POOLS_DATA)
                             this.constants.POOLS_DATA[poolId].in_api = true;
                         this.constants.COINS = NETWORK_CONSTANTS[this.chainId].COINS;
-                        this.constants.DECIMALS = extractDecimals(this.constants.POOLS_DATA);
+                        this.constants.DECIMALS = extractDecimals(__assign(__assign({}, this.constants.POOLS_DATA), this.constants.LLAMMAS_DATA));
                         this.constants.DECIMALS[this.constants.NATIVE_TOKEN.address] = 18;
                         this.constants.DECIMALS[this.constants.NATIVE_TOKEN.wrappedAddress] = 18;
                         this.constants.GAUGES = extractGauges(this.constants.POOLS_DATA);
@@ -612,7 +620,7 @@ var Curve = /** @class */ (function () {
                         return [4 /*yield*/, this.updateFeeData()];
                     case 18:
                         _p.sent();
-                        for (_i = 0, _f = Object.values(this.constants.POOLS_DATA); _i < _f.length; _i++) {
+                        for (_i = 0, _f = Object.values(__assign(__assign({}, this.constants.POOLS_DATA), this.constants.LLAMMAS_DATA)); _i < _f.length; _i++) {
                             pool = _f[_i];
                             this.setContract(pool.swap_address, pool.swap_abi);
                             if (pool.token_address !== pool.swap_address) {

package/lib/factory/constants.js

@@ -52,7 +52,7 @@ export var implementationABIDictEthereum = lowerCaseKeys({
     "0x4A4d7868390EF5CaC51cDA262888f34bD3025C3F": Plain2OptimizedABI,
     "0xc629a01eC23AB04E1050500A3717A2a5c0701497": Plain2BasicABI,
     "0x94b4DFd9Ba5865Cc931195c99A2db42F3fc5d45B": Plain2ETHABI,
-    "0xb9f861B7755Ff09cFD65CfE262D19823607b1f24": Plain2BasicABI,
+    "0xAee70429bdfbf599a979f50d5Fde5EB0d317E0f7": Plain2BasicABI,
     "0x9B52F13DF69D79Ec5aAB6D1aCe3157d29B409cC3": Plain3BasicABI,
     "0x50b085f2e5958C4A87baf93A8AB79F6bec068494": Plain3BalancesABI,
     "0x8c1aB78601c259E1B43F19816923609dC7d7de9B": Plain3ETHABI,

package/lib/factory/factory-crypto.js

@@ -314,11 +314,11 @@ export function getCryptoFactoryPoolData(fromIdx, swapAddress) {
                                 is_factory: true,
                                 base_pool: basePoolId,
                                 underlying_coins: __spreadArray([coinAddressNameDict[underlyingCoinAddresses[i][0]]], basePoolCoinNames, true),
-                                wrapped_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
+                                wrapped_coins: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
                                 underlying_coin_addresses: __spreadArray([underlyingCoinAddresses[i][0]], basePoolCoinAddresses, true),
                                 wrapped_coin_addresses: coinAddresses[i],
                                 underlying_decimals: __spreadArray([coinAddressDecimalsDict[underlyingCoinAddresses[i][0]]], basePoolDecimals, true),
-                                wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
+                                wrapped_decimals: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
                                 swap_abi: cryptoFactorySwapABI,
                                 gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                                 deposit_abi: basePoolZap.ABI,
@@ -336,12 +336,12 @@ export function getCryptoFactoryPoolData(fromIdx, swapAddress) {
                                 is_crypto: true,
                                 is_plain: underlyingCoinAddresses[i].toString() === coinAddresses[i].toString(),
                                 is_factory: true,
-                                underlying_coins: underlyingCoinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
-                                wrapped_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
+                                underlying_coins: __spreadArray([], underlyingCoinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
+                                wrapped_coins: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
                                 underlying_coin_addresses: underlyingCoinAddresses[i],
                                 wrapped_coin_addresses: coinAddresses[i],
-                                underlying_decimals: underlyingCoinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
-                                wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
+                                underlying_decimals: __spreadArray([], underlyingCoinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
+                                wrapped_decimals: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
                                 swap_abi: cryptoFactorySwapABI,
                                 gauge_abi: this.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                             };

package/lib/factory/factory.js

@@ -337,12 +337,12 @@ export function getFactoryPoolData(fromIdx, swapAddress, factoryAddress) {
                                 implementation_address: implementations[i],
                                 is_plain: true,
                                 is_factory: true,
-                                underlying_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
-                                wrapped_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
+                                underlying_coins: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
+                                wrapped_coins: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
                                 underlying_coin_addresses: coinAddresses[i],
                                 wrapped_coin_addresses: coinAddresses[i],
-                                underlying_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
-                                wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
+                                underlying_decimals: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
+                                wrapped_decimals: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
                                 swap_abi: swapABIs[i],
                                 gauge_abi: this_1.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                             };
@@ -371,11 +371,11 @@ export function getFactoryPoolData(fromIdx, swapAddress, factoryAddress) {
                                 is_factory: true,
                                 base_pool: basePoolIds[i],
                                 underlying_coins: __spreadArray([coinAddressNameDict[coinAddresses[i][0]]], basePoolIdCoinsDict[basePoolIds[i]], true),
-                                wrapped_coins: coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }),
+                                wrapped_coins: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressNameDict[addr]; }), true),
                                 underlying_coin_addresses: __spreadArray([coinAddresses[i][0]], basePoolIdCoinAddressesDict[basePoolIds[i]], true),
                                 wrapped_coin_addresses: coinAddresses[i],
                                 underlying_decimals: __spreadArray([coinAddressDecimalsDict[coinAddresses[i][0]]], basePoolIdDecimalsDict[basePoolIds[i]], true),
-                                wrapped_decimals: coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }),
+                                wrapped_decimals: __spreadArray([], coinAddresses[i].map(function (addr) { return coinAddressDecimalsDict[addr]; }), true),
                                 swap_abi: swapABIs[i],
                                 gauge_abi: this_1.chainId === 1 ? factoryGaugeABI : gaugeChildABI,
                                 deposit_abi: basePoolZap.ABI,

package/lib/interfaces.d.ts

@@ -24,6 +24,7 @@ export interface IPoolData {
     is_crypto?: boolean;
     is_fake?: boolean;
     is_factory?: boolean;
+    is_llamma?: boolean;
     base_pool?: string;
     meta_coin_idx?: number;
     underlying_coins: string[];

package/lib/pools/PoolTemplate.d.ts

@@ -19,6 +19,7 @@ export declare class PoolTemplate {
     isFake: boolean;
     isFactory: boolean;
     isMetaFactory: boolean;
+    isLlamma: boolean;
     basePool: string;
     metaCoinIdx: number;
     underlyingCoins: string[];

package/lib/pools/PoolTemplate.js

@@ -157,20 +157,39 @@ var PoolTemplate = /** @class */ (function () {
         this.statsTotalLiquidity = function (useApi) {
             if (useApi === void 0) { useApi = true; }
             return __awaiter(_this, void 0, void 0, function () {
-                var network, poolType, poolsData, totalLiquidity_1, balances, promises, _i, _c, addr, prices, totalLiquidity;
+                var stablecoinContract, collateralContract, ammContract, _c, _balance_x, _fee_x, _balance_y, _fee_y, collateralRate, stablecoinTvlBN, collateralTvlBN, network, poolType, poolsData, totalLiquidity_1, balances, promises, _i, _d, addr, prices, totalLiquidity;
                 var _this = this;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
                         case 0:
-                            if (!useApi) return [3 /*break*/, 2];
+                            if (!this.isLlamma) return [3 /*break*/, 3];
+                            stablecoinContract = curve.contracts[this.underlyingCoinAddresses[0]].multicallContract;
+                            collateralContract = curve.contracts[this.underlyingCoinAddresses[1]].multicallContract;
+                            ammContract = curve.contracts[this.address].multicallContract;
+                            return [4 /*yield*/, curve.multicallProvider.all([
+                                    stablecoinContract.balanceOf(this.address),
+                                    ammContract.admin_fees_x(),
+                                    collateralContract.balanceOf(this.address),
+                                    ammContract.admin_fees_y(),
+                                ])];
+                        case 1:
+                            _c = _e.sent(), _balance_x = _c[0], _fee_x = _c[1], _balance_y = _c[2], _fee_y = _c[3];
+                            return [4 /*yield*/, _getUsdRate(this.underlyingCoinAddresses[1])];
+                        case 2:
+                            collateralRate = _e.sent();
+                            stablecoinTvlBN = toBN(_balance_x).minus(toBN(_fee_x));
+                            collateralTvlBN = toBN(_balance_y).minus(toBN(_fee_y)).times(collateralRate);
+                            return [2 /*return*/, stablecoinTvlBN.plus(collateralTvlBN).toString()];
+                        case 3:
+                            if (!useApi) return [3 /*break*/, 5];
                             network = curve.constants.NETWORK_NAME;
                             poolType = !this.isFactory && !this.isCrypto ? "main" :
                                 !this.isFactory ? "crypto" :
                                     !(this.isCrypto && this.isFactory) ? "factory" :
                                         "factory-crypto";
                             return [4 /*yield*/, _getPoolsFromApi(network, poolType)];
-                        case 1:
-                            poolsData = (_d.sent()).poolData;
+                        case 4:
+                            poolsData = (_e.sent()).poolData;
                             try {
                                 totalLiquidity_1 = poolsData.filter(function (data) { return data.address.toLowerCase() === _this.address.toLowerCase(); })[0].usdTotal;
                                 return [2 /*return*/, String(totalLiquidity_1)];
@@ -178,18 +197,18 @@ var PoolTemplate = /** @class */ (function () {
                             catch (err) {
                                 console.log(this.id, err.message);
                             }
-                            _d.label = 2;
-                        case 2: return [4 /*yield*/, this.statsUnderlyingBalances()];
-                        case 3:
-                            balances = _d.sent();
+                            _e.label = 5;
+                        case 5: return [4 /*yield*/, this.statsUnderlyingBalances()];
+                        case 6:
+                            balances = _e.sent();
                             promises = [];
-                            for (_i = 0, _c = this.underlyingCoinAddresses; _i < _c.length; _i++) {
-                                addr = _c[_i];
+                            for (_i = 0, _d = this.underlyingCoinAddresses; _i < _d.length; _i++) {
+                                addr = _d[_i];
                                 promises.push(_getUsdRate(addr));
                             }
                             return [4 /*yield*/, Promise.all(promises)];
-                        case 4:
-                            prices = _d.sent();
+                        case 7:
+                            prices = _e.sent();
                             totalLiquidity = balances.reduce(function (liquidity, b, i) { return liquidity + (Number(b) * prices[i]); }, 0);
                             return [2 /*return*/, totalLiquidity.toFixed(8)];
                     }
@@ -1060,7 +1079,7 @@ var PoolTemplate = /** @class */ (function () {
                 }
             });
         }); };
-        var poolData = __assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA)[id];
+        var poolData = __assign(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA), curve.constants.LLAMMAS_DATA)[id];
         this.id = id;
         this.name = poolData.name;
         this.fullName = poolData.full_name;
@@ -1079,6 +1098,7 @@ var PoolTemplate = /** @class */ (function () {
         this.isFake = poolData.is_fake || false;
         this.isFactory = poolData.is_factory || false;
         this.isMetaFactory = (this.isMeta && this.isFactory) || this.zap === '0xa79828df1850e8a3a3064576f380d90aecdd3359';
+        this.isLlamma = poolData.is_llamma || false;
         this.basePool = poolData.base_pool || '';
         this.metaCoinIdx = this.isMeta ? (_c = poolData.meta_coin_idx) !== null && _c !== void 0 ? _c : poolData.wrapped_coins.length - 1 : -1;
         this.underlyingCoins = poolData.underlying_coins;
@@ -1145,14 +1165,16 @@ var PoolTemplate = /** @class */ (function () {
     };
     PoolTemplate.prototype.statsWrappedBalances = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var swapContract, contractCalls, _wrappedBalances;
+            var contract, calls, i, _wrappedBalances;
             var _this = this;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        swapContract = curve.contracts[this.address].multicallContract;
-                        contractCalls = this.wrappedCoins.map(function (_, i) { return swapContract.balances(i); });
-                        return [4 /*yield*/, curve.multicallProvider.all(contractCalls)];
+                        contract = curve.contracts[this.address].multicallContract;
+                        calls = [];
+                        for (i = 0; i < this.wrappedCoins.length; i++)
+                            calls.push(contract.balances(i));
+                        return [4 /*yield*/, curve.multicallProvider.all(calls)];
                     case 1:
                         _wrappedBalances = _c.sent();
                         return [2 /*return*/, _wrappedBalances.map(function (_b, i) { return curve.formatUnits(_b, _this.wrappedDecimals[i]); })];

package/lib/router.js

@@ -115,6 +115,17 @@ var filterRoutes = function (routes, inputCoinAddress, sortFn) {
 };
 var sortByTvl = function (a, b) { return b.minTvl - a.minTvl || b.totalTvl - a.totalTvl || a.route.length - b.route.length; };
 var sortByLength = function (a, b) { return a.route.length - b.route.length || b.minTvl - a.minTvl || b.totalTvl - a.totalTvl; };
+var _getTVL = memoize(function (poolId) { return __awaiter(void 0, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
+    switch (_b.label) {
+        case 0:
+            _a = Number;
+            return [4 /*yield*/, (getPool(poolId)).stats.totalLiquidity()];
+        case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+    }
+}); }); }, {
+    promise: true,
+    maxAge: 5 * 60 * 1000, // 5m
+});
 // Inspired by Dijkstra's algorithm
 var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __awaiter(void 0, void 0, void 0, function () {
     var ALL_POOLS, amplificationCoefficientDict, curCoins, nextCoins, routesByTvl, routesByLength, step, _loop_1, _i, curCoins_1, inCoin, routes;
@@ -125,7 +136,7 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
             case 0:
                 inputCoinAddress = inputCoinAddress.toLowerCase();
                 outputCoinAddress = outputCoinAddress.toLowerCase();
-                ALL_POOLS = Object.entries(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA));
+                ALL_POOLS = Object.entries(__assign(__assign(__assign(__assign({}, curve.constants.POOLS_DATA), curve.constants.FACTORY_POOLS_DATA), curve.constants.CRYPTO_FACTORY_POOLS_DATA), curve.constants.LLAMMAS_DATA));
                 return [4 /*yield*/, _getAmplificationCoefficientsFromApi()];
             case 1:
                 amplificationCoefficientDict = _s.sent();
@@ -157,9 +168,9 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
                                     nextCoins.add(outCoin_1);
                                 }
                                 _loop_2 = function (poolId, poolData) {
-                                    var wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_aave_like_lending, tvlMultiplier, inCoinIndexes, tvl, _w, _x, poolAddress, coin_addresses, _loop_3, j, inCoinIndex, swapType_1, newRoutesByTvl, newRoutesByLength, _loop_4, j, _loop_5, j;
-                                    return __generator(this, function (_y) {
-                                        switch (_y.label) {
+                                    var wrapped_coin_addresses, underlying_coin_addresses, base_pool, meta_coin_addresses, token_address, is_aave_like_lending, tvlMultiplier, inCoinIndexes, tvl, _w, poolAddress, coin_addresses, _loop_3, j, inCoinIndex, swapType_1, newRoutesByTvl, newRoutesByLength, _loop_4, j, _loop_5, j;
+                                    return __generator(this, function (_x) {
+                                        switch (_x.label) {
                                             case 0:
                                                 wrapped_coin_addresses = poolData.wrapped_coin_addresses.map(function (a) { return a.toLowerCase(); });
                                                 underlying_coin_addresses = poolData.underlying_coin_addresses.map(function (a) { return a.toLowerCase(); });
@@ -179,12 +190,10 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
                                                 if (!poolId.startsWith('factory-crvusd-')) return [3 /*break*/, 1];
                                                 _w = 500000 * 100;
                                                 return [3 /*break*/, 3];
-                                            case 1:
-                                                _x = Number;
-                                                return [4 /*yield*/, (getPool(poolId)).stats.totalLiquidity()];
+                                            case 1: return [4 /*yield*/, _getTVL(poolId)];
                                             case 2:
-                                                _w = _x.apply(void 0, [_y.sent()]) * tvlMultiplier;
-                                                _y.label = 3;
+                                                _w = (_x.sent()) * tvlMultiplier;
+                                                _x.label = 3;
                                             case 3:
                                                 tvl = _w;
                                                 // Skip empty pools
@@ -216,7 +225,7 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
                                                     }
                                                 }
                                                 inCoinIndex = (is_aave_like_lending || poolData.is_fake) ? inCoinIndexes.underlying_coin : inCoinIndexes.wrapped_coin;
-                                                if (coin_addresses.length < 6 && inCoinIndex >= 0) {
+                                                if (coin_addresses.length < 6 && inCoinIndex >= 0 && !poolData.is_llamma) {
                                                     // Looking for outputCoinAddress only on the final step
                                                     if (!(step === 3 && token_address !== outputCoinAddress)) {
                                                         swapType_1 = is_aave_like_lending ? 9
@@ -263,58 +272,43 @@ var _findAllRoutes = function (inputCoinAddress, outputCoinAddress) { return __a
                                                 // Only for underlying swaps
                                                 poolAddress = (poolData.is_crypto && poolData.is_meta) || ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ?
                                                     poolData.deposit_address : poolData.swap_address;
-                                                if (!(!poolData.is_plain && inCoinIndexes.underlying_coin >= 0)) return [3 /*break*/, 7];
-                                                _loop_5 = function (j) {
-                                                    var outputCoinIdx, tvl_1, _z, hasEth, swapType, newRoutesByTvl, newRoutesByLength;
-                                                    return __generator(this, function (_0) {
-                                                        switch (_0.label) {
-                                                            case 0:
-                                                                if (j === inCoinIndexes.underlying_coin)
-                                                                    return [2 /*return*/, "continue"];
-                                                                // Don't swap metacoins since they can be swapped directly in base pool
-                                                                if (inCoinIndexes.meta_coin >= 0 && meta_coin_addresses.includes(underlying_coin_addresses[j]))
-                                                                    return [2 /*return*/, "continue"];
-                                                                // Looking for outputCoinAddress only on the final step
-                                                                if (step === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
-                                                                    return [2 /*return*/, "continue"];
-                                                                outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
-                                                                if (outputCoinIdx >= 0 && j !== outputCoinIdx)
-                                                                    return [2 /*return*/, "continue"];
-                                                                _z = Number;
-                                                                return [4 /*yield*/, (getPool(poolId)).stats.totalLiquidity()];
-                                                            case 1:
-                                                                tvl_1 = _z.apply(void 0, [_0.sent()]);
-                                                                if (tvl_1 === 0)
-                                                                    return [2 /*return*/, "continue"];
-                                                                hasEth = (inCoin === curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve.constants.NATIVE_TOKEN.address);
-                                                                swapType = (poolData.is_crypto && poolData.is_meta && poolData.is_factory) ? 6
-                                                                    : ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ? 5
-                                                                        : hasEth && poolId !== 'avaxcrypto' ? 3
-                                                                            : poolData.is_crypto ? 4
-                                                                                : 2;
-                                                                newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, underlying_coin_addresses[j], inCoinIndexes.underlying_coin, j, swapType, (swapType === 5 || swapType === 6) ? poolData.swap_address : curve.constants.ZERO_ADDRESS, tvl_1); });
-                                                                newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, underlying_coin_addresses[j], inCoinIndexes.underlying_coin, j, swapType, (swapType === 5 || swapType === 6) ? poolData.swap_address : curve.constants.ZERO_ADDRESS, tvl_1); });
-                                                                routesByTvl[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_o = routesByTvl[underlying_coin_addresses[j]]) !== null && _o !== void 0 ? _o : []), true), newRoutesByTvl, true);
-                                                                routesByTvl[underlying_coin_addresses[j]] = filterRoutes(routesByTvl[underlying_coin_addresses[j]], inputCoinAddress, sortByTvl);
-                                                                routesByLength[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_p = routesByLength[underlying_coin_addresses[j]]) !== null && _p !== void 0 ? _p : []), true), newRoutesByLength, true);
-                                                                routesByLength[underlying_coin_addresses[j]] = filterRoutes(routesByLength[underlying_coin_addresses[j]], inputCoinAddress, sortByLength);
-                                                                nextCoins.add(underlying_coin_addresses[j]);
-                                                                return [2 /*return*/];
-                                                        }
-                                                    });
-                                                };
-                                                j = 0;
-                                                _y.label = 4;
-                                            case 4:
-                                                if (!(j < underlying_coin_addresses.length)) return [3 /*break*/, 7];
-                                                return [5 /*yield**/, _loop_5(j)];
-                                            case 5:
-                                                _y.sent();
-                                                _y.label = 6;
-                                            case 6:
-                                                j++;
-                                                return [3 /*break*/, 4];
-                                            case 7: return [2 /*return*/];
+                                                // Underlying swaps
+                                                if (!poolData.is_plain && inCoinIndexes.underlying_coin >= 0) {
+                                                    _loop_5 = function (j) {
+                                                        if (j === inCoinIndexes.underlying_coin)
+                                                            return "continue";
+                                                        // Don't swap metacoins since they can be swapped directly in base pool
+                                                        if (inCoinIndexes.meta_coin >= 0 && meta_coin_addresses.includes(underlying_coin_addresses[j]))
+                                                            return "continue";
+                                                        // Looking for outputCoinAddress only on the final step
+                                                        if (step === 3 && underlying_coin_addresses[j] !== outputCoinAddress)
+                                                            return "continue";
+                                                        // Exclude such cases as cvxeth -> tricrypto2 -> tusd -> susd or cvxeth -> tricrypto2 -> susd -> susd
+                                                        var outputCoinIdx = underlying_coin_addresses.indexOf(outputCoinAddress);
+                                                        if (outputCoinIdx >= 0 && j !== outputCoinIdx)
+                                                            return "continue";
+                                                        // Skip empty pools
+                                                        if (tvl === 0)
+                                                            return "continue";
+                                                        var hasEth = (inCoin === curve.constants.NATIVE_TOKEN.address || underlying_coin_addresses[j] === curve.constants.NATIVE_TOKEN.address);
+                                                        var swapType = (poolData.is_crypto && poolData.is_meta && poolData.is_factory) ? 6
+                                                            : ((base_pool === null || base_pool === void 0 ? void 0 : base_pool.is_lending) && poolData.is_factory) ? 5
+                                                                : hasEth && poolId !== 'avaxcrypto' ? 3
+                                                                    : poolData.is_crypto ? 4
+                                                                        : 2;
+                                                        var newRoutesByTvl = routesByTvl[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, underlying_coin_addresses[j], inCoinIndexes.underlying_coin, j, swapType, (swapType === 5 || swapType === 6) ? poolData.swap_address : curve.constants.ZERO_ADDRESS, tvl); });
+                                                        var newRoutesByLength = routesByLength[inCoin].map(function (route) { return getNewRoute(route, poolId, poolAddress, inCoin, underlying_coin_addresses[j], inCoinIndexes.underlying_coin, j, swapType, (swapType === 5 || swapType === 6) ? poolData.swap_address : curve.constants.ZERO_ADDRESS, tvl); });
+                                                        routesByTvl[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_o = routesByTvl[underlying_coin_addresses[j]]) !== null && _o !== void 0 ? _o : []), true), newRoutesByTvl, true);
+                                                        routesByTvl[underlying_coin_addresses[j]] = filterRoutes(routesByTvl[underlying_coin_addresses[j]], inputCoinAddress, sortByTvl);
+                                                        routesByLength[underlying_coin_addresses[j]] = __spreadArray(__spreadArray([], ((_p = routesByLength[underlying_coin_addresses[j]]) !== null && _p !== void 0 ? _p : []), true), newRoutesByLength, true);
+                                                        routesByLength[underlying_coin_addresses[j]] = filterRoutes(routesByLength[underlying_coin_addresses[j]], inputCoinAddress, sortByLength);
+                                                        nextCoins.add(underlying_coin_addresses[j]);
+                                                    };
+                                                    for (j = 0; j < underlying_coin_addresses.length; j++) {
+                                                        _loop_5(j);
+                                                    }
+                                                }
+                                                return [2 /*return*/];
                                         }
                                     });
                                 };

package/package.json

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