@curvefi/api 2.46.0 → 2.46.2

package/lib/constants/abis/{minter_child.json → gauge_factory_sidechain.json}

@@ -181,27 +181,6 @@
         ],
         "outputs": []
     },
-    {
-        "stateMutability": "nonpayable",
-        "type": "function",
-        "name": "deploy_gauge",
-        "inputs": [
-            {
-                "name": "_lp_token",
-                "type": "address"
-            },
-            {
-                "name": "_salt",
-                "type": "bytes32"
-            }
-        ],
-        "outputs": [
-            {
-                "name": "",
-                "type": "address"
-            }
-        ]
-    },
     {
         "stateMutability": "nonpayable",
         "type": "function",

package/lib/constants/aliases.js

@@ -1,7 +1,7 @@
 import { lowerCaseValues } from "./utils.js";
 export var ALIASES_ETHEREUM = lowerCaseValues({
     "crv": "0xD533a949740bb3306d119CC777fa900bA034cd52",
-    "minter": "0xd061D61a4d941c39E5453435B6345Dc261C2fcE0",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x5f3b5DfEb7B28CDbD7FAba78963EE202a494e2A2",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -20,7 +20,7 @@ export var ALIASES_ETHEREUM = lowerCaseValues({
 });
 export var ALIASES_POLYGON = lowerCaseValues({
     "crv": "0x172370d5cd63279efa6d502dab29171933a610af",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0xb5acc710aede048600e10eedcefdf98d4abf4b1e",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -39,7 +39,7 @@ export var ALIASES_POLYGON = lowerCaseValues({
 });
 export var ALIASES_FANTOM = lowerCaseValues({
     "crv": "0x1E4F97b9f9F913c46F1632781732927B9019C68b",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0xb75dca485e21a77e1b433ecacb74475fc67e259c",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -58,7 +58,7 @@ export var ALIASES_FANTOM = lowerCaseValues({
 });
 export var ALIASES_AVALANCHE = lowerCaseValues({
     "crv": "0x47536F17F4fF30e64A96a7555826b8f9e66ec468",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0xc55837710bc500f1e3c7bb9dd1d51f7c5647e657",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -77,7 +77,7 @@ export var ALIASES_AVALANCHE = lowerCaseValues({
 });
 export var ALIASES_ARBITRUM = lowerCaseValues({
     "crv": "0x11cDb42B0EB46D95f990BeDD4695A6e3fA034978",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x98c80fa823759b642c3e02f40533c164f40727ae",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -96,7 +96,7 @@ export var ALIASES_ARBITRUM = lowerCaseValues({
 });
 export var ALIASES_OPTIMISM = lowerCaseValues({
     "crv": "0x0994206dfE8De6Ec6920FF4D779B0d950605Fb53",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x65a0b01756e837e6670634816e4f5b3a3ff21107",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -115,7 +115,7 @@ export var ALIASES_OPTIMISM = lowerCaseValues({
 });
 export var ALIASES_XDAI = lowerCaseValues({
     "crv": "0x712b3d230f3c1c19db860d80619288b1f0bdd0bd",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0xefde221f306152971d8e9f181bfe998447975810",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -134,7 +134,7 @@ export var ALIASES_XDAI = lowerCaseValues({
 });
 export var ALIASES_MOONBEAM = lowerCaseValues({
     "crv": "0x7C598c96D02398d89FbCb9d41Eab3DF0C16F227D",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -153,7 +153,7 @@ export var ALIASES_MOONBEAM = lowerCaseValues({
 });
 export var ALIASES_AURORA = lowerCaseValues({
     "crv": "0x64D5BaF5ac030e2b7c435aDD967f787ae94D0205",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0x0000000000000000000000000000000000000000",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -172,7 +172,7 @@ export var ALIASES_AURORA = lowerCaseValues({
 });
 export var ALIASES_KAVA = lowerCaseValues({
     "crv": "0x64D5BaF5ac030e2b7c435aDD967f787ae94D0205",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -191,7 +191,7 @@ export var ALIASES_KAVA = lowerCaseValues({
 });
 export var ALIASES_CELO = lowerCaseValues({
     "crv": "0x0a7432cF27F1aE3825c313F3C81e7D3efD7639aB",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -210,7 +210,7 @@ export var ALIASES_CELO = lowerCaseValues({
 });
 export var ALIASES_ZKSYNC = lowerCaseValues({
     "crv": "0x0a7432cF27F1aE3825c313F3C81e7D3efD7639aB",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0x0000000000000000000000000000000000000000",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",
@@ -229,7 +229,7 @@ export var ALIASES_ZKSYNC = lowerCaseValues({
 });
 export var ALIASES_BASE = lowerCaseValues({
     "crv": "0x8Ee73c484A26e0A5df2Ee2a4960B789967dd0415",
-    "minter": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
+    "gauge_factory": "0xabC000d88f23Bb45525E447528DBF656A9D55bf5",
     "voting_escrow": "0x0000000000000000000000000000000000000000",
     "fee_distributor": "0xA464e6DCda8AC41e03616F95f4BC98a13b8922Dc",
     "gauge_controller": "0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB",

package/lib/curve.js

@@ -63,8 +63,8 @@ import { getTricryptoFactoryPoolData } from "./factory/factory-tricrypto.js";
 import ERC20Abi from './constants/abis/ERC20.json' assert { type: 'json' };
 import cERC20Abi from './constants/abis/cERC20.json' assert { type: 'json' };
 import yERC20Abi from './constants/abis/yERC20.json' assert { type: 'json' };
-import minterABI from './constants/abis/minter.json' assert { type: 'json' };
-import minterChildABI from './constants/abis/minter_child.json' assert { type: 'json' };
+import gaugeFactoryABI from './constants/abis/gauge_factory.json' assert { type: 'json' };
+import gaugeFactorySidechainABI from './constants/abis/gauge_factory_sidechain.json' assert { type: 'json' };
 import votingEscrowABI from './constants/abis/votingescrow.json' assert { type: 'json' };
 import anycallABI from './constants/abis/anycall.json' assert { type: 'json' };
 import votingEscrowOracleABI from './constants/abis/voting_escrow_oracle.json' assert { type: 'json' };
@@ -539,7 +539,7 @@ var Curve = /** @class */ (function () {
                         case 8:
                             _h = this.constants.FACTORY_GAUGE_IMPLEMENTATIONS;
                             _j = "factory-tricrypto";
-                            return [4 /*yield*/, this.contracts[this.constants.ALIASES.minter].contract.get_implementation(this.constantOptions)];
+                            return [4 /*yield*/, this.contracts[this.constants.ALIASES.gauge_factory].contract.get_implementation(this.constantOptions)];
                         case 9:
                             _h[_j] =
                                 _k.sent();
@@ -701,7 +701,7 @@ var Curve = /** @class */ (function () {
         var _a;
         if (options === void 0) { options = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var jsonRpcApiProviderOptions, _b, e_1, _c, network, poolId, _d, cTokens, yTokens, ycTokens, aTokens, customAbiTokens, _e, err_1, _i, _f, pool, _g, _h, coinAddr, _j, _k, coinAddr, _l, _m, coinAddr, _minterABI, addressProviderContract, _o, factoryContract, _p;
+            var jsonRpcApiProviderOptions, _b, e_1, _c, network, poolId, _d, cTokens, yTokens, ycTokens, aTokens, customAbiTokens, _e, err_1, _i, _f, pool, _g, _h, coinAddr, _j, _k, coinAddr, _l, _m, coinAddr, _gaugeFactoryABI, addressProviderContract, _o, factoryContract, _p;
             return __generator(this, function (_q) {
                 switch (_q.label) {
                     case 0:
@@ -891,8 +891,8 @@ var Curve = /** @class */ (function () {
                         this.setContract(this.constants.NATIVE_TOKEN.wrappedAddress, ERC20Abi);
                         this.setContract(this.constants.ALIASES.crv, ERC20Abi);
                         this.constants.DECIMALS[this.constants.ALIASES.crv] = 18;
-                        _minterABI = this.chainId === 1 ? minterABI : minterChildABI;
-                        this.setContract(this.constants.ALIASES.minter, _minterABI);
+                        _gaugeFactoryABI = this.chainId === 1 ? gaugeFactoryABI : gaugeFactorySidechainABI;
+                        this.setContract(this.constants.ALIASES.gauge_factory, _gaugeFactoryABI);
                         this.setContract(this.constants.ALIASES.voting_escrow, votingEscrowABI);
                         this.setContract(this.constants.ALIASES.fee_distributor, feeDistributorABI);
                         this.setContract(this.constants.ALIASES.address_provider, addressProviderABI);

package/lib/factory/deploy.d.ts

@@ -16,4 +16,8 @@ export declare const deployTricryptoPool: (name: string, symbol: string, coins:
 export declare const getDeployedTricryptoPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
 export declare const deployGaugeEstimateGas: (pool: string, factory: string) => Promise<number>;
 export declare const deployGauge: (pool: string, factory: string) => Promise<ethers.ContractTransactionResponse>;
+export declare const deployGaugeSidechainEstimateGas: (pool: string, salt: string) => Promise<number>;
+export declare const deployGaugeSidechain: (pool: string, salt: string) => Promise<ethers.ContractTransactionResponse>;
+export declare const deployGaugeMirrorEstimateGas: (chainId: number, salt: string) => Promise<number>;
+export declare const deployGaugeMirror: (chainId: number, salt: string) => Promise<ethers.ContractTransactionResponse>;
 export declare const getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;

package/lib/factory/deploy.js

@@ -54,7 +54,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { ethers, Contract } from "ethers";
+import { ethers, Contract, Typed } from "ethers";
 import { curve } from "../curve.js";
 import { getPool } from "../pools/index.js";
 import { parseUnits, BN, mulBy1_3, getPoolIdBySwapAddress } from "../utils.js";
@@ -532,6 +532,8 @@ var _deployGauge = function (pool, factory, estimateGas) { return __awaiter(void
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
+                if (curve.chainId !== 1)
+                    throw Error("There is no deployGauge method on sidechain network");
                 contract = curve.contracts[factory].contract;
                 return [4 /*yield*/, contract.deploy_gauge.estimateGas(pool, curve.constantOptions)];
             case 1:
@@ -547,6 +549,52 @@ var _deployGauge = function (pool, factory, estimateGas) { return __awaiter(void
         }
     });
 }); };
+var _deployGaugeSidechain = function (pool, salt, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var contract, _salt, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId === 1)
+                    throw Error("There is no deployGaugeSidechain method on ethereum network");
+                contract = curve.contracts[curve.constants.ALIASES.gauge_factory].contract;
+                _salt = ethers.encodeBytes32String(salt);
+                return [4 /*yield*/, contract.deploy_gauge.estimateGas(pool, Typed.bytes32(_salt), curve.signerAddress, curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, Number(gas)];
+                gasLimit = mulBy1_3(gas);
+                return [4 /*yield*/, curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_gauge(pool, Typed.bytes32(_salt), curve.signerAddress, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var _deployGaugeMirror = function (chainId, salt, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var contract, _salt, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId !== 1)
+                    throw Error("There is no deployGaugeMirror method on sidechain network");
+                contract = curve.contracts[curve.constants.ALIASES.gauge_factory].contract;
+                _salt = ethers.encodeBytes32String(salt);
+                return [4 /*yield*/, contract.deploy_gauge.estimateGas(chainId, Typed.bytes32(_salt), curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, Number(gas)];
+                gasLimit = mulBy1_3(gas);
+                return [4 /*yield*/, curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                return [4 /*yield*/, contract.deploy_gauge(chainId, Typed.bytes32(_salt), __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
 export var deployGaugeEstimateGas = function (pool, factory) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
     switch (_a.label) {
         case 0: return [4 /*yield*/, _deployGauge(pool, factory, true)];
@@ -559,6 +607,30 @@ export var deployGauge = function (pool, factory) { return __awaiter(void 0, voi
         case 1: return [2 /*return*/, _a.sent()];
     }
 }); }); };
+export var deployGaugeSidechainEstimateGas = function (pool, salt) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, _deployGaugeSidechain(pool, salt, true)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+export var deployGaugeSidechain = function (pool, salt) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, _deployGaugeSidechain(pool, salt, false)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+export var deployGaugeMirrorEstimateGas = function (chainId, salt) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, _deployGaugeMirror(chainId, salt, true)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+export var deployGaugeMirror = function (chainId, salt) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, _deployGaugeMirror(chainId, salt, false)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
 export var getDeployedGaugeAddress = function (tx) { return __awaiter(void 0, void 0, void 0, function () {
     var txInfo;
     return __generator(this, function (_a) {

package/lib/factory/factory-crypto.js

@@ -126,27 +126,82 @@ function _handleCoinAddresses(coinAddresses) {
     var _this = this;
     return coinAddresses.map(function (addresses) { return addresses.map(function (addr) { return _this.chainId === 137 && addr === "0x0000000000000000000000000000000000001010" ? _this.constants.NATIVE_TOKEN.wrappedAddress : addr.toLowerCase(); }); });
 }
-function getPoolsData(factorySwapAddresses) {
+function _getLpTokenMap(factorySwapAddresses) {
     return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, res, tokenAddresses, gaugeAddresses, coinAddresses;
+        var factoryMulticallContract, LpTokenMap, getLpTokenCalls, _i, factorySwapAddresses_1, addr, lpTokens;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
-                    calls = [];
+                    LpTokenMap = {};
+                    getLpTokenCalls = [];
                     for (_i = 0, factorySwapAddresses_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
                         addr = factorySwapAddresses_1[_i];
+                        getLpTokenCalls.push(factoryMulticallContract.get_token(addr));
+                    }
+                    return [4 /*yield*/, this.multicallProvider.all(getLpTokenCalls)];
+                case 1:
+                    lpTokens = _a.sent();
+                    lpTokens.forEach(function (item, index) {
+                        if (typeof item === "string") {
+                            LpTokenMap[factorySwapAddresses[index]] = item;
+                        }
+                        else {
+                            throw Error("Lp token is not string");
+                        }
+                    });
+                    return [2 /*return*/, LpTokenMap];
+            }
+        });
+    });
+}
+function getPoolsData(factorySwapAddresses) {
+    return __awaiter(this, void 0, void 0, function () {
+        var factoryMulticallContract, isfactoryGaugeNull, calls, _i, factorySwapAddresses_2, addr, factoryMulticallGaugeContract, LpTokenMap, _a, factorySwapAddresses_3, addr, res, tokenAddresses, coinAddresses, gaugeAddresses, tokenAddresses, gaugeAddresses, coinAddresses;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    factoryMulticallContract = this.contracts[this.constants.ALIASES.crypto_factory].multicallContract;
+                    isfactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
+                    calls = [];
+                    if (!(this.chainId === 1)) return [3 /*break*/, 1];
+                    for (_i = 0, factorySwapAddresses_2 = factorySwapAddresses; _i < factorySwapAddresses_2.length; _i++) {
+                        addr = factorySwapAddresses_2[_i];
                         calls.push(factoryMulticallContract.get_token(addr));
                         calls.push(factoryMulticallContract.get_gauge(addr));
                         calls.push(factoryMulticallContract.get_coins(addr));
                     }
-                    return [4 /*yield*/, this.multicallProvider.all(calls)];
+                    return [3 /*break*/, 3];
                 case 1:
-                    res = _a.sent();
-                    tokenAddresses = res.filter(function (a, i) { return i % 3 == 0; }).map(function (a) { return a.toLowerCase(); });
-                    gaugeAddresses = res.filter(function (a, i) { return i % 3 == 1; }).map(function (a) { return a.toLowerCase(); });
-                    coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 3 == 2; }));
-                    return [2 /*return*/, [tokenAddresses, gaugeAddresses, coinAddresses]];
+                    factoryMulticallGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+                    return [4 /*yield*/, _getLpTokenMap.call(this, factorySwapAddresses)];
+                case 2:
+                    LpTokenMap = _b.sent();
+                    for (_a = 0, factorySwapAddresses_3 = factorySwapAddresses; _a < factorySwapAddresses_3.length; _a++) {
+                        addr = factorySwapAddresses_3[_a];
+                        calls.push(factoryMulticallContract.get_token(addr));
+                        if (!isfactoryGaugeNull) {
+                            calls.push(factoryMulticallGaugeContract.get_gauge_from_lp_token(LpTokenMap[addr]));
+                        }
+                        calls.push(factoryMulticallContract.get_coins(addr));
+                    }
+                    _b.label = 3;
+                case 3: return [4 /*yield*/, this.multicallProvider.all(calls)];
+                case 4:
+                    res = _b.sent();
+                    if (isfactoryGaugeNull) {
+                        tokenAddresses = res.filter(function (a, i) { return i % 3 == 0; }).map(function (a) { return a.toLowerCase(); });
+                        coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 3 == 1; }));
+                        gaugeAddresses = Array.from(Array(factorySwapAddresses.length)).map(function () { return '0x0000000000000000000000000000000000000000'; });
+                        return [2 /*return*/, [tokenAddresses, gaugeAddresses, coinAddresses]];
+                    }
+                    else {
+                        tokenAddresses = res.filter(function (a, i) { return i % 3 == 0; }).map(function (a) { return a.toLowerCase(); });
+                        gaugeAddresses = res.filter(function (a, i) { return i % 3 == 1; }).map(function (a) { return a.toLowerCase(); });
+                        coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 3 == 2; }));
+                        return [2 /*return*/, [tokenAddresses, gaugeAddresses, coinAddresses]];
+                    }
+                    return [2 /*return*/];
             }
         });
     });

package/lib/factory/factory-tricrypto.js

@@ -115,10 +115,11 @@ function _handleCoinAddresses(coinAddresses) {
 }
 function getPoolsData(factorySwapAddresses) {
     return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, res, gaugeAddresses, coinAddresses;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
+        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, res, gaugeAddresses, coinAddresses, factoryMulticallContract, isFactoryGaugeNull, factoryMulticallGaugeContract, calls, _a, factorySwapAddresses_2, addr, res, gaugeAddresses, coinAddresses, coinAddresses, gaugeAddresses;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
+                    if (!(this.chainId === 1)) return [3 /*break*/, 2];
                     factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
                     calls = [];
                     for (_i = 0, factorySwapAddresses_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
@@ -128,10 +129,37 @@ function getPoolsData(factorySwapAddresses) {
                     }
                     return [4 /*yield*/, this.multicallProvider.all(calls)];
                 case 1:
-                    res = _a.sent();
+                    res = _b.sent();
                     gaugeAddresses = res.filter(function (a, i) { return i % 2 == 0; }).map(function (a) { return a.toLowerCase(); });
                     coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 2 == 1; }));
                     return [2 /*return*/, [gaugeAddresses, coinAddresses]];
+                case 2:
+                    factoryMulticallContract = this.contracts[this.constants.ALIASES.tricrypto_factory].multicallContract;
+                    isFactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
+                    factoryMulticallGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
+                    calls = [];
+                    for (_a = 0, factorySwapAddresses_2 = factorySwapAddresses; _a < factorySwapAddresses_2.length; _a++) {
+                        addr = factorySwapAddresses_2[_a];
+                        if (!isFactoryGaugeNull) {
+                            calls.push(factoryMulticallGaugeContract.get_gauge_from_lp_token(addr));
+                        }
+                        calls.push(factoryMulticallContract.get_coins(addr));
+                    }
+                    return [4 /*yield*/, this.multicallProvider.all(calls)];
+                case 3:
+                    res = _b.sent();
+                    if (!isFactoryGaugeNull) {
+                        gaugeAddresses = res.filter(function (a, i) { return i % 2 == 0; }).map(function (a) { return a.toLowerCase(); });
+                        coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 2 == 1; }));
+                        return [2 /*return*/, [gaugeAddresses, coinAddresses]];
+                    }
+                    else {
+                        coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 2 == 0; }));
+                        gaugeAddresses = Array.from(Array(factorySwapAddresses.length)).map(function () { return '0x0000000000000000000000000000000000000000'; });
+                        return [2 /*return*/, [gaugeAddresses, coinAddresses]];
+                    }
+                    _b.label = 4;
+                case 4: return [2 /*return*/];
             }
         });
     });

package/lib/factory/factory.d.ts

@@ -1,2 +1,5 @@
 import { IDict, IPoolData, ICurve } from "../interfaces";
+export declare const BLACK_LIST: {
+    [index: number]: any;
+};
 export declare function getFactoryPoolData(this: ICurve, fromIdx?: number, swapAddress?: string, factoryAddress?: string): Promise<IDict<IPoolData>>;

package/lib/factory/factory.js

@@ -61,15 +61,19 @@ import factoryGaugeABI from "../constants/abis/gauge_factory.json" assert { type
 import gaugeChildABI from "../constants/abis/gauge_child.json" assert { type: 'json' };
 import { setFactoryZapContracts } from "./common.js";
 import { FACTORY_CONSTANTS } from "./constants.js";
-var BLACK_LIST = {
+export var BLACK_LIST = {
     1: [
         "0x066b6e1e93fa7dcd3f0eb7f8bac7d5a747ce0bf9",
+        "0xc61557c5d177bd7dc889a3b621eec333e168f68a",
     ],
     137: [
         "0x666dc3b4babfd063faf965bd020024af0dc51b64",
         "0xe4199bc5c5c1f63dba47b56b6db7144c51cf0bf8",
         "0x88c4d6534165510b2e2caf0a130d4f70aa4b6d71",
     ],
+    42161: [
+        "0xd7bb79aee866672419999a0496d99c54741d67b5"
+    ]
 };
 var deepFlatten = function (arr) { return [].concat.apply([], arr.map(function (v) { return (Array.isArray(v) ? deepFlatten(v) : v); })); };
 function getRecentlyCreatedPoolId(swapAddress) {
@@ -153,17 +157,24 @@ function _handleCoinAddresses(coinAddresses) {
 }
 function getPoolsData(factorySwapAddresses, factoryAddress) {
     return __awaiter(this, void 0, void 0, function () {
-        var factoryMulticallContract, calls, _i, factorySwapAddresses_1, addr, tempSwapContract, res, implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses;
+        var factoryMulticallContract, isFactoryGaugeNull, factoryGaugeContract, calls, _i, factorySwapAddresses_1, addr, tempSwapContract, res, implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses, implememntationAddresses, referenceAssets, symbols, names, isMeta, coinAddresses, gaugeAddresses;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     factoryMulticallContract = this.contracts[factoryAddress].multicallContract;
+                    isFactoryGaugeNull = this.constants.ALIASES.gauge_factory === '0x0000000000000000000000000000000000000000';
+                    factoryGaugeContract = this.contracts[this.constants.ALIASES.gauge_factory].multicallContract;
                     calls = [];
                     for (_i = 0, factorySwapAddresses_1 = factorySwapAddresses; _i < factorySwapAddresses_1.length; _i++) {
                         addr = factorySwapAddresses_1[_i];
                         tempSwapContract = new MulticallContract(addr, ERC20ABI);
                         calls.push(factoryMulticallContract.get_implementation_address(addr));
-                        calls.push(factoryMulticallContract.get_gauge(addr));
+                        if (this.chainId === 1) {
+                            calls.push(factoryMulticallContract.get_gauge(addr));
+                        }
+                        else if (!isFactoryGaugeNull) {
+                            calls.push(factoryGaugeContract.get_gauge_from_lp_token(addr));
+                        }
                         calls.push(factoryMulticallContract.get_pool_asset_type(addr));
                         calls.push(tempSwapContract.symbol());
                         calls.push(tempSwapContract.name());
@@ -173,14 +184,27 @@ function getPoolsData(factorySwapAddresses, factoryAddress) {
                     return [4 /*yield*/, this.multicallProvider.all(calls)];
                 case 1:
                     res = _a.sent();
-                    implememntationAddresses = res.filter(function (a, i) { return i % 7 == 0; }).map(function (a) { return a.toLowerCase(); });
-                    gaugeAddresses = res.filter(function (a, i) { return i % 7 == 1; }).map(function (a) { return a.toLowerCase(); });
-                    referenceAssets = _handleReferenceAssets(res.filter(function (a, i) { return i % 7 == 2; }));
-                    symbols = res.filter(function (a, i) { return i % 7 == 3; });
-                    names = res.filter(function (a, i) { return i % 7 == 4; });
-                    isMeta = res.filter(function (a, i) { return i % 7 == 5; });
-                    coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 7 == 6; }));
-                    return [2 /*return*/, [implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses]];
+                    if (!isFactoryGaugeNull) {
+                        implememntationAddresses = res.filter(function (a, i) { return i % 7 == 0; }).map(function (a) { return a.toLowerCase(); });
+                        gaugeAddresses = res.filter(function (a, i) { return i % 7 == 1; }).map(function (a) { return a.toLowerCase(); });
+                        referenceAssets = _handleReferenceAssets(res.filter(function (a, i) { return i % 7 == 2; }));
+                        symbols = res.filter(function (a, i) { return i % 7 == 3; });
+                        names = res.filter(function (a, i) { return i % 7 == 4; });
+                        isMeta = res.filter(function (a, i) { return i % 7 == 5; });
+                        coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 7 == 6; }));
+                        return [2 /*return*/, [implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses]];
+                    }
+                    else {
+                        implememntationAddresses = res.filter(function (a, i) { return i % 7 == 0; }).map(function (a) { return a.toLowerCase(); });
+                        referenceAssets = _handleReferenceAssets(res.filter(function (a, i) { return i % 7 == 1; }));
+                        symbols = res.filter(function (a, i) { return i % 7 == 2; });
+                        names = res.filter(function (a, i) { return i % 7 == 3; });
+                        isMeta = res.filter(function (a, i) { return i % 7 == 4; });
+                        coinAddresses = _handleCoinAddresses.call(this, res.filter(function (a, i) { return i % 7 == 5; }));
+                        gaugeAddresses = Array.from(Array(factorySwapAddresses.length)).map(function () { return '0x0000000000000000000000000000000000000000'; });
+                        return [2 /*return*/, [implememntationAddresses, gaugeAddresses, referenceAssets, symbols, names, isMeta, coinAddresses]];
+                    }
+                    return [2 /*return*/];
             }
         });
     });
@@ -349,7 +373,7 @@ export function getFactoryPoolData(fromIdx, swapAddress, factoryAddress) {
                             };
                         }
                         else {
-                            var allPoolsData_1 = __assign(__assign({}, this_1.constants.POOLS_DATA), FACTORY_POOLS_DATA);
+                            var allPoolsData_1 = __assign(__assign(__assign({}, this_1.constants.POOLS_DATA), this_1.constants.FACTORY_POOLS_DATA), FACTORY_POOLS_DATA);
                             // @ts-ignore
                             var basePoolIdCoinsDict = Object.fromEntries(basePoolIds.map(function (poolId) { var _a; return [poolId, (_a = allPoolsData_1[poolId]) === null || _a === void 0 ? void 0 : _a.underlying_coins]; }));
                             // @ts-ignore

package/lib/index.d.ts

@@ -63,6 +63,8 @@ declare const curve: {
         setOracle: (poolAddress: string, oracleAddress?: string, methodName?: string) => Promise<ethers.ContractTransactionResponse>;
         deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, implementationIdx: 0 | 1) => Promise<ethers.ContractTransactionResponse>;
         deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeMirror: (chainId: number, salt: string) => Promise<ethers.ContractTransactionResponse>;
         getDeployedPlainPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedMetaPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
@@ -73,6 +75,8 @@ declare const curve: {
             setOracle: (poolAddress: string, oracleAddress?: string, methodName?: string) => Promise<number>;
             deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, implementationIdx: 0 | 1) => Promise<number>;
             deployGauge: (poolAddress: string) => Promise<number>;
+            deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<number>;
+            deployGaugeMirror: (chainId: number, salt: string) => Promise<number>;
         };
     };
     crvUSDFactory: {
@@ -89,6 +93,8 @@ declare const curve: {
         getPoolList: () => string[];
         deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: number, initialPrice: string | number) => Promise<ethers.ContractTransactionResponse>;
         deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeMirror: (chainId: number, salt: string) => Promise<ethers.ContractTransactionResponse>;
         getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
@@ -96,6 +102,8 @@ declare const curve: {
         estimateGas: {
             deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: number, initialPrice: string | number) => Promise<number>;
             deployGauge: (poolAddress: string) => Promise<number>;
+            deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<number>;
+            deployGaugeMirror: (chainId: number, salt: string) => Promise<number>;
         };
     };
     tricryptoFactory: {
@@ -104,6 +112,8 @@ declare const curve: {
         getPoolList: () => string[];
         deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, emaTime: number, initialPrices: (string | number)[]) => Promise<ethers.ContractTransactionResponse>;
         deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<ethers.ContractTransactionResponse>;
+        deployGaugeMirror: (chainId: number, salt: string) => Promise<ethers.ContractTransactionResponse>;
         getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
@@ -111,6 +121,8 @@ declare const curve: {
         estimateGas: {
             deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, emaTime: number, initialPrices: (string | number)[]) => Promise<number>;
             deployGauge: (poolAddress: string) => Promise<number>;
+            deployGaugeSidechain: (poolAddress: string, salt: string) => Promise<number>;
+            deployGaugeMirror: (chainId: number, salt: string) => Promise<number>;
         };
     };
     estimateGas: {