@curvefi/api 2.66.29 → 2.66.31

package/lib/dao.js

@@ -7,372 +7,442 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { curve } from "./curve.js";
 import { Contract } from "ethers";
-import { _getAllGauges, _getDaoProposalList, _getDaoProposal } from './external-api.js';
-import { _getAddress, DIGas, ensureAllowance, ensureAllowanceEstimateGas, hasAllowance, mulBy1_3, parseUnits, smartNumber, toBN, BN, } from './utils.js';
-import feeDistributorViewABI from "./constants/abis/fee_distributor_view.json" with { type: 'json' };
+import { _getAllGauges, _getDaoProposal, _getDaoProposalList } from './external-api.js';
+import { _getAddress, BN, DIGas, ensureAllowance, ensureAllowanceEstimateGas, hasAllowance, mulBy1_3, parseUnits, smartNumber, toBN, } from './utils.js';
+import feeDistributorViewABI from "./constants/abis/fee_distributor_view.json" with { type: "json" };
 // ----------------- Refactored boosting stuff -----------------
-export const crvSupplyStats = () => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const crvContract = curve.contracts[curve.constants.ALIASES.crv].multicallContract;
-    const veContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
-    const csContract = curve.contracts[curve.constants.ALIASES.circulating_supply].multicallContract;
-    const [_circulating, _locked, _veCrv] = yield curve.multicallProvider.all([
-        csContract.circulating_supply(),
-        crvContract.balanceOf(curve.constants.ALIASES.voting_escrow),
-        veContract.totalSupply(),
-    ]);
-    return {
-        circulating: curve.formatUnits(_circulating),
-        locked: curve.formatUnits(_locked),
-        total: curve.formatUnits(_circulating + _locked),
-        veCrv: curve.formatUnits(_veCrv),
-        averageLockTime: toBN(_veCrv).div(toBN(_locked)).times(4).toFixed(4), // years
-    };
-});
-export const userCrv = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    address = _getAddress(address);
-    const _balance = yield curve.contracts[curve.constants.ALIASES.crv].contract.balanceOf(address);
-    return curve.formatUnits(_balance);
-});
-export const userVeCrv = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    address = _getAddress(address);
-    const contract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
-    const [_veCrv, _veCrvTotal, _locked] = yield curve.multicallProvider.all([
-        contract.balanceOf(address),
-        contract.totalSupply(),
-        contract.locked(address),
-    ]);
-    const _lockedCrv = _locked[0];
-    const _unlockTime = _locked[1];
-    return {
-        veCrv: curve.formatUnits(_veCrv),
-        veCrvPct: toBN(_veCrv).div(toBN(_veCrvTotal)).times(100).toString(),
-        lockedCrv: curve.formatUnits(_lockedCrv),
-        unlockTime: Number(curve.formatUnits(_unlockTime, 0)) * 1000,
-    };
-});
-export const crvLockIsApproved = (amount) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    return yield hasAllowance([curve.constants.ALIASES.crv], [amount], curve.signerAddress, curve.constants.ALIASES.voting_escrow);
-});
-export const crvLockApproveEstimateGas = (amount) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    return yield ensureAllowanceEstimateGas([curve.constants.ALIASES.crv], [amount], curve.constants.ALIASES.voting_escrow, false);
-});
-export const crvLockApprove = (amount) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    return yield ensureAllowance([curve.constants.ALIASES.crv], [amount], curve.constants.ALIASES.voting_escrow, false);
-});
+export function crvSupplyStats() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const crvContract = this.contracts[this.constants.ALIASES.crv].multicallContract;
+        const veContract = this.contracts[this.constants.ALIASES.voting_escrow].multicallContract;
+        const csContract = this.contracts[this.constants.ALIASES.circulating_supply].multicallContract;
+        const [_circulating, _locked, _veCrv] = yield this.multicallProvider.all([
+            csContract.circulating_supply(),
+            crvContract.balanceOf(this.constants.ALIASES.voting_escrow),
+            veContract.totalSupply(),
+        ]);
+        return {
+            circulating: this.formatUnits(_circulating),
+            locked: this.formatUnits(_locked),
+            total: this.formatUnits(_circulating + _locked),
+            veCrv: this.formatUnits(_veCrv),
+            averageLockTime: toBN(_veCrv).div(toBN(_locked)).times(4).toFixed(4), // years
+        };
+    });
+}
+export function userCrv() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        address = _getAddress.call(this, address);
+        const _balance = yield this.contracts[this.constants.ALIASES.crv].contract.balanceOf(address);
+        return this.formatUnits(_balance);
+    });
+}
+export function userVeCrv() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        address = _getAddress.call(this, address);
+        const contract = this.contracts[this.constants.ALIASES.voting_escrow].multicallContract;
+        const [_veCrv, _veCrvTotal, _locked] = yield this.multicallProvider.all([
+            contract.balanceOf(address),
+            contract.totalSupply(),
+            contract.locked(address),
+        ]);
+        const _lockedCrv = _locked[0];
+        const _unlockTime = _locked[1];
+        return {
+            veCrv: this.formatUnits(_veCrv),
+            veCrvPct: toBN(_veCrv).div(toBN(_veCrvTotal)).times(100).toString(),
+            lockedCrv: this.formatUnits(_lockedCrv),
+            unlockTime: Number(this.formatUnits(_unlockTime, 0)) * 1000,
+        };
+    });
+}
+export function crvLockIsApproved(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        return yield hasAllowance.call(this, [this.constants.ALIASES.crv], [amount], this.signerAddress, this.constants.ALIASES.voting_escrow);
+    });
+}
+export function crvLockApproveEstimateGas(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        return yield ensureAllowanceEstimateGas.call(this, [this.constants.ALIASES.crv], [amount], this.constants.ALIASES.voting_escrow, false);
+    });
+}
+export function crvLockApprove(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        return yield ensureAllowance.call(this, [this.constants.ALIASES.crv], [amount], this.constants.ALIASES.voting_escrow, false);
+    });
+}
 export const calcCrvUnlockTime = (days, start = Date.now()) => {
     const week = 86400 * 7;
     const now = Number(start) / 1000;
     const unlockTime = now + (86400 * Number(days));
     return Math.floor(unlockTime / week) * week * 1000;
 };
-const _createCrvLock = (amount, days, estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const crvBalance = yield userCrv();
-    if (BN(crvBalance).lt(amount))
-        throw Error(`Not enough CRV. Wallet balance: ${crvBalance}, required: ${amount}`);
-    if (!(yield crvLockIsApproved(amount)))
-        throw Error("Token allowance is needed to estimate gas");
-    const _amount = parseUnits(amount);
-    const unlockTime = Math.floor(Date.now() / 1000) + (days * 86400);
-    const contract = curve.contracts[curve.constants.ALIASES.voting_escrow].contract;
-    const gas = yield contract.create_lock.estimateGas(_amount, unlockTime, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.create_lock(_amount, unlockTime, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const createCrvLockEstimateGas = (amount, days) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _createCrvLock(amount, Number(days), true);
-});
-export const createCrvLock = (amount, days) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _createCrvLock(amount, Number(days), false);
-});
-const _increaseCrvLockedAmount = (amount, estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const crvBalance = yield userCrv();
-    if (BN(crvBalance).lt(amount))
-        throw Error(`Not enough CRV. Wallet balance: ${crvBalance}, required: ${amount}`);
-    if (!(yield crvLockIsApproved(amount)))
-        throw Error("Token allowance is needed to estimate gas");
-    const _amount = parseUnits(amount);
-    const contract = curve.contracts[curve.constants.ALIASES.voting_escrow].contract;
-    const gas = yield contract.increase_amount.estimateGas(_amount, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.increase_amount(_amount, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const increaseCrvLockedAmountEstimateGas = (amount) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _increaseCrvLockedAmount(amount, true);
-});
-export const increaseCrvLockedAmount = (amount) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _increaseCrvLockedAmount(amount, false);
-});
-const _increaseCrvUnlockTime = (days, estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const { unlockTime } = yield userVeCrv();
-    const newUnlockTime = Math.floor(unlockTime / 1000) + (days * 86400);
-    const contract = curve.contracts[curve.constants.ALIASES.voting_escrow].contract;
-    const gas = yield contract.increase_unlock_time.estimateGas(newUnlockTime, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.increase_unlock_time(newUnlockTime, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const increaseCrvUnlockTimeEstimateGas = (days) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _increaseCrvUnlockTime(Number(days), true);
-});
-export const increaseCrvUnlockTime = (days) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _increaseCrvUnlockTime(Number(days), false);
-});
-const _withdrawLockedCrv = (estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const { unlockTime } = yield userVeCrv();
-    if (unlockTime > Date.now())
-        throw Error("The lock haven't expired yet");
-    const contract = curve.contracts[curve.constants.ALIASES.voting_escrow].contract;
-    const gas = yield contract.withdraw.estimateGas(curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.withdraw(Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const withdrawLockedCrvEstimateGas = () => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _withdrawLockedCrv(true);
-});
-export const withdrawLockedCrv = () => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _withdrawLockedCrv(false);
-});
-export const claimableFees = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    address = _getAddress(address);
-    const contract = new Contract(curve.constants.ALIASES.fee_distributor, feeDistributorViewABI, curve.provider);
-    return curve.formatUnits(yield contract.claim(address, curve.constantOptions));
-});
-const _claimFees = (address, estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    address = _getAddress(address);
-    const contract = curve.contracts[curve.constants.ALIASES.fee_distributor].contract;
-    const gas = yield contract.claim.estimateGas(address, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.claim(address, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const claimFeesEstimateGas = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    return yield _claimFees(address, true);
-});
-export const claimFees = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    return yield _claimFees(address, false);
-});
+function _createCrvLock(amount, days, estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const crvBalance = yield userCrv.call(this);
+        if (BN(crvBalance).lt(amount))
+            throw Error(`Not enough CRV. Wallet balance: ${crvBalance}, required: ${amount}`);
+        if (!(yield crvLockIsApproved.call(this, amount)))
+            throw Error("Token allowance is needed to estimate gas");
+        const _amount = parseUnits(amount);
+        const unlockTime = Math.floor(Date.now() / 1000) + (days * 86400);
+        const contract = this.contracts[this.constants.ALIASES.voting_escrow].contract;
+        const gas = yield contract.create_lock.estimateGas(_amount, unlockTime, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.create_lock(_amount, unlockTime, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function createCrvLockEstimateGas(amount, days) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _createCrvLock.call(this, amount, Number(days), true);
+    });
+}
+export function createCrvLock(amount, days) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _createCrvLock.call(this, amount, Number(days), false);
+    });
+}
+function _increaseCrvLockedAmount(amount, estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const crvBalance = yield userCrv.call(this);
+        if (BN(crvBalance).lt(amount))
+            throw Error(`Not enough CRV. Wallet balance: ${crvBalance}, required: ${amount}`);
+        if (!(yield crvLockIsApproved.call(this, amount)))
+            throw Error("Token allowance is needed to estimate gas");
+        const _amount = parseUnits(amount);
+        const contract = this.contracts[this.constants.ALIASES.voting_escrow].contract;
+        const gas = yield contract.increase_amount.estimateGas(_amount, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.increase_amount(_amount, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function increaseCrvLockedAmountEstimateGas(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _increaseCrvLockedAmount.call(this, amount, true);
+    });
+}
+export function increaseCrvLockedAmount(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _increaseCrvLockedAmount.call(this, amount, false);
+    });
+}
+function _increaseCrvUnlockTime(days, estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const { unlockTime } = yield userVeCrv.call(this);
+        const newUnlockTime = Math.floor(unlockTime / 1000) + (days * 86400);
+        const contract = this.contracts[this.constants.ALIASES.voting_escrow].contract;
+        const gas = yield contract.increase_unlock_time.estimateGas(newUnlockTime, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.increase_unlock_time(newUnlockTime, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function increaseCrvUnlockTimeEstimateGas(days) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _increaseCrvUnlockTime.call(this, Number(days), true);
+    });
+}
+export function increaseCrvUnlockTime(days) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _increaseCrvUnlockTime.call(this, Number(days), false);
+    });
+}
+function _withdrawLockedCrv(estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const { unlockTime } = yield userVeCrv.call(this);
+        if (unlockTime > Date.now())
+            throw Error("The lock haven't expired yet");
+        const contract = this.contracts[this.constants.ALIASES.voting_escrow].contract;
+        const gas = yield contract.withdraw.estimateGas(this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.withdraw(Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function withdrawLockedCrvEstimateGas() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _withdrawLockedCrv.call(this, true);
+    });
+}
+export function withdrawLockedCrv() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _withdrawLockedCrv.call(this, false);
+    });
+}
+export function claimableFees() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        address = _getAddress.call(this, address);
+        const contract = new Contract(this.constants.ALIASES.fee_distributor, feeDistributorViewABI, this.provider);
+        return this.formatUnits(yield contract.claim(address, this.constantOptions));
+    });
+}
+function _claimFees(address, estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        address = _getAddress.call(this, address);
+        const contract = this.contracts[this.constants.ALIASES.fee_distributor].contract;
+        const gas = yield contract.claim.estimateGas(address, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.claim(address, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function claimFeesEstimateGas() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        return yield _claimFees.call(this, address, true);
+    });
+}
+export function claimFees() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        return yield _claimFees.call(this, address, false);
+    });
+}
 // ----------------- Gauge weights -----------------
-const _extractNetworkFromPoolUrl = (poolUrl) => {
-    if (!poolUrl)
-        return "unknown";
-    return poolUrl.split("/")[4];
-};
-export const getVotingGaugeList = () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const gaugeData = Object.values(yield _getAllGauges());
-    const res = [];
-    for (let i = 0; i < gaugeData.length; i++) {
-        if ((gaugeData[i].is_killed || gaugeData[i].hasNoCrv) && Number(gaugeData[i].gauge_controller.gauge_relative_weight) === 0)
-            continue;
-        res.push({
-            poolUrl: ((_a = gaugeData[i].poolUrls) === null || _a === void 0 ? void 0 : _a.swap[0]) || '',
-            network: gaugeData[i].blockchainId,
-            gaugeAddress: gaugeData[i].gauge,
-            poolAddress: gaugeData[i].swap || '',
-            lpTokenAddress: gaugeData[i].swap_token || '',
-            poolName: gaugeData[i].shortName,
-            totalVeCrv: curve.formatUnits(gaugeData[i].gauge_controller.get_gauge_weight, 18),
-            relativeWeight: curve.formatUnits(gaugeData[i].gauge_controller.gauge_relative_weight, 16),
-            isKilled: (_b = gaugeData[i].is_killed) !== null && _b !== void 0 ? _b : false,
-        });
-    }
-    return res;
-});
-export const userGaugeVotes = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    var _a, _b;
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    address = _getAddress(address);
-    const gcMulticallContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
-    const veMulticallContract = curve.contracts[curve.constants.ALIASES.voting_escrow].multicallContract;
-    const gaugeData = Object.values(yield _getAllGauges());
-    const calls = [veMulticallContract.balanceOf(address)];
-    for (const d of gaugeData) {
-        const gaugeAddress = d.rootGauge ? d.rootGauge : d.gauge;
-        calls.push(gcMulticallContract.vote_user_slopes(address, gaugeAddress));
-    }
-    const [veCrvBalance, ...votes] = yield curve.multicallProvider.all(calls);
-    const res = { gauges: [], powerUsed: "0.0", veCrvUsed: "0.0" };
-    let powerUsed = BigInt(0);
-    let veCrvUsed = BigInt(0);
-    for (let i = 0; i < votes.length; i++) {
-        if (votes[i][1] === BigInt(0))
-            continue;
-        let dt = votes[i][2] - BigInt(Math.floor(Date.now() / 1000));
-        if (dt < BigInt(0))
-            dt = BigInt(0);
-        res.gauges.push({
-            userPower: curve.formatUnits(votes[i][1], 2),
-            userVeCrv: curve.formatUnits(votes[i][0] * dt, 18),
-            userFutureVeCrv: curve.formatUnits(veCrvBalance * votes[i][1] / BigInt(10000), 18),
-            expired: dt === BigInt(0),
-            gaugeData: {
+export function getVotingGaugeList() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const gaugeData = Object.values(yield _getAllGauges());
+        const res = [];
+        for (let i = 0; i < gaugeData.length; i++) {
+            if ((gaugeData[i].is_killed || gaugeData[i].hasNoCrv) && Number(gaugeData[i].gauge_controller.gauge_relative_weight) === 0)
+                continue;
+            res.push({
                 poolUrl: ((_a = gaugeData[i].poolUrls) === null || _a === void 0 ? void 0 : _a.swap[0]) || '',
                 network: gaugeData[i].blockchainId,
                 gaugeAddress: gaugeData[i].gauge,
                 poolAddress: gaugeData[i].swap || '',
                 lpTokenAddress: gaugeData[i].swap_token || '',
                 poolName: gaugeData[i].shortName,
-                totalVeCrv: curve.formatUnits(gaugeData[i].gauge_controller.get_gauge_weight, 18),
-                relativeWeight: curve.formatUnits(gaugeData[i].gauge_controller.gauge_relative_weight, 16),
+                totalVeCrv: this.formatUnits(gaugeData[i].gauge_controller.get_gauge_weight, 18),
+                relativeWeight: this.formatUnits(gaugeData[i].gauge_controller.gauge_relative_weight, 16),
                 isKilled: (_b = gaugeData[i].is_killed) !== null && _b !== void 0 ? _b : false,
-            },
-        });
-        powerUsed += votes[i][1];
-        veCrvUsed += votes[i][0] * dt;
-    }
-    res.powerUsed = curve.formatUnits(powerUsed, 2);
-    res.veCrvUsed = curve.formatUnits(veCrvUsed.toString(), 18);
-    return res;
-});
-export const voteForGaugeNextTime = (gauge) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const _lastVote = yield curve.contracts[curve.constants.ALIASES.gauge_controller].contract.last_user_vote(curve.signerAddress, gauge, curve.constantOptions);
-    return (Number(_lastVote) + (10 * 86400)) * 1000;
-});
-const _voteForGauge = (gauge, power, estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const gcContract = curve.contracts[curve.constants.ALIASES.gauge_controller].contract;
-    const gcMulticallContract = curve.contracts[curve.constants.ALIASES.gauge_controller].multicallContract;
-    const _power = parseUnits(power, 2);
-    const [_powerUsed, _vote_slopes] = yield curve.multicallProvider.all([
-        gcMulticallContract.vote_user_power(curve.signerAddress),
-        gcMulticallContract.vote_user_slopes(curve.signerAddress, gauge),
-    ]);
-    const _freePower = BigInt(10000) - _powerUsed;
-    if (_power > _freePower + _vote_slopes[1])
-        throw Error(`User have only ${curve.formatUnits(_freePower, 2)} % free power. Trying to use ${curve.formatUnits(_power, 2)}`);
-    const nextVoteTime = yield voteForGaugeNextTime(gauge);
-    if (Date.now() < nextVoteTime)
-        throw Error(`User can't change vote for this gauge earlier than ${new Date(nextVoteTime)}`);
-    const gas = yield gcContract.vote_for_gauge_weights.estimateGas(gauge, _power, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield gcContract.vote_for_gauge_weights(gauge, _power, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const voteForGaugeEstimateGas = (gauge, power) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _voteForGauge(gauge, power, true);
-});
-export const voteForGauge = (gauge, power) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _voteForGauge(gauge, power, false);
-});
+            });
+        }
+        return res;
+    });
+}
+export function userGaugeVotes() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        var _a, _b;
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        address = _getAddress.call(this, address);
+        const gcMulticallContract = this.contracts[this.constants.ALIASES.gauge_controller].multicallContract;
+        const veMulticallContract = this.contracts[this.constants.ALIASES.voting_escrow].multicallContract;
+        const gaugeData = Object.values(yield _getAllGauges());
+        const calls = [veMulticallContract.balanceOf(address)];
+        for (const d of gaugeData) {
+            const gaugeAddress = d.rootGauge ? d.rootGauge : d.gauge;
+            calls.push(gcMulticallContract.vote_user_slopes(address, gaugeAddress));
+        }
+        const [veCrvBalance, ...votes] = yield this.multicallProvider.all(calls);
+        const res = { gauges: [], powerUsed: "0.0", veCrvUsed: "0.0" };
+        let powerUsed = BigInt(0);
+        let veCrvUsed = BigInt(0);
+        for (let i = 0; i < votes.length; i++) {
+            if (votes[i][1] === BigInt(0))
+                continue;
+            let dt = votes[i][2] - BigInt(Math.floor(Date.now() / 1000));
+            if (dt < BigInt(0))
+                dt = BigInt(0);
+            res.gauges.push({
+                userPower: this.formatUnits(votes[i][1], 2),
+                userVeCrv: this.formatUnits(votes[i][0] * dt, 18),
+                userFutureVeCrv: this.formatUnits(veCrvBalance * votes[i][1] / BigInt(10000), 18),
+                expired: dt === BigInt(0),
+                gaugeData: {
+                    poolUrl: ((_a = gaugeData[i].poolUrls) === null || _a === void 0 ? void 0 : _a.swap[0]) || '',
+                    network: gaugeData[i].blockchainId,
+                    gaugeAddress: gaugeData[i].gauge,
+                    poolAddress: gaugeData[i].swap || '',
+                    lpTokenAddress: gaugeData[i].swap_token || '',
+                    poolName: gaugeData[i].shortName,
+                    totalVeCrv: this.formatUnits(gaugeData[i].gauge_controller.get_gauge_weight, 18),
+                    relativeWeight: this.formatUnits(gaugeData[i].gauge_controller.gauge_relative_weight, 16),
+                    isKilled: (_b = gaugeData[i].is_killed) !== null && _b !== void 0 ? _b : false,
+                },
+            });
+            powerUsed += votes[i][1];
+            veCrvUsed += votes[i][0] * dt;
+        }
+        res.powerUsed = this.formatUnits(powerUsed, 2);
+        res.veCrvUsed = this.formatUnits(veCrvUsed.toString(), 18);
+        return res;
+    });
+}
+export function voteForGaugeNextTime(gauge) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const _lastVote = yield this.contracts[this.constants.ALIASES.gauge_controller].contract.last_user_vote(this.signerAddress, gauge, this.constantOptions);
+        return (Number(_lastVote) + (10 * 86400)) * 1000;
+    });
+}
+function _voteForGauge(gauge, power, estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const gcContract = this.contracts[this.constants.ALIASES.gauge_controller].contract;
+        const gcMulticallContract = this.contracts[this.constants.ALIASES.gauge_controller].multicallContract;
+        const _power = parseUnits(power, 2);
+        const [_powerUsed, _vote_slopes] = yield this.multicallProvider.all([
+            gcMulticallContract.vote_user_power(this.signerAddress),
+            gcMulticallContract.vote_user_slopes(this.signerAddress, gauge),
+        ]);
+        const _freePower = BigInt(10000) - _powerUsed;
+        if (_power > _freePower + _vote_slopes[1])
+            throw Error(`User have only ${this.formatUnits(_freePower, 2)} % free power. Trying to use ${this.formatUnits(_power, 2)}`);
+        const nextVoteTime = yield voteForGaugeNextTime.call(this, gauge);
+        if (Date.now() < nextVoteTime)
+            throw Error(`User can't change vote for this gauge earlier than ${new Date(nextVoteTime)}`);
+        const gas = yield gcContract.vote_for_gauge_weights.estimateGas(gauge, _power, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield gcContract.vote_for_gauge_weights(gauge, _power, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function voteForGaugeEstimateGas(gauge, power) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _voteForGauge.call(this, gauge, power, true);
+    });
+}
+export function voteForGauge(gauge, power) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _voteForGauge.call(this, gauge, power, false);
+    });
+}
 // ----------------- Proposals -----------------
-export const getProposalList = () => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _getDaoProposalList();
-});
-export const getProposal = (type, id) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _getDaoProposal(type, id);
-});
-export const userProposalVotes = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (address = "") {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    address = _getAddress(address);
-    const proposalList = yield _getDaoProposalList();
-    const calls = [];
-    for (const proposal of proposalList) {
-        if (proposal.voteType.toUpperCase() == "PARAMETER") {
-            calls.push(curve.contracts[curve.constants.ALIASES.voting_parameter].multicallContract.getVoterState(proposal.voteId, address));
+export function getProposalList() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _getDaoProposalList();
+    });
+}
+export function getProposal(type, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _getDaoProposal(type, id);
+    });
+}
+export function userProposalVotes() {
+    return __awaiter(this, arguments, void 0, function* (address = "") {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        address = _getAddress.call(this, address);
+        const proposalList = yield _getDaoProposalList();
+        const calls = [];
+        for (const proposal of proposalList) {
+            if (proposal.voteType.toUpperCase() == "PARAMETER") {
+                calls.push(this.contracts[this.constants.ALIASES.voting_parameter].multicallContract.getVoterState(proposal.voteId, address));
+            }
+            else {
+                calls.push(this.contracts[this.constants.ALIASES.voting_ownership].multicallContract.getVoterState(proposal.voteId, address));
+            }
         }
-        else {
-            calls.push(curve.contracts[curve.constants.ALIASES.voting_ownership].multicallContract.getVoterState(proposal.voteId, address));
+        const userState = (yield this.multicallProvider.all(calls)).map(Number);
+        const userProposalList = [];
+        const voteEnum = {
+            1: "yes",
+            2: "no",
+            3: "even",
+        };
+        for (let i = 0; i < proposalList.length; i++) {
+            if (userState[i] > 0)
+                userProposalList.push(Object.assign(Object.assign({}, proposalList[i]), { userVote: voteEnum[userState[i]] }));
         }
-    }
-    const userState = (yield curve.multicallProvider.all(calls)).map(Number);
-    const userProposalList = [];
-    const voteEnum = {
-        1: "yes",
-        2: "no",
-        3: "even",
-    };
-    for (let i = 0; i < proposalList.length; i++) {
-        if (userState[i] > 0)
-            userProposalList.push(Object.assign(Object.assign({}, proposalList[i]), { userVote: voteEnum[userState[i]] }));
-    }
-    return userProposalList;
-});
-const _voteForProposal = (type, id, support, estimateGas) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const contractAddress = type.toUpperCase() === "PARAMETER" ? curve.constants.ALIASES.voting_parameter : curve.constants.ALIASES.voting_ownership;
-    const contract = curve.contracts[contractAddress].contract;
-    const yesPct = support ? BigInt(Math.pow(10, 18)) : BigInt(0);
-    const noPct = BigInt(Math.pow(10, 18)) - yesPct;
-    const gas = yield contract.votePct.estimateGas(id, yesPct, noPct, true, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.votePct(id, yesPct, noPct, false, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const voteForProposalEstimateGas = (type, id, support) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _voteForProposal(type, id, support, true);
-});
-export const voteForProposal = (type, id, support) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _voteForProposal(type, id, support, false);
-});
-const _executeVote = (type_1, id_1, ...args_1) => __awaiter(void 0, [type_1, id_1, ...args_1], void 0, function* (type, id, estimateGas = false) {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const contractAddress = type.toUpperCase() === "PARAMETER" ? curve.constants.ALIASES.voting_parameter : curve.constants.ALIASES.voting_ownership;
-    const contract = curve.contracts[contractAddress].contract;
-    const gas = yield contract.executeVote.estimateGas(id, curve.constantOptions);
-    if (estimateGas)
-        return smartNumber(gas);
-    yield curve.updateFeeData();
-    const gasLimit = mulBy1_3(DIGas(gas));
-    return (yield contract.executeVote(id, Object.assign(Object.assign({}, curve.options), { gasLimit }))).hash;
-});
-export const executeVoteEstimateGas = (type, id) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _executeVote(type, id, true);
-});
-export const executeVote = (type, id) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield _executeVote(type, id, false);
-});
-export const isCanVoteExecute = (type, id) => __awaiter(void 0, void 0, void 0, function* () {
-    if (curve.chainId !== 1)
-        throw Error("Ethereum-only method");
-    const contractAddress = type.toUpperCase() === "PARAMETER" ? curve.constants.ALIASES.voting_parameter : curve.constants.ALIASES.voting_ownership;
-    const contract = curve.contracts[contractAddress].contract;
-    return yield contract.canExecute(id, Object.assign({}, curve.options));
-});
+        return userProposalList;
+    });
+}
+function _voteForProposal(type, id, support, estimateGas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const contractAddress = type.toUpperCase() === "PARAMETER" ? this.constants.ALIASES.voting_parameter : this.constants.ALIASES.voting_ownership;
+        const contract = this.contracts[contractAddress].contract;
+        const yesPct = support ? BigInt(Math.pow(10, 18)) : BigInt(0);
+        const noPct = BigInt(Math.pow(10, 18)) - yesPct;
+        const gas = yield contract.votePct.estimateGas(id, yesPct, noPct, true, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.votePct(id, yesPct, noPct, false, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function voteForProposalEstimateGas(type, id, support) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _voteForProposal.call(this, type, id, support, true);
+    });
+}
+export function voteForProposal(type, id, support) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _voteForProposal.call(this, type, id, support, false);
+    });
+}
+function _executeVote(type_1, id_1) {
+    return __awaiter(this, arguments, void 0, function* (type, id, estimateGas = false) {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const contractAddress = type.toUpperCase() === "PARAMETER" ? this.constants.ALIASES.voting_parameter : this.constants.ALIASES.voting_ownership;
+        const contract = this.contracts[contractAddress].contract;
+        const gas = yield contract.executeVote.estimateGas(id, this.constantOptions);
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = mulBy1_3(DIGas(gas));
+        return (yield contract.executeVote(id, Object.assign(Object.assign({}, this.options), { gasLimit }))).hash;
+    });
+}
+export function executeVoteEstimateGas(type, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _executeVote.call(this, type, id, true);
+    });
+}
+export function executeVote(type, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _executeVote.call(this, type, id, false);
+    });
+}
+export function isCanVoteExecute(type, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (this.chainId !== 1)
+            throw Error("Ethereum-only method");
+        const contractAddress = type.toUpperCase() === "PARAMETER" ? this.constants.ALIASES.voting_parameter : this.constants.ALIASES.voting_ownership;
+        const contract = this.contracts[contractAddress].contract;
+        return yield contract.canExecute(id, Object.assign({}, this.options));
+    });
+}