@curvefi/api 2.66.29 → 2.66.31

package/lib/pools/PoolTemplate.js

@@ -9,41 +9,41 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import memoize from "memoizee";
 import { _getAllGaugesFormatted } from '../external-api.js';
-import { _getCoinAddresses, _ensureAllowance, _getUsdRate, hasAllowance, ensureAllowance, ensureAllowanceEstimateGas, BN, toBN, toStringFromBN, parseUnits, getEthIndex, fromBN, _cutZeros, _setContracts, _get_small_x, _get_price_impact, checkNumber, _getRewardsFromApi, mulBy1_3, smartNumber, DIGas, _getAddress, findAbiFunction, PERIODS, } from '../utils.js';
-import { curve, OLD_CHAINS } from "../curve.js";
+import { _cutZeros, _ensureAllowance, _get_price_impact, _get_small_x, _getAddress, _getCoinAddresses, _getRewardsFromApi, _getUsdRate, _setContracts, BN, checkNumber, DIGas, ensureAllowance, ensureAllowanceEstimateGas, findAbiFunction, fromBN, getEthIndex, hasAllowance, mulBy1_3, parseUnits, PERIODS, smartNumber, toBN, toStringFromBN, } from '../utils.js';
+import { OLD_CHAINS } from "../curve.js";
 import ERC20Abi from '../constants/abis/ERC20.json' with { type: 'json' };
 import { CorePool } from "./subClasses/corePool.js";
 import { StatsPool } from "./subClasses/statsPool.js";
 import { WalletPool } from "./subClasses/walletPool.js";
 import { checkVyperVulnerability } from "./utils.js";
 export class PoolTemplate extends CorePool {
-    constructor(id) {
-        super(id);
+    constructor(id, curve, poolData = curve.getPoolsData()[id]) {
+        super(id, poolData, curve);
         this._calcTokenApy = (...args_1) => __awaiter(this, [...args_1], void 0, function* (futureWorkingSupplyBN = null) {
             const totalLiquidityUSD = yield this.stats.totalLiquidity();
             if (Number(totalLiquidityUSD) === 0)
                 return [0, 0];
             let inflationRateBN, workingSupplyBN, totalSupplyBN;
-            if (curve.chainId !== 1) {
-                const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
-                const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
-                const crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
+            if (this.curve.chainId !== 1) {
+                const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
+                const lpTokenContract = this.curve.contracts[this.lpToken].multicallContract;
+                const crvContract = this.curve.contracts[this.curve.constants.ALIASES.crv].contract;
                 const currentWeek = Math.floor(Date.now() / 1000 / PERIODS.WEEK);
-                [inflationRateBN, workingSupplyBN, totalSupplyBN] = (yield curve.multicallProvider.all([
+                [inflationRateBN, workingSupplyBN, totalSupplyBN] = (yield this.curve.multicallProvider.all([
                     gaugeContract.inflation_rate(currentWeek),
                     gaugeContract.working_supply(),
                     lpTokenContract.totalSupply(),
                 ])).map((value) => toBN(value));
                 if (inflationRateBN.eq(0)) {
-                    inflationRateBN = toBN(yield crvContract.balanceOf(this.gauge.address, curve.constantOptions)).div(PERIODS.WEEK);
+                    inflationRateBN = toBN(yield crvContract.balanceOf(this.gauge.address, this.curve.constantOptions)).div(PERIODS.WEEK);
                 }
             }
             else {
-                const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
-                const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
-                const gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
+                const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
+                const lpTokenContract = this.curve.contracts[this.lpToken].multicallContract;
+                const gaugeControllerContract = this.curve.contracts[this.curve.constants.ALIASES.gauge_controller].multicallContract;
                 let weightBN;
-                [inflationRateBN, weightBN, workingSupplyBN, totalSupplyBN] = (yield curve.multicallProvider.all([
+                [inflationRateBN, weightBN, workingSupplyBN, totalSupplyBN] = (yield this.curve.multicallProvider.all([
                     gaugeContract.inflation_rate(),
                     gaugeControllerContract.gauge_relative_weight(this.gauge.address),
                     gaugeContract.working_supply(),
@@ -58,7 +58,7 @@ export class PoolTemplate extends CorePool {
             // If you added 1$ value of LP it would be 0.4$ of working LP. So your annual reward per 1$ in USD is:
             // (annual reward per working liquidity in $) * (0.4$ of working LP)
             const rateBN = inflationRateBN.times(31536000).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)).times(0.4);
-            const crvPrice = yield _getUsdRate(curve.constants.ALIASES.crv);
+            const crvPrice = yield _getUsdRate.call(this.curve, this.curve.constants.ALIASES.crv);
             const baseApyBN = rateBN.times(crvPrice);
             const boostedApyBN = baseApyBN.times(2.5);
             return [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()];
@@ -69,14 +69,14 @@ export class PoolTemplate extends CorePool {
                     return yield this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying);
                 }
                 catch (e) { // Seeding
-                    const lpContract = curve.contracts[this.lpToken].contract;
-                    const _lpTotalSupply = yield lpContract.totalSupply(curve.constantOptions);
-                    if (_lpTotalSupply > curve.parseUnits("0"))
+                    const lpContract = this.curve.contracts[this.lpToken].contract;
+                    const _lpTotalSupply = yield lpContract.totalSupply(this.curve.constantOptions);
+                    if (_lpTotalSupply > this.curve.parseUnits("0"))
                         throw e; // Already seeded
                     if (this.isMeta && useUnderlying)
                         throw Error("Initial deposit for crypto meta pools must be in wrapped coins");
                     const decimals = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                    const amounts = _amounts.map((_a, i) => curve.formatUnits(_a, decimals[i]));
+                    const amounts = _amounts.map((_a, i) => this.curve.formatUnits(_a, decimals[i]));
                     const seedAmounts = yield this.getSeedAmounts(amounts[0]); // Checks N coins is 2 or 3 and amounts > 0
                     amounts.forEach((a, i) => {
                         if (!BN(a).eq(BN(seedAmounts[i])))
@@ -89,22 +89,22 @@ export class PoolTemplate extends CorePool {
                 if (this.isNg)
                     return yield this._pureCalcLpTokenAmount(_amounts, isDeposit, useUnderlying);
                 if (this.isMeta) {
-                    const basePool = new PoolTemplate(this.basePool);
-                    return yield curve.contracts[curve.constants.ALIASES.stable_calc].contract.calc_token_amount_meta(this.address, this.lpToken, _amounts.concat(Array(10 - _amounts.length).fill(curve.parseUnits("0"))), _amounts.length, basePool.address, basePool.lpToken, isDeposit, useUnderlying);
+                    const basePool = new PoolTemplate(this.basePool, this.curve);
+                    return yield this.curve.contracts[this.curve.constants.ALIASES.stable_calc].contract.calc_token_amount_meta(this.address, this.lpToken, _amounts.concat(Array(10 - _amounts.length).fill(this.curve.parseUnits("0"))), _amounts.length, basePool.address, basePool.lpToken, isDeposit, useUnderlying);
                 }
                 else {
-                    return yield curve.contracts[curve.constants.ALIASES.stable_calc].contract.calc_token_amount(this.address, this.lpToken, _amounts.concat(Array(10 - _amounts.length).fill(curve.parseUnits("0"))), _amounts.length, isDeposit, useUnderlying && this.isLending);
+                    return yield this.curve.contracts[this.curve.constants.ALIASES.stable_calc].contract.calc_token_amount(this.address, this.lpToken, _amounts.concat(Array(10 - _amounts.length).fill(this.curve.parseUnits("0"))), _amounts.length, isDeposit, useUnderlying && this.isLending);
                 }
             }
             catch (e) { // Seeding
                 if (!isDeposit)
                     throw e; // Seeding is only for deposit
-                const lpContract = curve.contracts[this.lpToken].contract;
-                const _lpTotalSupply = yield lpContract.totalSupply(curve.constantOptions);
-                if (_lpTotalSupply > curve.parseUnits("0"))
+                const lpContract = this.curve.contracts[this.lpToken].contract;
+                const _lpTotalSupply = yield lpContract.totalSupply(this.curve.constantOptions);
+                if (_lpTotalSupply > this.curve.parseUnits("0"))
                     throw e; // Already seeded
                 const decimals = useUnderlying ? this.underlyingDecimals : this.wrappedDecimals;
-                const amounts = _amounts.map((_a, i) => curve.formatUnits(_a, decimals[i]));
+                const amounts = _amounts.map((_a, i) => this.curve.formatUnits(_a, decimals[i]));
                 const seedAmounts = yield this.getSeedAmounts(amounts[0]); // Checks N coins == 2 and amounts > 0
                 amounts.forEach((a, i) => {
                     if (!BN(a).eq(BN(seedAmounts[i])))
@@ -123,28 +123,28 @@ export class PoolTemplate extends CorePool {
         this.crvProfit = (...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
             if (this.rewardsOnly())
                 throw Error(`${this.name} has Rewards-Only Gauge. Use rewardsProfit instead`);
-            address = address || curve.signerAddress;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
             let inflationRateBN, workingSupplyBN, workingBalanceBN;
-            if (curve.chainId !== 1) {
-                const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
-                const crvContract = curve.contracts[curve.constants.ALIASES.crv].contract;
+            if (this.curve.chainId !== 1) {
+                const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
+                const crvContract = this.curve.contracts[this.curve.constants.ALIASES.crv].contract;
                 const currentWeek = Math.floor(Date.now() / 1000 / PERIODS.WEEK);
-                [inflationRateBN, workingBalanceBN, workingSupplyBN] = (yield curve.multicallProvider.all([
+                [inflationRateBN, workingBalanceBN, workingSupplyBN] = (yield this.curve.multicallProvider.all([
                     gaugeContract.inflation_rate(currentWeek),
                     gaugeContract.working_balances(address),
                     gaugeContract.working_supply(),
                 ])).map((value) => toBN(value));
                 if (inflationRateBN.eq(0)) {
-                    inflationRateBN = toBN(yield crvContract.balanceOf(this.gauge.address, curve.constantOptions)).div(PERIODS.WEEK);
+                    inflationRateBN = toBN(yield crvContract.balanceOf(this.gauge.address, this.curve.constantOptions)).div(PERIODS.WEEK);
                 }
             }
             else {
-                const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
-                const gaugeControllerContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
+                const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
+                const gaugeControllerContract = this.curve.contracts[this.curve.constants.ALIASES.gauge_controller].multicallContract;
                 let weightBN;
-                [inflationRateBN, weightBN, workingBalanceBN, workingSupplyBN] = (yield curve.multicallProvider.all([
+                [inflationRateBN, weightBN, workingBalanceBN, workingSupplyBN] = (yield this.curve.multicallProvider.all([
                     gaugeContract.inflation_rate(),
                     gaugeControllerContract.gauge_relative_weight(this.gauge.address),
                     gaugeContract.working_balances(address),
@@ -152,14 +152,14 @@ export class PoolTemplate extends CorePool {
                 ])).map((value) => toBN(value));
                 inflationRateBN = inflationRateBN.times(weightBN);
             }
-            const crvPrice = yield _getUsdRate('CRV');
+            const crvPrice = yield _getUsdRate.call(this.curve, 'CRV');
             if (workingSupplyBN.eq(0))
                 return {
                     day: "0.0",
                     week: "0.0",
                     month: "0.0",
                     year: "0.0",
-                    token: curve.constants.ALIASES.crv,
+                    token: this.curve.constants.ALIASES.crv,
                     symbol: 'CRV',
                     price: crvPrice,
                 };
@@ -172,19 +172,19 @@ export class PoolTemplate extends CorePool {
                 week: weeklyIncome.toString(),
                 month: monthlyIncome.toString(),
                 year: annualIncome.toString(),
-                token: curve.constants.ALIASES.crv,
+                token: this.curve.constants.ALIASES.crv,
                 symbol: 'CRV',
                 price: crvPrice,
             };
         });
         this.userBoost = (...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS)
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS)
                 throw Error(`${this.name} doesn't have gauge`);
             if (this.rewardsOnly())
                 throw Error(`${this.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
-            address = _getAddress(address);
-            const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
-            const [workingBalanceBN, balanceBN] = (yield curve.multicallProvider.all([
+            address = _getAddress.call(this.curve, address);
+            const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
+            const [workingBalanceBN, balanceBN] = (yield this.curve.multicallProvider.all([
                 gaugeContract.working_balances(address),
                 gaugeContract.balanceOf(address),
             ])).map((value) => toBN(value));
@@ -197,8 +197,8 @@ export class PoolTemplate extends CorePool {
         });
         this._userFutureBoostAndWorkingSupply = (address) => __awaiter(this, void 0, void 0, function* () {
             // Calc future working balance
-            const veContractMulticall = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
-            const gaugeContractMulticall = curve.contracts[this.gauge.address].multicallContract;
+            const veContractMulticall = this.curve.contracts[this.curve.constants.ALIASES.voting_escrow].multicallContract;
+            const gaugeContractMulticall = this.curve.contracts[this.gauge.address].multicallContract;
             const calls = [
                 veContractMulticall.balanceOf(address),
                 veContractMulticall.totalSupply(),
@@ -207,7 +207,7 @@ export class PoolTemplate extends CorePool {
                 gaugeContractMulticall.working_balances(address),
                 gaugeContractMulticall.working_supply(),
             ];
-            const [_votingBalance, _votingTotal, _gaugeBalance, _gaugeTotal, _workingBalance, _workingSupply] = yield curve.multicallProvider.all(calls);
+            const [_votingBalance, _votingTotal, _gaugeBalance, _gaugeTotal, _workingBalance, _workingSupply] = yield this.curve.multicallProvider.all(calls);
             let _futureWorkingBalance = _gaugeBalance * BigInt(40) / BigInt(100);
             if (_votingTotal > BigInt(0)) {
                 _futureWorkingBalance += _gaugeTotal * _votingBalance / _votingTotal * BigInt(60) / BigInt(100);
@@ -223,7 +223,7 @@ export class PoolTemplate extends CorePool {
         this.userFutureBoost = (...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
             if (this.rewardsOnly())
                 throw Error(`${this.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
-            address = _getAddress(address);
+            address = _getAddress.call(this.curve, address);
             const [boostBN] = yield this._userFutureBoostAndWorkingSupply(address);
             if (boostBN.lt(1))
                 return '1.0';
@@ -234,7 +234,7 @@ export class PoolTemplate extends CorePool {
         this.userCrvApy = (...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
             if (this.rewardsOnly())
                 throw Error(`${this.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
-            address = _getAddress(address);
+            address = _getAddress.call(this.curve, address);
             const [minApy, maxApy] = yield this.stats.tokenApy();
             const boost = yield this.userBoost(address);
             if (boost == "2.5")
@@ -246,7 +246,7 @@ export class PoolTemplate extends CorePool {
         this.userFutureCrvApy = (...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
             if (this.rewardsOnly())
                 throw Error(`${this.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
-            address = _getAddress(address);
+            address = _getAddress.call(this.curve, address);
             const [boostBN, futureWorkingSupplyBN] = yield this._userFutureBoostAndWorkingSupply(address);
             const [minApy, maxApy] = yield this._calcTokenApy(futureWorkingSupplyBN);
             if (boostBN.lt(1))
@@ -256,21 +256,21 @@ export class PoolTemplate extends CorePool {
             return BN(minApy).times(boostBN).toNumber();
         });
         this.maxBoostedStake = (...addresses) => __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS)
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS)
                 throw Error(`${this.name} doesn't have gauge`);
             if (addresses.length == 1 && Array.isArray(addresses[0]))
                 addresses = addresses[0];
-            if (addresses.length === 0 && curve.signerAddress !== '')
-                addresses = [curve.signerAddress];
+            if (addresses.length === 0 && this.curve.signerAddress !== '')
+                addresses = [this.curve.signerAddress];
             if (addresses.length === 0)
                 throw Error("Need to connect wallet or pass addresses into args");
-            const votingEscrowContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
-            const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
+            const votingEscrowContract = this.curve.contracts[this.curve.constants.ALIASES.voting_escrow].multicallContract;
+            const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
             const contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
             addresses.forEach((account) => {
                 contractCalls.push(votingEscrowContract.balanceOf(account));
             });
-            const _response = yield curve.multicallProvider.all(contractCalls);
+            const _response = yield this.curve.multicallProvider.all(contractCalls);
             const responseBN = _response.map((value) => toBN(value));
             const [veTotalSupplyBN, gaugeTotalSupplyBN] = responseBN.splice(0, 2);
             const resultBN = {};
@@ -285,14 +285,15 @@ export class PoolTemplate extends CorePool {
         });
         // ---------------- REWARDS PROFIT, CLAIM ----------------
         this.rewardTokens = memoize((...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+            const curve = this.curve;
             if (this.gauge.address === curve.constants.ZERO_ADDRESS)
                 return [];
             if (useApi) {
-                const rewards = yield _getRewardsFromApi();
+                const rewards = yield _getRewardsFromApi.call(curve);
                 if (!rewards[this.gauge.address])
                     return [];
                 // Don't reset ABI if its already set, we might override an LP token ABI
-                rewards[this.gauge.address].forEach((r) => !curve.contracts[r.tokenAddress] && _setContracts(r.tokenAddress, ERC20Abi));
+                rewards[this.gauge.address].forEach((r) => !curve.contracts[r.tokenAddress] && _setContracts.call(curve, r.tokenAddress, ERC20Abi));
                 return rewards[this.gauge.address].map((r) => ({ token: r.tokenAddress, symbol: r.symbol, decimals: Number(r.decimals) }));
             }
             const gaugeContract = curve.contracts[this.gauge.address].contract;
@@ -313,7 +314,7 @@ export class PoolTemplate extends CorePool {
                 const tokenInfoCalls = [];
                 for (const token of tokens) {
                     // Don't reset ABI if its already set, we might override an LP token ABI
-                    const { multicallContract } = curve.contracts[token] || _setContracts(token, ERC20Abi);
+                    const { multicallContract } = curve.contracts[token] || _setContracts.call(curve, token, ERC20Abi);
                     tokenInfoCalls.push(multicallContract.symbol(), multicallContract.decimals());
                 }
                 const tokenInfo = yield curve.multicallProvider.all(tokenInfoCalls);
@@ -326,7 +327,7 @@ export class PoolTemplate extends CorePool {
                 const rewardContract = curve.contracts[this.sRewardContract].contract;
                 const method = "snx()" in rewardContract ? "snx" : "rewardsToken"; // susd, tbtc : dusd, musd, rsv, sbtc
                 const token = (yield rewardContract[method](curve.constantOptions)).toLowerCase();
-                _setContracts(token, ERC20Abi);
+                _setContracts.call(curve, token, ERC20Abi);
                 const tokenMulticallContract = curve.contracts[token].multicallContract;
                 const res = yield curve.multicallProvider.all([
                     tokenMulticallContract.symbol(),
@@ -342,27 +343,27 @@ export class PoolTemplate extends CorePool {
             maxAge: 30 * 60 * 1000, // 30m
         });
         this.rewardsProfit = (...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS)
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS)
                 throw Error(`${this.name} doesn't have gauge`);
-            address = address || curve.signerAddress;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
             const rewardTokens = yield this.rewardTokens();
-            const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
+            const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
             const result = [];
-            if ('reward_data(address)' in curve.contracts[this.gauge.address].contract) {
+            if ('reward_data(address)' in this.curve.contracts[this.gauge.address].contract) {
                 const calls = [gaugeContract.balanceOf(address), gaugeContract.totalSupply()];
                 for (const rewardToken of rewardTokens) {
                     calls.push(gaugeContract.reward_data(rewardToken.token));
                 }
-                const res = yield curve.multicallProvider.all(calls);
+                const res = yield this.curve.multicallProvider.all(calls);
                 const balanceBN = toBN(res.shift());
                 const totalSupplyBN = toBN(res.shift());
                 for (const rewardToken of rewardTokens) {
                     const _rewardData = res.shift();
-                    const periodFinish = Number(curve.formatUnits(_rewardData.period_finish, 0)) * 1000;
+                    const periodFinish = Number(this.curve.formatUnits(_rewardData.period_finish, 0)) * 1000;
                     const inflationRateBN = periodFinish > Date.now() ? toBN(_rewardData.rate, rewardToken.decimals) : BN(0);
-                    const tokenPrice = yield _getUsdRate(rewardToken.token);
+                    const tokenPrice = yield _getUsdRate.call(this.curve, rewardToken.token);
                     result.push({
                         day: inflationRateBN.times(PERIODS.DAY).times(balanceBN).div(totalSupplyBN).toString(),
                         week: inflationRateBN.times(PERIODS.WEEK).times(balanceBN).div(totalSupplyBN).toString(),
@@ -374,10 +375,10 @@ export class PoolTemplate extends CorePool {
                     });
                 }
             }
-            else if (this.sRewardContract && "rewardRate()" in curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1) {
+            else if (this.sRewardContract && "rewardRate()" in this.curve.contracts[this.sRewardContract].contract && "periodFinish()" && rewardTokens.length === 1) {
                 const rewardToken = rewardTokens[0];
-                const sRewardContract = curve.contracts[this.sRewardContract].multicallContract;
-                const [_inflationRate, _periodFinish, _balance, _totalSupply] = yield curve.multicallProvider.all([
+                const sRewardContract = this.curve.contracts[this.sRewardContract].multicallContract;
+                const [_inflationRate, _periodFinish, _balance, _totalSupply] = yield this.curve.multicallProvider.all([
                     sRewardContract.rewardRate(),
                     sRewardContract.periodFinish(),
                     gaugeContract.balanceOf(address),
@@ -387,7 +388,7 @@ export class PoolTemplate extends CorePool {
                 const inflationRateBN = periodFinish > Date.now() ? toBN(_inflationRate, rewardToken.decimals) : BN(0);
                 const balanceBN = toBN(_balance);
                 const totalSupplyBN = toBN(_totalSupply);
-                const tokenPrice = yield _getUsdRate(rewardToken.token);
+                const tokenPrice = yield _getUsdRate.call(this.curve, rewardToken.token);
                 result.push({
                     day: inflationRateBN.times(PERIODS.DAY).times(balanceBN).div(totalSupplyBN).toString(),
                     week: inflationRateBN.times(PERIODS.WEEK).times(balanceBN).div(totalSupplyBN).toString(),
@@ -400,7 +401,7 @@ export class PoolTemplate extends CorePool {
             }
             else if (['aave', 'saave', 'ankreth'].includes(this.id)) {
                 for (const rewardToken of rewardTokens) {
-                    const tokenPrice = yield _getUsdRate(rewardToken.token);
+                    const tokenPrice = yield _getUsdRate.call(this.curve, rewardToken.token);
                     result.push({
                         day: "0",
                         week: "0",
@@ -416,18 +417,18 @@ export class PoolTemplate extends CorePool {
         });
         // ---------------- ... ----------------
         this.gaugeOptimalDeposits = (...accounts) => __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS)
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS)
                 throw Error(`${this.name} doesn't have gauge`);
             if (accounts.length == 1 && Array.isArray(accounts[0]))
                 accounts = accounts[0];
-            const votingEscrowContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
-            const lpTokenContract = curve.contracts[this.lpToken].multicallContract;
-            const gaugeContract = curve.contracts[this.gauge.address].multicallContract;
+            const votingEscrowContract = this.curve.contracts[this.curve.constants.ALIASES.voting_escrow].multicallContract;
+            const lpTokenContract = this.curve.contracts[this.lpToken].multicallContract;
+            const gaugeContract = this.curve.contracts[this.gauge.address].multicallContract;
             const contractCalls = [votingEscrowContract.totalSupply(), gaugeContract.totalSupply()];
             accounts.forEach((account) => {
                 contractCalls.push(votingEscrowContract.balanceOf(account), lpTokenContract.balanceOf(account), gaugeContract.balanceOf(account));
             });
-            const _response = yield curve.multicallProvider.all(contractCalls);
+            const _response = yield this.curve.multicallProvider.all(contractCalls);
             const response = _response.map((value) => toBN(value));
             const [veTotalSupply, gaugeTotalSupply] = response.splice(0, 2);
             const votingPower = {};
@@ -438,7 +439,6 @@ export class PoolTemplate extends CorePool {
                 response.splice(0, 3);
             }
             const totalPower = Object.values(votingPower).reduce((sum, item) => sum.plus(item));
-            // @ts-ignore
             const optimalBN = Object.fromEntries(accounts.map((acc) => [acc, BN(0)]));
             if (totalBalance.lt(gaugeTotalSupply.times(totalPower).div(veTotalSupply))) {
                 for (const acct of accounts) {
@@ -481,7 +481,7 @@ export class PoolTemplate extends CorePool {
                 }
                 return idx;
             }
-            const [coinAddress] = _getCoinAddresses(coin);
+            const [coinAddress] = _getCoinAddresses.call(this.curve, coin);
             const lowerCaseCoinAddresses = useUnderlying ?
                 this.underlyingCoinAddresses.map((c) => c.toLowerCase()) :
                 this.wrappedCoinAddresses.map((c) => c.toLowerCase());
@@ -498,17 +498,17 @@ export class PoolTemplate extends CorePool {
                 const addr = this.wrappedCoinAddresses[i];
                 if (this.useLending[i]) {
                     if (['compound', 'usdt', 'ib'].includes(this.id)) {
-                        _rates.push(yield curve.contracts[addr].contract.exchangeRateStored());
+                        _rates.push(yield this.curve.contracts[addr].contract.exchangeRateStored());
                     }
                     else if (['y', 'busd', 'pax'].includes(this.id)) {
-                        _rates.push(yield curve.contracts[addr].contract.getPricePerFullShare());
+                        _rates.push(yield this.curve.contracts[addr].contract.getPricePerFullShare());
                     }
                     else {
-                        _rates.push(curve.parseUnits(String(Math.pow(10, 18)), 0)); // Aave ratio 1:1
+                        _rates.push(this.curve.parseUnits(String(Math.pow(10, 18)), 0)); // Aave ratio 1:1
                     }
                 }
                 else {
-                    _rates.push(curve.parseUnits(String(Math.pow(10, 18)), 0));
+                    _rates.push(this.curve.parseUnits(String(Math.pow(10, 18)), 0));
                 }
             }
             return _rates;
@@ -517,12 +517,12 @@ export class PoolTemplate extends CorePool {
             if (this.isMeta) {
                 if (useUnderlying)
                     return this.underlyingCoins.map(() => BN(1));
-                const _vp = yield curve.contracts[curve.getPoolsData()[this.basePool].swap_address].contract.get_virtual_price();
+                const _vp = yield this.curve.contracts[this.curve.getPoolsData()[this.basePool].swap_address].contract.get_virtual_price();
                 return [BN(1), toBN(_vp)];
             }
             //for crvusd and stable-ng implementations
-            if (findAbiFunction(curve.contracts[this.address].abi, 'stored_rates').length > 0 && this.isPlain) {
-                const _stored_rates = yield curve.contracts[this.address].contract.stored_rates();
+            if (findAbiFunction(this.curve.contracts[this.address].abi, 'stored_rates').length > 0 && this.isPlain) {
+                const _stored_rates = yield this.curve.contracts[this.address].contract.stored_rates();
                 return _stored_rates.map((_r, i) => toBN(_r, 36 - this.wrappedDecimals[i]));
             }
             return this.wrappedCoins.map(() => BN(1));
@@ -530,7 +530,7 @@ export class PoolTemplate extends CorePool {
         this._underlyingPrices = () => __awaiter(this, void 0, void 0, function* () {
             const promises = [];
             for (const addr of this.underlyingCoinAddresses) {
-                promises.push(_getUsdRate(addr));
+                promises.push(_getUsdRate.call(this.curve, addr));
             }
             return yield Promise.all(promises);
         });
@@ -538,7 +538,7 @@ export class PoolTemplate extends CorePool {
         this._wrappedPrices = () => __awaiter(this, void 0, void 0, function* () {
             const promises = [];
             for (const addr of this.wrappedCoinAddresses) {
-                promises.push(_getUsdRate(addr));
+                promises.push(_getUsdRate.call(this.curve, addr));
             }
             return yield Promise.all(promises);
         });
@@ -576,31 +576,31 @@ export class PoolTemplate extends CorePool {
         };
     }
     hasVyperVulnerability() {
-        return checkVyperVulnerability(curve.chainId, this.id, this.implementation);
+        return checkVyperVulnerability(this.curve.chainId, this.id, this.implementation);
     }
     rewardsOnly() {
-        if (curve.chainId === 2222 || curve.chainId === 324)
+        if (this.curve.chainId === 2222 || this.curve.chainId === 324)
             return true; // TODO remove this for Kava and ZkSync
-        if (this.gauge.address === curve.constants.ZERO_ADDRESS)
+        if (this.gauge.address === this.curve.constants.ZERO_ADDRESS)
             throw Error(`${this.name} doesn't have gauge`);
-        return !findAbiFunction(curve.contracts[this.gauge.address].abi, 'inflation_rate')
+        return !findAbiFunction(this.curve.contracts[this.gauge.address].abi, 'inflation_rate')
             .find((func) => ['', 'uint256'].includes(func.inputs.map((a) => `${a.type}`).join(',')));
     }
     _pureCalcLpTokenAmount(_amounts_1) {
         return __awaiter(this, arguments, void 0, function* (_amounts, isDeposit = true, useUnderlying = true) {
             const calcContractAddress = this.isMeta && useUnderlying ? this.zap : this.address;
             const N_coins = useUnderlying ? this.underlyingCoins.length : this.wrappedCoins.length;
-            const contract = curve.contracts[calcContractAddress].contract;
+            const contract = this.curve.contracts[calcContractAddress].contract;
             if (this.isMetaFactory && useUnderlying) {
                 if (`calc_token_amount(address,uint256[${N_coins}],bool)` in contract) {
-                    return yield contract.calc_token_amount(this.address, _amounts, isDeposit, curve.constantOptions);
+                    return yield contract.calc_token_amount(this.address, _amounts, isDeposit, this.curve.constantOptions);
                 }
-                return yield contract.calc_token_amount(this.address, _amounts, curve.constantOptions);
+                return yield contract.calc_token_amount(this.address, _amounts, this.curve.constantOptions);
             }
             if (`calc_token_amount(uint256[${N_coins}],bool)` in contract) {
-                return yield contract.calc_token_amount(_amounts, isDeposit, curve.constantOptions);
+                return yield contract.calc_token_amount(_amounts, isDeposit, this.curve.constantOptions);
             }
-            return yield contract.calc_token_amount(_amounts, curve.constantOptions);
+            return yield contract.calc_token_amount(_amounts, this.curve.constantOptions);
         });
     }
     calcLpTokenAmount(amounts_1) {
@@ -610,7 +610,7 @@ export class PoolTemplate extends CorePool {
             }
             const _underlyingAmounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
             const _expected = yield this._calcLpTokenAmount(_underlyingAmounts, isDeposit, true);
-            return curve.formatUnits(_expected);
+            return this.curve.formatUnits(_expected);
         });
     }
     calcLpTokenAmountWrapped(amounts_1) {
@@ -623,7 +623,7 @@ export class PoolTemplate extends CorePool {
             }
             const _amounts = amounts.map((amount, i) => parseUnits(amount, this.wrappedDecimals[i]));
             const _expected = yield this._calcLpTokenAmount(_amounts, isDeposit, false);
-            return curve.formatUnits(_expected);
+            return this.curve.formatUnits(_expected);
         });
     }
     // ---------------- DEPOSIT ----------------
@@ -635,13 +635,13 @@ export class PoolTemplate extends CorePool {
             if (this.isCrypto) {
                 const decimals = this.isMeta ? this.wrappedDecimals : this.underlyingDecimals;
                 if (decimals.length === 2) {
-                    const priceScaleBN = toBN(yield curve.contracts[this.address].contract.price_scale(curve.constantOptions));
+                    const priceScaleBN = toBN(yield this.curve.contracts[this.address].contract.price_scale(this.curve.constantOptions));
                     return [_cutZeros(amount1BN.toFixed(decimals[0])), _cutZeros(amount1BN.div(priceScaleBN).toFixed(decimals[1]))];
                 }
                 else if (decimals.length === 3) {
-                    const priceScaleBN = (yield curve.multicallProvider.all([
-                        curve.contracts[this.address].multicallContract.price_scale(0),
-                        curve.contracts[this.address].multicallContract.price_scale(1),
+                    const priceScaleBN = (yield this.curve.multicallProvider.all([
+                        this.curve.contracts[this.address].multicallContract.price_scale(0),
+                        this.curve.contracts[this.address].multicallContract.price_scale(1),
                     ])).map((_p) => toBN(_p));
                     return [
                         _cutZeros(amount1BN.toFixed(decimals[0])),
@@ -654,7 +654,7 @@ export class PoolTemplate extends CorePool {
             else {
                 const amounts = [_cutZeros(amount1BN.toFixed(this.wrappedDecimals[0]))];
                 if (this.isMeta && useUnderlying) {
-                    const basePool = new PoolTemplate(this.basePool);
+                    const basePool = new PoolTemplate(this.basePool, this.curve);
                     const basePoolBalancesBN = (yield basePool.stats.underlyingBalances()).map(BN);
                     const totalBN = basePoolBalancesBN.reduce((a, b) => a.plus(b));
                     for (let i = 1; i < this.underlyingDecimals.length; i++) {
@@ -707,18 +707,18 @@ export class PoolTemplate extends CorePool {
     depositBonus(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
             const amountsBN = amounts.map(BN);
-            let pricesBN = [];
-            const multicallContract = curve.contracts[this.address].multicallContract;
+            let pricesBN;
+            const multicallContract = this.curve.contracts[this.address].multicallContract;
             if (this.isCrypto || this.id === 'wsteth') {
-                if (curve.isLiteChain) {
+                if (this.curve.isLiteChain) {
                     const prices = this.id.includes('twocrypto')
                         ? [
                             1,
-                            Number(yield curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
+                            Number(yield this.curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
                         ]
                         : [
                             1,
-                            ...(yield curve.multicallProvider.all([
+                            ...(yield this.curve.multicallProvider.all([
                                 multicallContract.price_oracle(0),
                                 multicallContract.price_oracle(1),
                             ])).map((value) => Number(value) / (Math.pow(10, 18))),
@@ -741,17 +741,17 @@ export class PoolTemplate extends CorePool {
     }
     depositIsApproved(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield hasAllowance(this.underlyingCoinAddresses, amounts, curve.signerAddress, this.zap || this.address);
+            return yield hasAllowance.call(this.curve, this.underlyingCoinAddresses, amounts, this.curve.signerAddress, this.zap || this.address);
         });
     }
     depositApproveEstimateGas(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield ensureAllowanceEstimateGas(this.underlyingCoinAddresses, amounts, this.zap || this.address);
+            return yield ensureAllowanceEstimateGas.call(this.curve, this.underlyingCoinAddresses, amounts, this.zap || this.address);
         });
     }
     depositApprove(amounts_1) {
         return __awaiter(this, arguments, void 0, function* (amounts, isMax = true) {
-            return yield ensureAllowance(this.underlyingCoinAddresses, amounts, this.zap || this.address, isMax);
+            return yield ensureAllowance.call(this.curve, this.underlyingCoinAddresses, amounts, this.zap || this.address, isMax);
         });
     }
     // OVERRIDE
@@ -796,7 +796,7 @@ export class PoolTemplate extends CorePool {
             if (this.isFake) {
                 throw Error(`depositWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
             }
-            return yield hasAllowance(this.wrappedCoinAddresses, amounts, curve.signerAddress, this.address);
+            return yield hasAllowance.call(this.curve, this.wrappedCoinAddresses, amounts, this.curve.signerAddress, this.address);
         });
     }
     depositWrappedApproveEstimateGas(amounts) {
@@ -804,7 +804,7 @@ export class PoolTemplate extends CorePool {
             if (this.isFake) {
                 throw Error(`depositWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
             }
-            return yield ensureAllowanceEstimateGas(this.wrappedCoinAddresses, amounts, this.address);
+            return yield ensureAllowanceEstimateGas.call(this.curve, this.wrappedCoinAddresses, amounts, this.address);
         });
     }
     depositWrappedApprove(amounts) {
@@ -812,7 +812,7 @@ export class PoolTemplate extends CorePool {
             if (this.isFake) {
                 throw Error(`depositWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
             }
-            return yield ensureAllowance(this.wrappedCoinAddresses, amounts, this.address);
+            return yield ensureAllowance.call(this.curve, this.wrappedCoinAddresses, amounts, this.address);
         });
     }
     // OVERRIDE
@@ -830,77 +830,77 @@ export class PoolTemplate extends CorePool {
     // ---------------- STAKING ----------------
     stakeIsApproved(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`stakeIsApproved method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            return yield hasAllowance([this.lpToken], [lpTokenAmount], curve.signerAddress, this.gauge.address);
+            return yield hasAllowance.call(this.curve, [this.lpToken], [lpTokenAmount], this.curve.signerAddress, this.gauge.address);
         });
     }
     stakeApproveEstimateGas(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`stakeApproveEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            return yield ensureAllowanceEstimateGas([this.lpToken], [lpTokenAmount], this.gauge.address);
+            return yield ensureAllowanceEstimateGas.call(this.curve, [this.lpToken], [lpTokenAmount], this.gauge.address);
         });
     }
     stakeApprove(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`stakeApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            return yield ensureAllowance([this.lpToken], [lpTokenAmount], this.gauge.address);
+            return yield ensureAllowance.call(this.curve, [this.lpToken], [lpTokenAmount], this.gauge.address);
         });
     }
     stakeEstimateGas(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`stakeEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             const _lpTokenAmount = parseUnits(lpTokenAmount);
-            return smartNumber(yield curve.contracts[this.gauge.address].contract.deposit.estimateGas(_lpTokenAmount, curve.constantOptions));
+            return smartNumber(yield this.curve.contracts[this.gauge.address].contract.deposit.estimateGas(_lpTokenAmount, this.curve.constantOptions));
         });
     }
     stake(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`stake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             const _lpTokenAmount = parseUnits(lpTokenAmount);
-            yield _ensureAllowance([this.lpToken], [_lpTokenAmount], this.gauge.address);
-            yield curve.updateFeeData();
-            const gasLimit = mulBy1_3(DIGas(yield curve.contracts[this.gauge.address].contract.deposit.estimateGas(_lpTokenAmount, curve.constantOptions)));
-            return (yield curve.contracts[this.gauge.address].contract.deposit(_lpTokenAmount, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
+            yield _ensureAllowance.call(this.curve, [this.lpToken], [_lpTokenAmount], this.gauge.address);
+            yield this.curve.updateFeeData();
+            const gasLimit = mulBy1_3(DIGas(yield this.curve.contracts[this.gauge.address].contract.deposit.estimateGas(_lpTokenAmount, this.curve.constantOptions)));
+            return (yield this.curve.contracts[this.gauge.address].contract.deposit(_lpTokenAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     }
     unstakeEstimateGas(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`unstakeEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             const _lpTokenAmount = parseUnits(lpTokenAmount);
-            return smartNumber(yield curve.contracts[this.gauge.address].contract.withdraw.estimateGas(_lpTokenAmount, curve.constantOptions));
+            return smartNumber(yield this.curve.contracts[this.gauge.address].contract.withdraw.estimateGas(_lpTokenAmount, this.curve.constantOptions));
         });
     }
     unstake(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`unstake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             const _lpTokenAmount = parseUnits(lpTokenAmount);
-            yield curve.updateFeeData();
-            const gasLimit = DIGas((yield curve.contracts[this.gauge.address].contract.withdraw.estimateGas(_lpTokenAmount, curve.constantOptions))) * curve.parseUnits("200", 0) / curve.parseUnits("100", 0);
-            return (yield curve.contracts[this.gauge.address].contract.withdraw(_lpTokenAmount, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
+            yield this.curve.updateFeeData();
+            const gasLimit = DIGas((yield this.curve.contracts[this.gauge.address].contract.withdraw.estimateGas(_lpTokenAmount, this.curve.constantOptions))) * this.curve.parseUnits("200", 0) / this.curve.parseUnits("100", 0);
+            return (yield this.curve.contracts[this.gauge.address].contract.withdraw(_lpTokenAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     }
     claimableCrv() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
             if (this.rewardsOnly())
                 throw Error(`${this.name} has Rewards-Only Gauge. Use claimableRewards instead`);
-            address = address || curve.signerAddress;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
-            return curve.formatUnits(yield curve.contracts[this.gauge.address].contract.claimable_tokens(address, curve.constantOptions));
+            return this.curve.formatUnits(yield this.curve.contracts[this.gauge.address].contract.claimable_tokens(address, this.curve.constantOptions));
         });
     }
     claimCrvEstimateGas() {
@@ -909,9 +909,9 @@ export class PoolTemplate extends CorePool {
                 throw Error(`${this.name} has Rewards-Only Gauge. Use claimRewards instead`);
             let isOldFactory = false;
             let contract;
-            if (curve.chainId !== 1) {
-                if (curve.constants.ALIASES.child_gauge_factory_old && curve.constants.ALIASES.child_gauge_factory_old !== curve.constants.ZERO_ADDRESS) {
-                    const oldFactoryContract = curve.contracts[curve.constants.ALIASES.child_gauge_factory_old].contract;
+            if (this.curve.chainId !== 1) {
+                if (this.curve.constants.ALIASES.child_gauge_factory_old && this.curve.constants.ALIASES.child_gauge_factory_old !== this.curve.constants.ZERO_ADDRESS) {
+                    const oldFactoryContract = this.curve.contracts[this.curve.constants.ALIASES.child_gauge_factory_old].contract;
                     const gaugeAddress = yield oldFactoryContract.get_gauge_from_lp_token(this.lpToken);
                     isOldFactory = gaugeAddress.toLowerCase() === this.gauge.address.toLowerCase();
                     if (isOldFactory) {
@@ -920,18 +920,18 @@ export class PoolTemplate extends CorePool {
                 }
             }
             if (!isOldFactory) {
-                contract = curve.chainId === 1 ?
-                    curve.contracts[curve.constants.ALIASES.minter].contract :
-                    curve.contracts[curve.constants.ALIASES.child_gauge_factory].contract;
+                contract = this.curve.chainId === 1 ?
+                    this.curve.contracts[this.curve.constants.ALIASES.minter].contract :
+                    this.curve.contracts[this.curve.constants.ALIASES.child_gauge_factory].contract;
             }
             if (!contract) {
                 throw new Error("Failed to find the correct contract for estimating gas");
             }
-            if (curve.chainId === 1) {
-                return Number(yield contract.mint.estimateGas(this.gauge.address, curve.constantOptions));
+            if (this.curve.chainId === 1) {
+                return Number(yield contract.mint.estimateGas(this.gauge.address, this.curve.constantOptions));
             }
             else {
-                return smartNumber(yield contract.mint.estimateGas(this.gauge.address, curve.constantOptions));
+                return smartNumber(yield contract.mint.estimateGas(this.gauge.address, this.curve.constantOptions));
             }
         });
     }
@@ -941,9 +941,9 @@ export class PoolTemplate extends CorePool {
                 throw Error(`${this.name} has Rewards-Only Gauge. Use claimRewards instead`);
             let isOldFactory = false;
             let contract;
-            if (curve.chainId !== 1) {
-                if (curve.constants.ALIASES.child_gauge_factory_old && curve.constants.ALIASES.child_gauge_factory_old !== curve.constants.ZERO_ADDRESS) {
-                    const oldFactoryContract = curve.contracts[curve.constants.ALIASES.child_gauge_factory_old].contract;
+            if (this.curve.chainId !== 1) {
+                if (this.curve.constants.ALIASES.child_gauge_factory_old && this.curve.constants.ALIASES.child_gauge_factory_old !== this.curve.constants.ZERO_ADDRESS) {
+                    const oldFactoryContract = this.curve.contracts[this.curve.constants.ALIASES.child_gauge_factory_old].contract;
                     const gaugeAddress = yield oldFactoryContract.get_gauge_from_lp_token(this.lpToken);
                     isOldFactory = gaugeAddress.toLowerCase() === this.gauge.address.toLowerCase();
                     if (isOldFactory) {
@@ -952,48 +952,48 @@ export class PoolTemplate extends CorePool {
                 }
             }
             if (!isOldFactory) {
-                contract = curve.chainId === 1 ?
-                    curve.contracts[curve.constants.ALIASES.minter].contract :
-                    curve.contracts[curve.constants.ALIASES.child_gauge_factory].contract;
+                contract = this.curve.chainId === 1 ?
+                    this.curve.contracts[this.curve.constants.ALIASES.minter].contract :
+                    this.curve.contracts[this.curve.constants.ALIASES.child_gauge_factory].contract;
             }
             if (!contract) {
                 throw new Error("Failed to find the correct contract for minting");
             }
-            yield curve.updateFeeData();
-            const gasLimit = mulBy1_3(DIGas(yield contract.mint.estimateGas(this.gauge.address, curve.constantOptions)));
-            return (yield contract.mint(this.gauge.address, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
+            yield this.curve.updateFeeData();
+            const gasLimit = mulBy1_3(DIGas(yield contract.mint.estimateGas(this.gauge.address, this.curve.constantOptions)));
+            return (yield contract.mint(this.gauge.address, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     }
     // TODO 1. Fix aave and saave error
     claimableRewards() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`claimableRewards method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            address = address || curve.signerAddress;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             const rewardTokens = yield this.rewardTokens();
             const rewards = [];
             if ('claimable_reward(address,address)' in gaugeContract) {
                 for (const rewardToken of rewardTokens) {
-                    const _amount = yield gaugeContract.claimable_reward(address, rewardToken.token, curve.constantOptions);
+                    const _amount = yield gaugeContract.claimable_reward(address, rewardToken.token, this.curve.constantOptions);
                     rewards.push({
                         token: rewardToken.token,
                         symbol: rewardToken.symbol,
-                        amount: curve.formatUnits(_amount, rewardToken.decimals),
+                        amount: this.curve.formatUnits(_amount, rewardToken.decimals),
                     });
                 }
             }
             else if ('claimable_reward(address)' in gaugeContract && rewardTokens.length > 0) { // Synthetix Gauge
                 const rewardToken = rewardTokens[0];
-                const _totalAmount = yield gaugeContract.claimable_reward(address, curve.constantOptions);
-                const _claimedAmount = yield gaugeContract.claimed_rewards_for(address, curve.constantOptions);
+                const _totalAmount = yield gaugeContract.claimable_reward(address, this.curve.constantOptions);
+                const _claimedAmount = yield gaugeContract.claimed_rewards_for(address, this.curve.constantOptions);
                 rewards.push({
                     token: rewardToken.token,
                     symbol: rewardToken.symbol,
-                    amount: curve.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
+                    amount: this.curve.formatUnits(_totalAmount.sub(_claimedAmount), rewardToken.decimals),
                 });
             }
             return rewards;
@@ -1001,32 +1001,32 @@ export class PoolTemplate extends CorePool {
     }
     claimRewardsEstimateGas() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`claimRewards method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if (!("claim_rewards()" in gaugeContract))
                 throw Error(`${this.name} pool doesn't have such method`);
-            return smartNumber(yield gaugeContract.claim_rewards.estimateGas(curve.constantOptions));
+            return smartNumber(yield gaugeContract.claim_rewards.estimateGas(this.curve.constantOptions));
         });
     }
     claimRewards() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`claimRewards method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if (!("claim_rewards()" in gaugeContract))
                 throw Error(`${this.name} pool doesn't have such method`);
-            yield curve.updateFeeData();
-            const gasLimit = mulBy1_3(DIGas(yield gaugeContract.claim_rewards.estimateGas(curve.constantOptions)));
-            return (yield gaugeContract.claim_rewards(Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
+            yield this.curve.updateFeeData();
+            const gasLimit = mulBy1_3(DIGas(yield gaugeContract.claim_rewards.estimateGas(this.curve.constantOptions)));
+            return (yield gaugeContract.claim_rewards(Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     }
     // ---------------- DEPOSIT & STAKE ----------------
     depositAndStakeExpected(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeExpected method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             return yield this.depositExpected(amounts);
@@ -1034,7 +1034,7 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeBonus(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeBonus method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             return yield this.depositBonus(amounts);
@@ -1042,13 +1042,13 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeIsApproved(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeIsApproved method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            const coinsAllowance = yield hasAllowance(this.underlyingCoinAddresses, amounts, curve.signerAddress, curve.constants.ALIASES.deposit_and_stake);
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const coinsAllowance = yield hasAllowance.call(this.curve, this.underlyingCoinAddresses, amounts, this.curve.signerAddress, this.curve.constants.ALIASES.deposit_and_stake);
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if ('approved_to_deposit' in gaugeContract) {
-                const gaugeAllowance = yield gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+                const gaugeAllowance = yield gaugeContract.approved_to_deposit(this.curve.constants.ALIASES.deposit_and_stake, this.curve.signerAddress, this.curve.constantOptions);
                 return coinsAllowance && gaugeAllowance;
             }
             return coinsAllowance;
@@ -1056,15 +1056,15 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeApproveEstimateGas(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            const approveCoinsGas = yield ensureAllowanceEstimateGas(this.underlyingCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const approveCoinsGas = yield ensureAllowanceEstimateGas.call(this.curve, this.underlyingCoinAddresses, amounts, this.curve.constants.ALIASES.deposit_and_stake);
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if ('approved_to_deposit' in gaugeContract) {
-                const gaugeAllowance = yield gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+                const gaugeAllowance = yield gaugeContract.approved_to_deposit(this.curve.constants.ALIASES.deposit_and_stake, this.curve.signerAddress, this.curve.constantOptions);
                 if (!gaugeAllowance) {
-                    const approveGaugeGas = smartNumber(yield gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
+                    const approveGaugeGas = smartNumber(yield gaugeContract.set_approve_deposit.estimateGas(this.curve.constants.ALIASES.deposit_and_stake, true, this.curve.constantOptions));
                     if (Array.isArray(approveCoinsGas) && Array.isArray(approveGaugeGas)) {
                         return [approveCoinsGas[0] + approveGaugeGas[0], approveCoinsGas[1] + approveGaugeGas[1]];
                     }
@@ -1078,16 +1078,16 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeApprove(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            const approveCoinsTx = yield ensureAllowance(this.underlyingCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const approveCoinsTx = yield ensureAllowance.call(this.curve, this.underlyingCoinAddresses, amounts, this.curve.constants.ALIASES.deposit_and_stake);
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if ('approved_to_deposit' in gaugeContract) {
-                const gaugeAllowance = yield gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+                const gaugeAllowance = yield gaugeContract.approved_to_deposit(this.curve.constants.ALIASES.deposit_and_stake, this.curve.signerAddress, this.curve.constantOptions);
                 if (!gaugeAllowance) {
-                    const gasLimit = mulBy1_3(yield gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
-                    const approveGaugeTx = (yield gaugeContract.set_approve_deposit(curve.constants.ALIASES.deposit_and_stake, true, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
+                    const gasLimit = mulBy1_3(yield gaugeContract.set_approve_deposit.estimateGas(this.curve.constants.ALIASES.deposit_and_stake, true, this.curve.constantOptions));
+                    const approveGaugeTx = (yield gaugeContract.set_approve_deposit(this.curve.constants.ALIASES.deposit_and_stake, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
                     return [...approveCoinsTx, approveGaugeTx];
                 }
             }
@@ -1096,7 +1096,7 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeEstimateGas(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             return yield this._depositAndStake(amounts, 1, true, true);
@@ -1104,7 +1104,7 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStake(amounts_1) {
         return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             return yield this._depositAndStake(amounts, slippage, true, false);
@@ -1113,7 +1113,7 @@ export class PoolTemplate extends CorePool {
     // ---------------- DEPOSIT & STAKE WRAPPED ----------------
     depositAndStakeWrappedExpected(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrappedExpected method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
@@ -1123,7 +1123,7 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeWrappedBonus(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrappedBonus method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
@@ -1133,15 +1133,15 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeWrappedIsApproved(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
                 throw Error(`depositAndStakeWrappedIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
-            const coinsAllowance = yield hasAllowance(this.wrappedCoinAddresses, amounts, curve.signerAddress, curve.constants.ALIASES.deposit_and_stake);
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const coinsAllowance = yield hasAllowance.call(this.curve, this.wrappedCoinAddresses, amounts, this.curve.signerAddress, this.curve.constants.ALIASES.deposit_and_stake);
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if ('approved_to_deposit' in gaugeContract) {
-                const gaugeAllowance = yield gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+                const gaugeAllowance = yield gaugeContract.approved_to_deposit(this.curve.constants.ALIASES.deposit_and_stake, this.curve.signerAddress, this.curve.constantOptions);
                 return coinsAllowance && gaugeAllowance;
             }
             return coinsAllowance;
@@ -1149,17 +1149,17 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeWrappedApproveEstimateGas(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
                 throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
-            const approveCoinsGas = yield ensureAllowanceEstimateGas(this.wrappedCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const approveCoinsGas = yield ensureAllowanceEstimateGas.call(this.curve, this.wrappedCoinAddresses, amounts, this.curve.constants.ALIASES.deposit_and_stake);
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if ('approved_to_deposit' in gaugeContract) {
-                const gaugeAllowance = yield gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+                const gaugeAllowance = yield gaugeContract.approved_to_deposit(this.curve.constants.ALIASES.deposit_and_stake, this.curve.signerAddress, this.curve.constantOptions);
                 if (!gaugeAllowance) {
-                    const approveGaugeGas = Number(yield gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
+                    const approveGaugeGas = Number(yield gaugeContract.set_approve_deposit.estimateGas(this.curve.constants.ALIASES.deposit_and_stake, true, this.curve.constantOptions));
                     if (Array.isArray(approveCoinsGas) && Array.isArray(approveGaugeGas)) {
                         return [approveCoinsGas[0] + approveGaugeGas[0], approveCoinsGas[1] + approveGaugeGas[1]];
                     }
@@ -1173,18 +1173,18 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeWrappedApprove(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
                 throw Error(`depositAndStakeWrappedApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
-            const approveCoinsTx = yield ensureAllowance(this.wrappedCoinAddresses, amounts, curve.constants.ALIASES.deposit_and_stake);
-            const gaugeContract = curve.contracts[this.gauge.address].contract;
+            const approveCoinsTx = yield ensureAllowance.call(this.curve, this.wrappedCoinAddresses, amounts, this.curve.constants.ALIASES.deposit_and_stake);
+            const gaugeContract = this.curve.contracts[this.gauge.address].contract;
             if ('approved_to_deposit' in gaugeContract) {
-                const gaugeAllowance = yield gaugeContract.approved_to_deposit(curve.constants.ALIASES.deposit_and_stake, curve.signerAddress, curve.constantOptions);
+                const gaugeAllowance = yield gaugeContract.approved_to_deposit(this.curve.constants.ALIASES.deposit_and_stake, this.curve.signerAddress, this.curve.constantOptions);
                 if (!gaugeAllowance) {
-                    const gasLimit = mulBy1_3(yield gaugeContract.set_approve_deposit.estimateGas(curve.constants.ALIASES.deposit_and_stake, true, curve.constantOptions));
-                    const approveGaugeTx = (yield gaugeContract.set_approve_deposit(curve.constants.ALIASES.deposit_and_stake, true, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
+                    const gasLimit = mulBy1_3(yield gaugeContract.set_approve_deposit.estimateGas(this.curve.constants.ALIASES.deposit_and_stake, true, this.curve.constantOptions));
+                    const approveGaugeTx = (yield gaugeContract.set_approve_deposit(this.curve.constants.ALIASES.deposit_and_stake, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
                     return [...approveCoinsTx, approveGaugeTx];
                 }
             }
@@ -1193,7 +1193,7 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeWrappedEstimateGas(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
@@ -1203,7 +1203,7 @@ export class PoolTemplate extends CorePool {
     }
     depositAndStakeWrapped(amounts_1) {
         return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
-            if (this.gauge.address === curve.constants.ZERO_ADDRESS) {
+            if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
@@ -1239,34 +1239,28 @@ export class PoolTemplate extends CorePool {
                 }
             }
             const _amounts = amounts.map((amount, i) => parseUnits(amount, decimals[i]));
-            const contract = curve.contracts[curve.constants.ALIASES.deposit_and_stake].contract;
+            const contract = this.curve.contracts[this.curve.constants.ALIASES.deposit_and_stake].contract;
             const useUnderlying = isUnderlying && (this.isLending || (this.isCrypto && !this.isPlain)) && (!this.zap || this.id == 'avaxcrypto');
-            const useDynarray = (!this.isCrypto && this.isNg && this.isPlain) || (isUnderlying && this.isMeta && (new PoolTemplate(this.basePool)).isNg);
+            const useDynarray = (!this.isCrypto && this.isNg && this.isPlain) || (isUnderlying && this.isMeta && (new PoolTemplate(this.basePool, this.curve)).isNg);
             const _expectedLpTokenAmount = isUnderlying ?
-                curve.parseUnits(yield this.depositAndStakeExpected(amounts)) :
-                curve.parseUnits(yield this.depositAndStakeWrappedExpected(amounts));
+                this.curve.parseUnits(yield this.depositAndStakeExpected(amounts)) :
+                this.curve.parseUnits(yield this.depositAndStakeWrappedExpected(amounts));
             const minAmountBN = toBN(_expectedLpTokenAmount).times(100 - slippage).div(100);
             const _minMintAmount = fromBN(minAmountBN);
             const ethIndex = getEthIndex(coinAddresses);
-            const value = _amounts[ethIndex] || curve.parseUnits("0");
-            let _gas = BigInt(0);
-            if (OLD_CHAINS.includes(curve.chainId)) {
-                _gas = (yield contract.deposit_and_stake.estimateGas(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, // <--- DIFFERENCE
-                useDynarray, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, curve.constantOptions), { value })));
-            }
-            else {
-                _gas = (yield contract.deposit_and_stake.estimateGas(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useDynarray, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, curve.constantOptions), { value })));
-            }
+            const value = _amounts[ethIndex] || this.curve.parseUnits("0");
+            const _gas = OLD_CHAINS.includes(this.curve.chainId) ? (yield contract.deposit_and_stake.estimateGas(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, // <--- DIFFERENCE
+            useDynarray, this.isMetaFactory && isUnderlying ? this.address : this.curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, this.curve.constantOptions), { value }))) : (yield contract.deposit_and_stake.estimateGas(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useDynarray, this.isMetaFactory && isUnderlying ? this.address : this.curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, this.curve.constantOptions), { value })));
             if (estimateGas)
                 return smartNumber(_gas);
-            yield curve.updateFeeData();
-            const gasLimit = DIGas(_gas) * curve.parseUnits("200", 0) / curve.parseUnits("100", 0);
-            if (OLD_CHAINS.includes(curve.chainId)) {
+            yield this.curve.updateFeeData();
+            const gasLimit = DIGas(_gas) * this.curve.parseUnits("200", 0) / this.curve.parseUnits("100", 0);
+            if (OLD_CHAINS.includes(this.curve.chainId)) {
                 return (yield contract.deposit_and_stake(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useUnderlying, // <--- DIFFERENCE
-                useDynarray, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, curve.options), { gasLimit, value }))).hash;
+                useDynarray, this.isMetaFactory && isUnderlying ? this.address : this.curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
             }
             else {
-                return (yield contract.deposit_and_stake(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useDynarray, this.isMetaFactory && isUnderlying ? this.address : curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, curve.options), { gasLimit, value }))).hash;
+                return (yield contract.deposit_and_stake(depositAddress, this.lpToken, this.gauge.address, coins.length, coinAddresses, _amounts, _minMintAmount, useDynarray, this.isMetaFactory && isUnderlying ? this.address : this.curve.constants.ZERO_ADDRESS, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
             }
         });
     }
@@ -1281,21 +1275,21 @@ export class PoolTemplate extends CorePool {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
                 return true;
-            return yield hasAllowance([this.lpToken], [lpTokenAmount], curve.signerAddress, this.zap);
+            return yield hasAllowance.call(this.curve, [this.lpToken], [lpTokenAmount], this.curve.signerAddress, this.zap);
         });
     }
     withdrawApproveEstimateGas(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
                 return 0;
-            return yield ensureAllowanceEstimateGas([this.lpToken], [lpTokenAmount], this.zap);
+            return yield ensureAllowanceEstimateGas.call(this.curve, [this.lpToken], [lpTokenAmount], this.zap);
         });
     }
     withdrawApprove(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
                 return [];
-            return yield ensureAllowance([this.lpToken], [lpTokenAmount], this.zap);
+            return yield ensureAllowance.call(this.curve, [this.lpToken], [lpTokenAmount], this.zap);
         });
     }
     // OVERRIDE
@@ -1340,17 +1334,17 @@ export class PoolTemplate extends CorePool {
     withdrawImbalanceBonus(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
             let pricesBN = [];
-            const multicallContract = curve.contracts[this.address].multicallContract;
+            const multicallContract = this.curve.contracts[this.address].multicallContract;
             if (this.isCrypto || this.id === 'wsteth') {
-                if (curve.isLiteChain) {
+                if (this.curve.isLiteChain) {
                     const prices = this.id.includes('twocrypto')
                         ? [
                             1,
-                            Number(yield curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
+                            Number(yield this.curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
                         ]
                         : [
                             1,
-                            ...(yield curve.multicallProvider.all([
+                            ...(yield this.curve.multicallProvider.all([
                                 multicallContract.price_oracle(0),
                                 multicallContract.price_oracle(1),
                             ])).map((value) => Number(value) / (Math.pow(10, 18))),
@@ -1377,8 +1371,8 @@ export class PoolTemplate extends CorePool {
                 throw Error(`withdrawImbalanceIsApproved method doesn't exist for pool ${this.name} (id: ${this.name})`);
             if (this.zap) {
                 const _amounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
-                const _maxBurnAmount = (yield this._calcLpTokenAmount(_amounts, false)) * curve.parseUnits("101", 0) / curve.parseUnits("100", 0);
-                return yield hasAllowance([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], curve.signerAddress, this.zap);
+                const _maxBurnAmount = (yield this._calcLpTokenAmount(_amounts, false)) * this.curve.parseUnits("101", 0) / this.curve.parseUnits("100", 0);
+                return yield hasAllowance.call(this.curve, [this.lpToken], [this.curve.formatUnits(_maxBurnAmount, 18)], this.curve.signerAddress, this.zap);
             }
             return true;
         });
@@ -1389,8 +1383,8 @@ export class PoolTemplate extends CorePool {
                 throw Error(`withdrawImbalanceApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
             if (this.zap) {
                 const _amounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
-                const _maxBurnAmount = (yield this._calcLpTokenAmount(_amounts, false)) * curve.parseUnits("101", 0) / curve.parseUnits("100", 0);
-                return yield ensureAllowanceEstimateGas([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], this.zap);
+                const _maxBurnAmount = (yield this._calcLpTokenAmount(_amounts, false)) * this.curve.parseUnits("101", 0) / this.curve.parseUnits("100", 0);
+                return yield ensureAllowanceEstimateGas.call(this.curve, [this.lpToken], [this.curve.formatUnits(_maxBurnAmount, 18)], this.zap);
             }
             return 0;
         });
@@ -1401,8 +1395,8 @@ export class PoolTemplate extends CorePool {
                 throw Error(`withdrawImbalanceApprove method doesn't exist for pool ${this.name} (id: ${this.name})`);
             if (this.zap) {
                 const _amounts = amounts.map((amount, i) => parseUnits(amount, this.underlyingDecimals[i]));
-                const _maxBurnAmount = (yield this._calcLpTokenAmount(_amounts, false)) * curve.parseUnits("101", 0) / curve.parseUnits("100", 0);
-                return yield ensureAllowance([this.lpToken], [curve.formatUnits(_maxBurnAmount, 18)], this.zap);
+                const _maxBurnAmount = (yield this._calcLpTokenAmount(_amounts, false)) * this.curve.parseUnits("101", 0) / this.curve.parseUnits("100", 0);
+                return yield ensureAllowance.call(this.curve, [this.lpToken], [this.curve.formatUnits(_maxBurnAmount, 18)], this.zap);
             }
             return [];
         });
@@ -1461,23 +1455,23 @@ export class PoolTemplate extends CorePool {
             const i = this._getCoinIdx(coin);
             const _lpTokenAmount = parseUnits(lpTokenAmount);
             const _expected = yield this._withdrawOneCoinExpected(_lpTokenAmount, i);
-            return curve.formatUnits(_expected, this.underlyingDecimals[i]);
+            return this.curve.formatUnits(_expected, this.underlyingDecimals[i]);
         });
     }
     withdrawOneCoinBonus(lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function* () {
             let pricesBN = [];
-            const multicallContract = curve.contracts[this.address].multicallContract;
+            const multicallContract = this.curve.contracts[this.address].multicallContract;
             if (this.isCrypto || this.id === 'wsteth') {
-                if (curve.isLiteChain) {
+                if (this.curve.isLiteChain) {
                     const prices = this.id.includes('twocrypto')
                         ? [
                             1,
-                            Number(yield curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
+                            Number(yield this.curve.contracts[this.address].contract.price_oracle()) / (Math.pow(10, 18)),
                         ]
                         : [
                             1,
-                            ...(yield curve.multicallProvider.all([
+                            ...(yield this.curve.multicallProvider.all([
                                 multicallContract.price_oracle(0),
                                 multicallContract.price_oracle(1),
                             ])).map((value) => Number(value) / (Math.pow(10, 18))),
@@ -1503,21 +1497,21 @@ export class PoolTemplate extends CorePool {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
                 return true;
-            return yield hasAllowance([this.lpToken], [lpTokenAmount], curve.signerAddress, this.zap);
+            return yield hasAllowance.call(this.curve, [this.lpToken], [lpTokenAmount], this.curve.signerAddress, this.zap);
         });
     }
     withdrawOneCoinApproveEstimateGas(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
                 return 0;
-            return yield ensureAllowanceEstimateGas([this.lpToken], [lpTokenAmount], this.zap);
+            return yield ensureAllowanceEstimateGas.call(this.curve, [this.lpToken], [lpTokenAmount], this.zap);
         });
     }
     withdrawOneCoinApprove(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
                 return [];
-            return yield ensureAllowance([this.lpToken], [lpTokenAmount], this.zap);
+            return yield ensureAllowance.call(this.curve, [this.lpToken], [lpTokenAmount], this.zap);
         });
     }
     // OVERRIDE
@@ -1544,7 +1538,7 @@ export class PoolTemplate extends CorePool {
             const i = this._getCoinIdx(coin, false);
             const _lpTokenAmount = parseUnits(lpTokenAmount);
             const _expected = yield this._withdrawOneCoinWrappedExpected(_lpTokenAmount, i);
-            return curve.formatUnits(_expected, this.wrappedDecimals[i]);
+            return this.curve.formatUnits(_expected, this.wrappedDecimals[i]);
         });
     }
     withdrawOneCoinWrappedBonus(lpTokenAmount, coin) {
@@ -1582,7 +1576,7 @@ export class PoolTemplate extends CorePool {
     }
     userBalances() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
-            address = address || curve.signerAddress;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
             const lpTotalBalanceBN = yield this._userLpTotalBalance(address);
@@ -1593,7 +1587,7 @@ export class PoolTemplate extends CorePool {
     }
     userWrappedBalances() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
-            address = address || curve.signerAddress;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
             const lpTotalBalanceBN = yield this._userLpTotalBalance(address);
@@ -1605,7 +1599,7 @@ export class PoolTemplate extends CorePool {
     userLiquidityUSD() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
             const lpBalanceBN = yield this._userLpTotalBalance(address);
-            const lpPrice = yield _getUsdRate(this.lpToken);
+            const lpPrice = yield _getUsdRate.call(this.curve, this.lpToken);
             return lpBalanceBN.times(lpPrice).toFixed(8);
         });
     }
@@ -1630,8 +1624,8 @@ export class PoolTemplate extends CorePool {
     }
     userShare() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
-            const withGauge = this.gauge.address !== curve.constants.ZERO_ADDRESS;
-            address = address || curve.signerAddress;
+            const withGauge = this.gauge.address !== this.curve.constants.ZERO_ADDRESS;
+            address = address || this.curve.signerAddress;
             if (!address)
                 throw Error("Need to connect wallet or pass address into args");
             const userLpBalance = yield this.wallet.lpTokenBalances(address);
@@ -1640,13 +1634,13 @@ export class PoolTemplate extends CorePool {
                 userLpTotalBalanceBN = userLpTotalBalanceBN.plus(BN(userLpBalance.gauge));
             let totalLp, gaugeLp;
             if (withGauge) {
-                [totalLp, gaugeLp] = (yield curve.multicallProvider.all([
-                    curve.contracts[this.lpToken].multicallContract.totalSupply(),
-                    curve.contracts[this.gauge.address].multicallContract.totalSupply(),
-                ])).map((_supply) => curve.formatUnits(_supply));
+                [totalLp, gaugeLp] = (yield this.curve.multicallProvider.all([
+                    this.curve.contracts[this.lpToken].multicallContract.totalSupply(),
+                    this.curve.contracts[this.gauge.address].multicallContract.totalSupply(),
+                ])).map((_supply) => this.curve.formatUnits(_supply));
             }
             else {
-                totalLp = curve.formatUnits(yield curve.contracts[this.lpToken].contract.totalSupply(curve.constantOptions));
+                totalLp = this.curve.formatUnits(yield this.curve.contracts[this.lpToken].contract.totalSupply(this.curve.constantOptions));
             }
             return {
                 lpUser: userLpTotalBalanceBN.toString(),
@@ -1662,15 +1656,15 @@ export class PoolTemplate extends CorePool {
     _swapExpected(i, j, _amount) {
         return __awaiter(this, void 0, void 0, function* () {
             const contractAddress = this.isCrypto && this.isMeta ? this.zap : this.address;
-            const contract = curve.contracts[contractAddress].contract;
+            const contract = this.curve.contracts[contractAddress].contract;
             if ('get_dy_underlying' in contract) {
-                return yield contract.get_dy_underlying(i, j, _amount, curve.constantOptions);
+                return yield contract.get_dy_underlying(i, j, _amount, this.curve.constantOptions);
             }
             else {
                 if ('get_dy(address,uint256,uint256,uint256)' in contract) { // atricrypto3 based metapools
-                    return yield contract.get_dy(this.address, i, j, _amount, curve.constantOptions);
+                    return yield contract.get_dy(this.address, i, j, _amount, this.curve.constantOptions);
                 }
-                return yield contract.get_dy(i, j, _amount, curve.constantOptions);
+                return yield contract.get_dy(i, j, _amount, this.curve.constantOptions);
             }
         });
     }
@@ -1680,61 +1674,61 @@ export class PoolTemplate extends CorePool {
             const j = this._getCoinIdx(outputCoin);
             const _amount = parseUnits(amount, this.underlyingDecimals[i]);
             const _expected = yield this._swapExpected(i, j, _amount);
-            return curve.formatUnits(_expected, this.underlyingDecimals[j]);
+            return this.curve.formatUnits(_expected, this.underlyingDecimals[j]);
         });
     }
     _swapRequired(i, j, _amount, isUnderlying) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isCrypto) {
                 if (this.isNg)
-                    return yield curve.contracts[this.address].contract.get_dx(i, j, _amount, curve.constantOptions);
-                const contract = curve.contracts[curve.constants.ALIASES.crypto_calc].contract;
+                    return yield this.curve.contracts[this.address].contract.get_dx(i, j, _amount, this.curve.constantOptions);
+                const contract = this.curve.contracts[this.curve.constants.ALIASES.crypto_calc].contract;
                 if (this.isMeta && isUnderlying) {
-                    const basePool = new PoolTemplate(this.basePool);
+                    const basePool = new PoolTemplate(this.basePool, this.curve);
                     if (this.wrappedCoins.length === 3) {
-                        return yield contract.get_dx_tricrypto_meta_underlying(this.address, i, j, _amount, this.wrappedCoins.length, basePool.address, basePool.lpToken, curve.constantOptions);
+                        return yield contract.get_dx_tricrypto_meta_underlying(this.address, i, j, _amount, this.wrappedCoins.length, basePool.address, basePool.lpToken, this.curve.constantOptions);
                     }
                     if (basePool.isFake) {
-                        const secondPool = new PoolTemplate(basePool.basePool);
-                        return yield contract.get_dx_double_meta_underlying(this.address, i, j, _amount, basePool.address, basePool.zap, secondPool.address, secondPool.lpToken, curve.constantOptions);
+                        const secondPool = new PoolTemplate(basePool.basePool, this.curve);
+                        return yield contract.get_dx_double_meta_underlying(this.address, i, j, _amount, basePool.address, basePool.zap, secondPool.address, secondPool.lpToken, this.curve.constantOptions);
                     }
-                    return yield contract.get_dx_meta_underlying(this.address, i, j, _amount, this.underlyingCoins.length, basePool.address, basePool.lpToken, curve.constantOptions);
+                    return yield contract.get_dx_meta_underlying(this.address, i, j, _amount, this.underlyingCoins.length, basePool.address, basePool.lpToken, this.curve.constantOptions);
                 }
                 else {
-                    return yield contract.get_dx(this.address, i, j, _amount, this.wrappedCoins.length, curve.constantOptions);
+                    return yield contract.get_dx(this.address, i, j, _amount, this.wrappedCoins.length, this.curve.constantOptions);
                 }
             }
             else {
                 if (this.isNg) {
-                    const contract = curve.contracts[this.address].contract;
+                    const contract = this.curve.contracts[this.address].contract;
                     if (this.isMeta) {
                         if (isUnderlying) {
-                            return yield contract.get_dx_underlying(i, j, _amount, curve.constantOptions);
+                            return yield contract.get_dx_underlying(i, j, _amount, this.curve.constantOptions);
                         }
                         else {
-                            return yield contract.get_dx(i, j, _amount, curve.constantOptions);
+                            return yield contract.get_dx(i, j, _amount, this.curve.constantOptions);
                         }
                     }
                     else {
-                        return yield contract.get_dx(i, j, _amount, curve.constantOptions);
+                        return yield contract.get_dx(i, j, _amount, this.curve.constantOptions);
                     }
                 }
-                const contract = curve.contracts[curve.constants.ALIASES.stable_calc].contract;
+                const contract = this.curve.contracts[this.curve.constants.ALIASES.stable_calc].contract;
                 if (this.isMeta) {
-                    const basePool = new PoolTemplate(this.basePool);
+                    const basePool = new PoolTemplate(this.basePool, this.curve);
                     if (isUnderlying) {
-                        return yield contract.get_dx_meta_underlying(this.address, i, j, _amount, this.underlyingCoins.length, basePool.address, basePool.lpToken, curve.constantOptions);
+                        return yield contract.get_dx_meta_underlying(this.address, i, j, _amount, this.underlyingCoins.length, basePool.address, basePool.lpToken, this.curve.constantOptions);
                     }
                     else {
-                        return yield contract.get_dx_meta(this.address, i, j, _amount, this.wrappedCoins.length, basePool.address, curve.constantOptions);
+                        return yield contract.get_dx_meta(this.address, i, j, _amount, this.wrappedCoins.length, basePool.address, this.curve.constantOptions);
                     }
                 }
                 else {
                     if (isUnderlying && this.isLending) {
-                        return yield contract.get_dx_underlying(this.address, i, j, _amount, this.underlyingCoins.length, curve.constantOptions);
+                        return yield contract.get_dx_underlying(this.address, i, j, _amount, this.underlyingCoins.length, this.curve.constantOptions);
                     }
                     else {
-                        return yield contract.get_dx(this.address, i, j, _amount, this.wrappedCoins.length, curve.constantOptions);
+                        return yield contract.get_dx(this.address, i, j, _amount, this.wrappedCoins.length, this.curve.constantOptions);
                     }
                 }
             }
@@ -1746,7 +1740,7 @@ export class PoolTemplate extends CorePool {
             const j = this._getCoinIdx(outputCoin);
             const _amount = parseUnits(amount, this.underlyingDecimals[j]);
             const _required = yield this._swapRequired(i, j, _amount, true);
-            return curve.formatUnits(_required, this.underlyingDecimals[i]);
+            return this.curve.formatUnits(_required, this.underlyingDecimals[i]);
         });
     }
     // OVERRIDE
@@ -1773,27 +1767,27 @@ export class PoolTemplate extends CorePool {
         });
     }
     _swapContractAddress() {
-        return (this.isCrypto && this.isMeta) || (this.isMetaFactory && (new PoolTemplate(this.basePool).isLending)) ? this.zap : this.address;
+        return (this.isCrypto && this.isMeta) || (this.isMetaFactory && (new PoolTemplate(this.basePool, this.curve).isLending)) ? this.zap : this.address;
     }
     swapIsApproved(inputCoin, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             const contractAddress = this._swapContractAddress();
             const i = this._getCoinIdx(inputCoin);
-            return yield hasAllowance([this.underlyingCoinAddresses[i]], [amount], curve.signerAddress, contractAddress);
+            return yield hasAllowance.call(this.curve, [this.underlyingCoinAddresses[i]], [amount], this.curve.signerAddress, contractAddress);
         });
     }
     swapApproveEstimateGas(inputCoin, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             const contractAddress = this._swapContractAddress();
             const i = this._getCoinIdx(inputCoin);
-            return yield ensureAllowanceEstimateGas([this.underlyingCoinAddresses[i]], [amount], contractAddress);
+            return yield ensureAllowanceEstimateGas.call(this.curve, [this.underlyingCoinAddresses[i]], [amount], contractAddress);
         });
     }
     swapApprove(inputCoin, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             const contractAddress = this._swapContractAddress();
             const i = this._getCoinIdx(inputCoin);
-            return yield ensureAllowance([this.underlyingCoinAddresses[i]], [amount], contractAddress);
+            return yield ensureAllowance.call(this.curve, [this.underlyingCoinAddresses[i]], [amount], contractAddress);
         });
     }
     // OVERRIDE
@@ -1811,7 +1805,7 @@ export class PoolTemplate extends CorePool {
     // ---------------- SWAP WRAPPED ----------------
     _swapWrappedExpected(i, j, _amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield curve.contracts[this.address].contract.get_dy(i, j, _amount, curve.constantOptions);
+            return yield this.curve.contracts[this.address].contract.get_dy(i, j, _amount, this.curve.constantOptions);
         });
     }
     // OVERRIDE