@curvefi/api 2.63.2 → 2.63.4

package/lib/constants/aliases.js

@@ -129,7 +129,8 @@ export const ALIASES_OPTIMISM = lowerCaseValues({
 });
 export const ALIASES_XDAI = lowerCaseValues({
     "crv": "0x712b3d230f3c1c19db860d80619288b1f0bdd0bd",
-    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0x7BE6BD57A319A7180f71552E58c9d32Da32b6f96",
+    "gauge_factory_old": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0xefde221f306152971d8e9f181bfe998447975810",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -143,7 +144,7 @@ export const ALIASES_XDAI = lowerCaseValues({
     "eywa_factory": '0x37F22A0B028f2152e6CAcef210e0C4d3b875f367',
     "crypto_factory": '0xF18056Bbd320E96A48e3Fbf8bC061322531aac99',
     "twocrypto_factory": '0x98EE851a00abeE0d95D08cF4CA2BdCE32aeaAF7F',
-    "tricrypto_factory": '0x0c0e5f2fF0ff18a3be9b835635039256dC4B4963',
+    "tricrypto_factory": '0xb47988aD49DCE8D909c6f9Cf7B26caF04e1445c8',
     "stable_ng_factory": '0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8',
     "factory_admin": "",
 });

package/lib/curve.js

@@ -787,6 +787,9 @@ class Curve {
             this.constants.DECIMALS[this.constants.ALIASES.crv] = 18;
             const _gaugeFactoryABI = this.chainId === 1 ? gaugeFactoryABI : gaugeFactorySidechainABI;
             this.setContract(this.constants.ALIASES.gauge_factory, _gaugeFactoryABI);
+            if ("gauge_factory_old" in this.constants.ALIASES) {
+                this.setContract(this.constants.ALIASES.gauge_factory_old, _gaugeFactoryABI);
+            }
             if (this.chainId === 1) {
                 this.setContract(this.constants.ALIASES.minter, minterMainnetABI);
                 this.setContract(this.constants.ALIASES.gauge_factory_fraxtal, gaugeFactoryForFraxtalABI);

package/lib/dao.js

@@ -193,7 +193,7 @@ const _extractNetworkFromPoolUrl = (poolUrl) => {
     return poolUrl.split("/")[4];
 };
 export const getVotingGaugeList = () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+    var _a, _b;
     if (curve.chainId !== 1)
         throw Error("Ethereum-only method");
     const gaugeData = Object.values(yield _getAllGauges());
@@ -202,21 +202,21 @@ export const getVotingGaugeList = () => __awaiter(void 0, void 0, void 0, functi
         if ((gaugeData[i].is_killed || gaugeData[i].hasNoCrv) && Number(gaugeData[i].gauge_controller.gauge_relative_weight) === 0)
             continue;
         res.push({
-            poolUrl: gaugeData[i].poolUrls.swap[0],
-            network: _extractNetworkFromPoolUrl(gaugeData[i].poolUrls.swap[0]),
+            poolUrl: ((_a = gaugeData[i].poolUrls) === null || _a === void 0 ? void 0 : _a.swap[0]) || '',
+            network: gaugeData[i].blockchainId,
             gaugeAddress: gaugeData[i].gauge,
-            poolAddress: gaugeData[i].swap,
-            lpTokenAddress: gaugeData[i].swap_token,
+            poolAddress: gaugeData[i].swap || '',
+            lpTokenAddress: gaugeData[i].swap_token || '',
             poolName: gaugeData[i].shortName,
             totalVeCrv: curve.formatUnits(gaugeData[i].gauge_controller.get_gauge_weight, 18),
             relativeWeight: curve.formatUnits(gaugeData[i].gauge_controller.gauge_relative_weight, 16),
-            isKilled: (_a = gaugeData[i].is_killed) !== null && _a !== void 0 ? _a : false,
+            isKilled: (_b = gaugeData[i].is_killed) !== null && _b !== void 0 ? _b : false,
         });
     }
     return res;
 });
 export const userGaugeVotes = (address = "") => __awaiter(void 0, void 0, void 0, function* () {
-    var _b;
+    var _c, _d;
     if (curve.chainId !== 1)
         throw Error("Ethereum-only method");
     address = _getAddress(address);
@@ -243,15 +243,15 @@ export const userGaugeVotes = (address = "") => __awaiter(void 0, void 0, void 0
             userFutureVeCrv: curve.formatUnits(veCrvBalance * votes[i][1] / BigInt(10000), 18),
             expired: dt === BigInt(0),
             gaugeData: {
-                poolUrl: gaugeData[i].poolUrls.swap[0],
-                network: _extractNetworkFromPoolUrl(gaugeData[i].poolUrls.swap[0]),
+                poolUrl: ((_c = gaugeData[i].poolUrls) === null || _c === void 0 ? void 0 : _c.swap[0]) || '',
+                network: gaugeData[i].blockchainId,
                 gaugeAddress: gaugeData[i].gauge,
-                poolAddress: gaugeData[i].swap,
-                lpTokenAddress: gaugeData[i].swap_token,
+                poolAddress: gaugeData[i].swap || '',
+                lpTokenAddress: gaugeData[i].swap_token || '',
                 poolName: gaugeData[i].shortName,
                 totalVeCrv: curve.formatUnits(gaugeData[i].gauge_controller.get_gauge_weight, 18),
                 relativeWeight: curve.formatUnits(gaugeData[i].gauge_controller.gauge_relative_weight, 16),
-                isKilled: (_b = gaugeData[i].is_killed) !== null && _b !== void 0 ? _b : false,
+                isKilled: (_d = gaugeData[i].is_killed) !== null && _d !== void 0 ? _d : false,
             },
         });
         powerUsed += votes[i][1];

package/lib/factory/factory-crypto.js

@@ -68,9 +68,11 @@ function _getLpTokenMap(factorySwapAddresses) {
     });
 }
 function getPoolsData(factorySwapAddresses) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         const factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
-        const isfactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
+        const isGaugeFactoryNull = this.constants.ALIASES.gauge_factory === curve.constants.ZERO_ADDRESS;
+        const isGaugeFactoryOldNull = !("gauge_factory_old" in this.constants.ALIASES);
         const calls = [];
         if (this.chainId === 1) {
             for (const addr of factorySwapAddresses) {
@@ -80,29 +82,32 @@ function getPoolsData(factorySwapAddresses) {
             }
         }
         else {
-            const factoryMulticallGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+            const gaugeFactoryMulticallContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+            const gaugeFactoryOldMulticallContract = this.contracts[(_a = this.constants.ALIASES.gauge_factory_old) !== null && _a !== void 0 ? _a : curve.constants.ZERO_ADDRESS].multicallContract;
             const LpTokenMap = yield _getLpTokenMap.call(this, factorySwapAddresses);
             for (const addr of factorySwapAddresses) {
                 calls.push(factoryMulticallContract.get_token(addr));
-                if (!isfactoryGaugeNull) {
-                    calls.push(factoryMulticallGaugeContract.get_gauge_from_lp_token(LpTokenMap[addr]));
-                }
+                if (!isGaugeFactoryNull)
+                    calls.push(gaugeFactoryMulticallContract.get_gauge_from_lp_token(LpTokenMap[addr]));
+                if (!isGaugeFactoryOldNull)
+                    calls.push(gaugeFactoryOldMulticallContract.get_gauge_from_lp_token(LpTokenMap[addr]));
                 calls.push(factoryMulticallContract.get_coins(addr));
             }
         }
         const res = yield this.multicallProvider.all(calls);
-        if (isfactoryGaugeNull) {
-            const tokenAddresses = res.filter((a, i) => i % 3 == 0).map((a) => a.toLowerCase());
-            const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 3 == 1));
-            const gaugeAddresses = Array.from(Array(factorySwapAddresses.length)).map(() => '0x0000000000000000000000000000000000000000');
-            return [tokenAddresses, gaugeAddresses, coinAddresses];
-        }
-        else {
-            const tokenAddresses = res.filter((a, i) => i % 3 == 0).map((a) => a.toLowerCase());
-            const gaugeAddresses = res.filter((a, i) => i % 3 == 1).map((a) => a.toLowerCase());
-            const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 3 == 2));
-            return [tokenAddresses, gaugeAddresses, coinAddresses];
+        if (isGaugeFactoryNull || isGaugeFactoryOldNull) {
+            for (let index = 0; index < res.length; index++) {
+                if (isGaugeFactoryNull && index % 4 == 1)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
+                if (isGaugeFactoryOldNull && index % 4 == 2)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
+            }
         }
+        const tokenAddresses = res.filter((a, i) => i % 4 == 0).map((a) => a.toLowerCase());
+        const gaugeAddresses = res.filter((a, i) => i % 4 == 1).map((a) => a.toLowerCase());
+        const gaugeOldAddresses = res.filter((a, i) => i % 4 == 2).map((a) => a.toLowerCase());
+        const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 4 == 3));
+        return [tokenAddresses, gaugeAddresses, gaugeOldAddresses, coinAddresses];
     });
 }
 function setCryptoFactorySwapContracts(factorySwapAddresses) {
@@ -199,7 +204,11 @@ export function getCryptoFactoryPoolData(fromIdx = 0, swapAddress) {
             : yield getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
         if (poolIds.length === 0)
             return {};
-        const [tokenAddresses, gaugeAddresses, coinAddresses] = yield getPoolsData.call(this, swapAddresses);
+        const [tokenAddresses, rawGaugeAddresses, rawOldGaugeAddresses, coinAddresses] = yield getPoolsData.call(this, swapAddresses);
+        const gaugeAddresses = [];
+        for (let i = 0; i < rawGaugeAddresses.length; i++) {
+            gaugeAddresses.push(rawGaugeAddresses[i] !== curve.constants.ZERO_ADDRESS ? rawGaugeAddresses[i] : rawOldGaugeAddresses[i]);
+        }
         setCryptoFactorySwapContracts.call(this, swapAddresses);
         setCryptoFactoryTokenContracts.call(this, tokenAddresses);
         setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);

package/lib/factory/factory-tricrypto.js

@@ -47,47 +47,45 @@ function _handleCoinAddresses(coinAddresses) {
     return coinAddresses.map((addresses) => addresses.map((addr) => this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase()));
 }
 function getPoolsData(factorySwapAddresses) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        const factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
+        const isGaugeFactoryNull = this.constants.ALIASES.gauge_factory === curve.constants.ZERO_ADDRESS;
+        const isGaugeFactoryOldNull = !("gauge_factory_old" in this.constants.ALIASES);
+        const calls = [];
         if (this.chainId === 1) {
-            const factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
-            const calls = [];
             for (const addr of factorySwapAddresses) {
                 calls.push(factoryMulticallContract.get_gauge(addr));
                 calls.push(factoryMulticallContract.get_coins(addr));
                 calls.push(factoryMulticallContract.get_implementation_address(addr));
             }
-            const res = yield this.multicallProvider.all(calls);
-            const gaugeAddresses = res.filter((a, i) => i % 3 == 0).map((a) => a.toLowerCase());
-            const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 3 == 1));
-            const implementationAddresses = res.filter((a, i) => i % 3 == 2).map((a) => a.toLowerCase());
-            return [gaugeAddresses, coinAddresses, implementationAddresses];
         }
         else {
-            const factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
-            const isFactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
-            const factoryMulticallGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
-            const calls = [];
+            const gaugeFactoryMulticallContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+            const gaugeFactoryOldMulticallContract = this.contracts[(_a = this.constants.ALIASES.gauge_factory_old) !== null && _a !== void 0 ? _a : curve.constants.ZERO_ADDRESS].multicallContract;
             for (const addr of factorySwapAddresses) {
-                if (!isFactoryGaugeNull) {
-                    calls.push(factoryMulticallGaugeContract.get_gauge_from_lp_token(addr));
-                }
+                if (!isGaugeFactoryNull)
+                    calls.push(gaugeFactoryMulticallContract.get_gauge_from_lp_token(addr));
+                if (!isGaugeFactoryOldNull)
+                    calls.push(gaugeFactoryOldMulticallContract.get_gauge_from_lp_token(addr));
                 calls.push(factoryMulticallContract.get_coins(addr));
                 calls.push(factoryMulticallContract.get_implementation_address(addr));
             }
-            const res = yield this.multicallProvider.all(calls);
-            if (!isFactoryGaugeNull) {
-                const gaugeAddresses = res.filter((a, i) => i % 3 == 0).map((a) => a.toLowerCase());
-                const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 3 == 1));
-                const implementationAddresses = res.filter((a, i) => i % 3 == 2).map((a) => a.toLowerCase());
-                return [gaugeAddresses, coinAddresses, implementationAddresses];
-            }
-            else {
-                const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 2 == 0));
-                const gaugeAddresses = Array.from(Array(factorySwapAddresses.length)).map(() => '0x0000000000000000000000000000000000000000');
-                const implementationAddresses = res.filter((a, i) => i % 2 == 1).map((a) => a.toLowerCase());
-                return [gaugeAddresses, coinAddresses, implementationAddresses];
+        }
+        const res = yield this.multicallProvider.all(calls);
+        if (isGaugeFactoryNull || isGaugeFactoryOldNull) {
+            for (let index = 0; index < res.length; index++) {
+                if (isGaugeFactoryNull && index % 4 == 0)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
+                if (isGaugeFactoryOldNull && index % 4 == 1)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
             }
         }
+        const gaugeAddresses = res.filter((a, i) => i % 4 == 0).map((a) => a.toLowerCase());
+        const gaugeOldAddresses = res.filter((a, i) => i % 4 == 1).map((a) => a.toLowerCase());
+        const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 4 == 2));
+        const implementationAddresses = res.filter((a, i) => i % 4 == 3).map((a) => a.toLowerCase());
+        return [gaugeAddresses, gaugeOldAddresses, coinAddresses, implementationAddresses];
     });
 }
 function setCryptoFactorySwapContracts(factorySwapAddresses) {
@@ -95,11 +93,6 @@ function setCryptoFactorySwapContracts(factorySwapAddresses) {
         this.setContract(addr, tricryptoFactorySwapABI);
     });
 }
-function setCryptoFactoryTokenContracts(factoryTokenAddresses) {
-    factoryTokenAddresses.forEach((addr) => {
-        this.setContract(addr, ERC20ABI);
-    });
-}
 function setCryptoFactoryGaugeContracts(factoryGaugeAddresses) {
     factoryGaugeAddresses.filter((addr) => addr !== curve.constants.ZERO_ADDRESS).forEach((addr, i) => {
         this.setContract(addr, this.chainId === 1 ? factoryGaugeABI : gaugeChildABI);
@@ -180,7 +173,11 @@ export function getTricryptoFactoryPoolData(fromIdx = 0, swapAddress) {
             : yield getCryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
         if (poolIds.length === 0)
             return {};
-        const [gaugeAddresses, coinAddresses, implementationAddresses] = yield getPoolsData.call(this, swapAddresses);
+        const [rawGaugeAddresses, rawOldGaugeAddresses, coinAddresses, implementationAddresses] = yield getPoolsData.call(this, swapAddresses);
+        const gaugeAddresses = [];
+        for (let i = 0; i < rawGaugeAddresses.length; i++) {
+            gaugeAddresses.push(rawGaugeAddresses[i] !== curve.constants.ZERO_ADDRESS ? rawGaugeAddresses[i] : rawOldGaugeAddresses[i]);
+        }
         setCryptoFactorySwapContracts.call(this, swapAddresses);
         setCryptoFactoryGaugeContracts.call(this, gaugeAddresses);
         setCryptoFactoryCoinsContracts.call(this, coinAddresses);

package/lib/factory/factory-twocrypto.js

@@ -46,42 +46,42 @@ function _handleCoinAddresses(coinAddresses) {
     return coinAddresses.map((addresses) => addresses.map((addr) => this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase()));
 }
 function getPoolsData(factorySwapAddresses) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        const factoryMulticallContract = this.contracts[this.constants.ALIASES.twocrypto_factory].multicallContract;
+        const isGaugeFactoryNull = this.constants.ALIASES.gauge_factory === curve.constants.ZERO_ADDRESS;
+        const isGaugeFactoryOldNull = !("gauge_factory_old" in this.constants.ALIASES);
+        const calls = [];
         if (this.chainId === 1) {
-            const factoryMulticallContract = this.contracts[this.constants.ALIASES.twocrypto_factory].multicallContract;
-            const calls = [];
             for (const addr of factorySwapAddresses) {
                 calls.push(factoryMulticallContract.get_gauge(addr));
                 calls.push(factoryMulticallContract.get_coins(addr));
             }
-            const res = yield this.multicallProvider.all(calls);
-            const gaugeAddresses = res.filter((a, i) => i % 2 == 0).map((a) => a.toLowerCase());
-            const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 2 == 1));
-            return [gaugeAddresses, coinAddresses];
         }
         else {
-            const factoryMulticallContract = this.contracts[this.constants.ALIASES.twocrypto_factory].multicallContract;
-            const isFactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
-            const factoryMulticallGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
-            const calls = [];
+            const gaugeFactoryMulticallContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+            const gaugeFactoryOldMulticallContract = this.contracts[(_a = this.constants.ALIASES.gauge_factory_old) !== null && _a !== void 0 ? _a : curve.constants.ZERO_ADDRESS].multicallContract;
             for (const addr of factorySwapAddresses) {
-                if (!isFactoryGaugeNull) {
-                    calls.push(factoryMulticallGaugeContract.get_gauge_from_lp_token(addr));
-                }
+                if (!isGaugeFactoryNull)
+                    calls.push(gaugeFactoryMulticallContract.get_gauge_from_lp_token(addr));
+                if (!isGaugeFactoryOldNull)
+                    calls.push(gaugeFactoryOldMulticallContract.get_gauge_from_lp_token(addr));
                 calls.push(factoryMulticallContract.get_coins(addr));
             }
-            const res = yield this.multicallProvider.all(calls);
-            if (!isFactoryGaugeNull) {
-                const gaugeAddresses = res.filter((a, i) => i % 2 == 0).map((a) => a.toLowerCase());
-                const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 2 == 1));
-                return [gaugeAddresses, coinAddresses];
-            }
-            else {
-                const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 2 == 0));
-                const gaugeAddresses = Array.from(Array(factorySwapAddresses.length)).map(() => '0x0000000000000000000000000000000000000000');
-                return [gaugeAddresses, coinAddresses];
+        }
+        const res = yield this.multicallProvider.all(calls);
+        if (isGaugeFactoryNull || isGaugeFactoryOldNull) {
+            for (let index = 0; index < res.length; index++) {
+                if (isGaugeFactoryNull && index % 3 == 0)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
+                if (isGaugeFactoryOldNull && index % 3 == 1)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
             }
         }
+        const gaugeAddresses = res.filter((a, i) => i % 3 == 0).map((a) => a.toLowerCase());
+        const gaugeOldAddresses = res.filter((a, i) => i % 3 == 1).map((a) => a.toLowerCase());
+        const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 3 == 2));
+        return [gaugeAddresses, gaugeOldAddresses, coinAddresses];
     });
 }
 function setTwocryptoFactorySwapContracts(factorySwapAddresses) {
@@ -89,11 +89,6 @@ function setTwocryptoFactorySwapContracts(factorySwapAddresses) {
         this.setContract(addr, twocryptoFactorySwapABI);
     });
 }
-function setTwocryptoFactoryTokenContracts(factoryTokenAddresses) {
-    factoryTokenAddresses.forEach((addr) => {
-        this.setContract(addr, ERC20ABI);
-    });
-}
 function setTwocryptoFactoryGaugeContracts(factoryGaugeAddresses) {
     factoryGaugeAddresses.filter((addr) => addr !== curve.constants.ZERO_ADDRESS).forEach((addr, i) => {
         this.setContract(addr, this.chainId === 1 ? factoryGaugeABI : gaugeChildABI);
@@ -177,7 +172,11 @@ export function getTwocryptoFactoryPoolData(fromIdx = 0, swapAddress) {
             : yield getTwocryptoFactoryIdsAndSwapAddresses.call(this, fromIdx);
         if (poolIds.length === 0)
             return {};
-        const [gaugeAddresses, coinAddresses] = yield getPoolsData.call(this, swapAddresses);
+        const [rawGaugeAddresses, rawOldGaugeAddresses, coinAddresses] = yield getPoolsData.call(this, swapAddresses);
+        const gaugeAddresses = [];
+        for (let i = 0; i < rawGaugeAddresses.length; i++) {
+            gaugeAddresses.push(rawGaugeAddresses[i] !== curve.constants.ZERO_ADDRESS ? rawGaugeAddresses[i] : rawOldGaugeAddresses[i]);
+        }
         setTwocryptoFactorySwapContracts.call(this, swapAddresses);
         setTwocryptoFactoryGaugeContracts.call(this, gaugeAddresses);
         setTwocryptoFactoryCoinsContracts.call(this, coinAddresses);

package/lib/factory/factory.js

@@ -106,11 +106,14 @@ function _handleCoinAddresses(coinAddresses) {
         .map((addr) => this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? this.constants.NATIVE_TOKEN.address : addr.toLowerCase()));
 }
 function getPoolsData(factorySwapAddresses, factoryAddress) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         const factoryMulticallContract = this.contracts[factoryAddress].multicallContract;
-        const isFactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
+        const isGaugeFactoryNull = this.constants.ALIASES.gauge_factory === curve.constants.ZERO_ADDRESS;
+        const isGaugeFactoryOldNull = !("gauge_factory_old" in this.constants.ALIASES);
         const isStableNgFactory = factoryAddress === this.constants.ALIASES['stable_ng_factory'];
-        const factoryGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+        const gaugeFactoryContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+        const gaugeFactoryOldContract = this.contracts[(_a = this.constants.ALIASES.gauge_factory_old) !== null && _a !== void 0 ? _a : curve.constants.ZERO_ADDRESS].multicallContract;
         const calls = [];
         for (const addr of factorySwapAddresses) {
             const tempSwapContract = new MulticallContract(addr, ERC20ABI);
@@ -118,8 +121,11 @@ function getPoolsData(factorySwapAddresses, factoryAddress) {
             if (this.chainId === 1) {
                 calls.push(factoryMulticallContract.get_gauge(addr));
             }
-            else if (!isFactoryGaugeNull) {
-                calls.push(factoryGaugeContract.get_gauge_from_lp_token(addr));
+            else if (!isGaugeFactoryNull) {
+                calls.push(gaugeFactoryContract.get_gauge_from_lp_token(addr));
+            }
+            if (!isGaugeFactoryOldNull) {
+                calls.push(gaugeFactoryOldContract.get_gauge_from_lp_token(addr));
             }
             if (!isStableNgFactory) {
                 calls.push(factoryMulticallContract.get_pool_asset_type(addr));
@@ -130,28 +136,25 @@ function getPoolsData(factorySwapAddresses, factoryAddress) {
             calls.push(factoryMulticallContract.get_coins(addr));
         }
         const res = yield this.multicallProvider.all(calls);
-        if (isFactoryGaugeNull) {
+        if (isGaugeFactoryNull || isGaugeFactoryOldNull || isStableNgFactory) {
             for (let index = 0; index < res.length; index++) {
-                if (index % 7 == 1) {
-                    res.splice(index, 0, '0x0000000000000000000000000000000000000000');
-                }
-            }
-        }
-        if (isStableNgFactory) {
-            for (let index = 0; index < res.length; index++) {
-                if (index % 7 == 2) {
+                if (isGaugeFactoryNull && index % 8 == 1)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
+                if (isGaugeFactoryOldNull && index % 8 == 2)
+                    res.splice(index, 0, curve.constants.ZERO_ADDRESS);
+                if (isStableNgFactory && index % 8 == 3)
                     res.splice(index, 0, -1);
-                }
             }
         }
-        const implememntationAddresses = res.filter((a, i) => i % 7 == 0).map((a) => a.toLowerCase());
-        const gaugeAddresses = res.filter((a, i) => i % 7 == 1).map((a) => a.toLowerCase());
-        const referenceAssets = _handleReferenceAssets(res.filter((a, i) => i % 7 == 2));
-        const symbols = res.filter((a, i) => i % 7 == 3);
-        const names = res.filter((a, i) => i % 7 == 4);
-        const isMeta = res.filter((a, i) => i % 7 == 5);
-        const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 7 == 6));
-        return [implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses];
+        const implememntationAddresses = res.filter((a, i) => i % 8 == 0).map((a) => a.toLowerCase());
+        const gaugeAddresses = res.filter((a, i) => i % 8 == 1).map((a) => a.toLowerCase());
+        const oldGaugeAddresses = res.filter((a, i) => i % 8 == 2).map((a) => a.toLowerCase());
+        const referenceAssets = _handleReferenceAssets(res.filter((a, i) => i % 8 == 3));
+        const symbols = res.filter((a, i) => i % 8 == 4);
+        const names = res.filter((a, i) => i % 8 == 5);
+        const isMeta = res.filter((a, i) => i % 8 == 6);
+        const coinAddresses = _handleCoinAddresses.call(this, res.filter((a, i) => i % 8 == 7));
+        return [implememntationAddresses, gaugeAddresses, oldGaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses];
     });
 }
 function setFactorySwapContracts(factorySwapAddresses, factorySwapABIs) {
@@ -226,7 +229,7 @@ export function getFactoryPoolData(fromIdx = 0, swapAddress, factoryAddress = cu
             : yield getFactoryIdsAndSwapAddresses.call(this, fromIdx, factoryAddress);
         if (rawPoolIds.length === 0)
             return {};
-        const [rawImplementations, rawGauges, rawReferenceAssets, rawPoolSymbols, rawPoolNames, rawIsMeta, rawCoinAddresses] = yield getPoolsData.call(this, rawSwapAddresses, factoryAddress);
+        const [rawImplementations, rawGauges, rawOldGauges, rawReferenceAssets, rawPoolSymbols, rawPoolNames, rawIsMeta, rawCoinAddresses] = yield getPoolsData.call(this, rawSwapAddresses, factoryAddress);
         const poolIds = [];
         const swapAddresses = [];
         const implementations = [];
@@ -242,7 +245,7 @@ export function getFactoryPoolData(fromIdx = 0, swapAddress, factoryAddress = cu
                 poolIds.push(rawPoolIds[i]);
                 swapAddresses.push(rawSwapAddresses[i]);
                 implementations.push(rawImplementations[i]);
-                gaugeAddresses.push(rawGauges[i]);
+                gaugeAddresses.push(rawGauges[i] !== curve.constants.ZERO_ADDRESS ? rawGauges[i] : rawOldGauges[i]);
                 referenceAssets.push(rawReferenceAssets[i]);
                 poolSymbols.push(rawPoolSymbols[i]);
                 poolNames.push(rawPoolNames[i]);

package/lib/interfaces.d.ts

@@ -178,6 +178,7 @@ export interface IProfit {
     price: number;
 }
 export interface IGaugesDataFromApi {
+    blockchainId: string;
     gauge: string;
     swap: string;
     swap_token: string;
@@ -186,7 +187,7 @@ export interface IGaugesDataFromApi {
         gauge_relative_weight: string;
         get_gauge_weight: string;
     };
-    poolUrls: {
+    poolUrls?: {
         swap: string[];
     };
     is_killed?: boolean;

package/package.json

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