@curvefi/llamalend-api 1.1.9 → 2.0.0

package/lib/lendMarkets/modules/common/vault.js

@@ -0,0 +1,535 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import memoize from "memoizee";
+import { _getAddress, parseUnits, BN, toBN, ensureAllowance, hasAllowance, ensureAllowanceEstimateGas, formatUnits, smartNumber, _mulBy1_3, _getUsdRate, _ensureAllowance, DIGas, } from "../../../utils";
+import { _getMarketsData } from "../../../external-api";
+import ERC20Abi from '../../../constants/abis/ERC20.json' with { type: 'json' };
+import { WEEK } from "../../../constants/utils";
+export class VaultModule {
+    constructor(market) {
+        this._calcCrvApr = (...args_1) => __awaiter(this, [...args_1], void 0, function* (futureWorkingSupplyBN = null) {
+            const totalLiquidityUSD = yield this.vaultTotalLiquidity();
+            if (Number(totalLiquidityUSD) === 0)
+                return [0, 0];
+            let inflationRateBN, workingSupplyBN, totalSupplyBN;
+            if (this.llamalend.chainId !== 1) {
+                const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+                const lpTokenContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
+                const crvContract = this.llamalend.contracts[this.llamalend.constants.ALIASES.crv].contract;
+                const currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                [inflationRateBN, workingSupplyBN, totalSupplyBN] = (yield this.llamalend.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.market.addresses.gauge, this.llamalend.constantOptions)).div(WEEK);
+                }
+            }
+            else {
+                const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+                const lpTokenContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
+                const gaugeControllerContract = this.llamalend.contracts[this.llamalend.constants.ALIASES.gauge_controller].multicallContract;
+                let weightBN;
+                [inflationRateBN, weightBN, workingSupplyBN, totalSupplyBN] = (yield this.llamalend.multicallProvider.all([
+                    gaugeContract.inflation_rate(),
+                    gaugeControllerContract.gauge_relative_weight(this.market.addresses.gauge),
+                    gaugeContract.working_supply(),
+                    lpTokenContract.totalSupply(),
+                ])).map((value) => toBN(value));
+                inflationRateBN = inflationRateBN.times(weightBN);
+            }
+            if (inflationRateBN.eq(0))
+                return [0, 0];
+            if (futureWorkingSupplyBN !== null)
+                workingSupplyBN = futureWorkingSupplyBN;
+            // 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.call(this.llamalend, this.llamalend.constants.ALIASES.crv);
+            const baseApyBN = rateBN.times(crvPrice);
+            const boostedApyBN = baseApyBN.times(2.5);
+            return [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()];
+        });
+        this.vaultRewardTokens = memoize(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS)
+                return [];
+            // if (useApi) {
+            //     const rewards = await _getRewardsFromApi();
+            //     if (!rewards[this.market.addresses.gauge]) return [];
+            //     rewards[this.market.addresses.gauge].forEach((r) => _setContracts(r.tokenAddress, ERC20Abi));
+            //     return rewards[this.market.addresses.gauge].map((r) => ({ token: r.tokenAddress, symbol: r.symbol, decimals: Number(r.decimals) }));
+            // }
+            const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].contract;
+            const gaugeMulticallContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+            const rewardCount = Number(this.llamalend.formatUnits(yield gaugeContract.reward_count(this.llamalend.constantOptions), 0));
+            const tokenCalls = [];
+            for (let i = 0; i < rewardCount; i++) {
+                tokenCalls.push(gaugeMulticallContract.reward_tokens(i));
+            }
+            const tokens = (yield this.llamalend.multicallProvider.all(tokenCalls))
+                .filter((addr) => addr !== this.llamalend.constants.ZERO_ADDRESS)
+                .map((addr) => addr.toLowerCase())
+                .filter((addr) => this.llamalend.chainId === 1 || addr !== this.llamalend.constants.COINS.crv);
+            const tokenInfoCalls = [];
+            for (const token of tokens) {
+                this.llamalend.setContract(token, ERC20Abi);
+                const tokenMulticallContract = this.llamalend.contracts[token].multicallContract;
+                tokenInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
+            }
+            const tokenInfo = yield this.llamalend.multicallProvider.all(tokenInfoCalls);
+            for (let i = 0; i < tokens.length; i++) {
+                this.llamalend.constants.DECIMALS[tokens[i]] = Number(tokenInfo[(i * 2) + 1]);
+            }
+            return tokens.map((token, i) => ({ token, symbol: tokenInfo[i * 2], decimals: Number(tokenInfo[(i * 2) + 1]) }));
+        }), {
+            promise: true,
+            maxAge: 30 * 60 * 1000, // 30m
+        });
+        this.vaultRewardsApr = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+            if (useApi) {
+                const response = yield _getMarketsData(this.llamalend.constants.NETWORK_NAME);
+                const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase());
+                if (market) {
+                    return market.gaugeRewards;
+                }
+                else {
+                    throw new Error('Market not found in API');
+                }
+            }
+            else {
+                if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS)
+                    return [];
+                // const isDisabledChain = [1313161554].includes(this.llamalend.chainId); // Disable Aurora
+                // if (useApi && !isDisabledChain) {
+                //     const rewards = await _getRewardsFromApi();
+                //     if (!rewards[this.market.addresses.gauge]) return [];
+                //     return rewards[this.market.addresses.gauge].map((r) => ({ gaugeAddress: r.gaugeAddress, tokenAddress: r.tokenAddress, symbol: r.symbol, apy: r.apy }));
+                // }
+                const apy = [];
+                const rewardTokens = yield this.vaultRewardTokens();
+                for (const rewardToken of rewardTokens) {
+                    const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+                    const lpTokenContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
+                    const rewardContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+                    const totalLiquidityUSD = yield this.vaultTotalLiquidity();
+                    const rewardRate = yield _getUsdRate.call(this.llamalend, rewardToken.token);
+                    const [rewardData, _stakedSupply, _totalSupply] = yield this.llamalend.multicallProvider.all([
+                        rewardContract.reward_data(rewardToken.token),
+                        gaugeContract.totalSupply(),
+                        lpTokenContract.totalSupply(),
+                    ]);
+                    const stakedSupplyBN = toBN(_stakedSupply);
+                    const totalSupplyBN = toBN(_totalSupply);
+                    const inflationBN = toBN(rewardData.rate, rewardToken.decimals);
+                    const periodFinish = Number(this.llamalend.formatUnits(rewardData.period_finish, 0)) * 1000;
+                    const baseApy = periodFinish > Date.now() ?
+                        inflationBN.times(31536000).times(rewardRate).div(stakedSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)) :
+                        BN(0);
+                    apy.push({
+                        gaugeAddress: this.market.addresses.gauge,
+                        tokenAddress: rewardToken.token,
+                        symbol: rewardToken.symbol,
+                        apy: baseApy.times(100).toNumber(),
+                    });
+                }
+                return apy;
+            }
+        });
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    vaultMaxDeposit() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            // const _amount = await this.llamalend.contracts[this.market.addresses.vault].contract.maxDeposit(address);  TODO use maxDeposit
+            const _amount = yield this.llamalend.contracts[this.market.addresses.borrowed_token].contract.balanceOf(address);
+            return formatUnits(_amount, this.market.borrowed_token.decimals);
+        });
+    }
+    vaultPreviewDeposit(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _amount = parseUnits(amount, this.market.borrowed_token.decimals);
+            const _shares = yield this.llamalend.contracts[this.market.addresses.vault].contract.previewDeposit(_amount);
+            return formatUnits(_shares, 18);
+        });
+    }
+    vaultDepositIsApproved(borrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield hasAllowance.call(this.llamalend, [this.market.borrowed_token.address], [borrowed], this.llamalend.signerAddress, this.market.addresses.vault);
+        });
+    }
+    vaultDepositApproveEstimateGas(borrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.borrowed_token.address], [borrowed], this.market.addresses.vault);
+        });
+    }
+    vaultDepositApprove(borrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ensureAllowance.call(this.llamalend, [this.market.borrowed_token.address], [borrowed], this.market.addresses.vault);
+        });
+    }
+    _vaultDeposit(amount_1) {
+        return __awaiter(this, arguments, void 0, function* (amount, estimateGas = false) {
+            const _amount = parseUnits(amount, this.market.borrowed_token.decimals);
+            const gas = yield this.llamalend.contracts[this.market.addresses.vault].contract.deposit.estimateGas(_amount, Object.assign({}, this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield this.llamalend.contracts[this.market.addresses.vault].contract.deposit(_amount, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultDepositEstimateGas(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.vaultDepositIsApproved(amount)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._vaultDeposit(amount, true);
+        });
+    }
+    vaultDeposit(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.vaultDepositApprove(amount);
+            return yield this._vaultDeposit(amount, false);
+        });
+    }
+    vaultMaxMint() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            // const _shares = await this.llamalend.contracts[this.market.addresses.vault].contract.maxMint(address);  TODO use maxMint
+            const _assetBalance = yield this.llamalend.contracts[this.market.addresses.borrowed_token].contract.balanceOf(address);
+            const _shares = yield this.llamalend.contracts[this.market.addresses.vault].contract.convertToShares(_assetBalance);
+            return formatUnits(_shares, 18);
+        });
+    }
+    vaultPreviewMint(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _amount = parseUnits(amount, 18);
+            const _assets = yield this.llamalend.contracts[this.market.addresses.vault].contract.previewMint(_amount);
+            return formatUnits(_assets, this.market.borrowed_token.decimals);
+        });
+    }
+    vaultMintIsApproved(borrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield hasAllowance.call(this.llamalend, [this.market.borrowed_token.address], [borrowed], this.llamalend.signerAddress, this.market.addresses.vault);
+        });
+    }
+    vaultMintApproveEstimateGas(borrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.borrowed_token.address], [borrowed], this.market.addresses.vault);
+        });
+    }
+    vaultMintApprove(borrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ensureAllowance.call(this.llamalend, [this.market.borrowed_token.address], [borrowed], this.market.addresses.vault);
+        });
+    }
+    _vaultMint(amount_1) {
+        return __awaiter(this, arguments, void 0, function* (amount, estimateGas = false) {
+            const _amount = parseUnits(amount, 18);
+            const gas = yield this.llamalend.contracts[this.market.addresses.vault].contract.mint.estimateGas(_amount, Object.assign({}, this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield this.llamalend.contracts[this.market.addresses.vault].contract.mint(_amount, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultMintEstimateGas(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.vaultMintIsApproved(amount)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._vaultMint(amount, true);
+        });
+    }
+    vaultMint(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.vaultMintApprove(amount);
+            return yield this._vaultMint(amount, false);
+        });
+    }
+    vaultMaxWithdraw() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            const _assets = yield this.llamalend.contracts[this.market.addresses.vault].contract.maxWithdraw(address);
+            return formatUnits(_assets, this.market.borrowed_token.decimals);
+        });
+    }
+    vaultPreviewWithdraw(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _amount = parseUnits(amount, this.market.borrowed_token.decimals);
+            const _shares = yield this.llamalend.contracts[this.market.addresses.vault].contract.previewWithdraw(_amount);
+            return formatUnits(_shares, 18);
+        });
+    }
+    _vaultWithdraw(amount_1) {
+        return __awaiter(this, arguments, void 0, function* (amount, estimateGas = false) {
+            const _amount = parseUnits(amount, this.market.borrowed_token.decimals);
+            const gas = yield this.llamalend.contracts[this.market.addresses.vault].contract.withdraw.estimateGas(_amount, Object.assign({}, this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield this.llamalend.contracts[this.market.addresses.vault].contract.withdraw(_amount, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultWithdrawEstimateGas(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultWithdraw(amount, true);
+        });
+    }
+    vaultWithdraw(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultWithdraw(amount, false);
+        });
+    }
+    vaultMaxRedeem() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            const _shares = yield this.llamalend.contracts[this.market.addresses.vault].contract.maxRedeem(address);
+            return formatUnits(_shares, 18);
+        });
+    }
+    vaultPreviewRedeem(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _amount = parseUnits(amount, 18);
+            const _assets = yield this.llamalend.contracts[this.market.addresses.vault].contract.previewRedeem(_amount);
+            return formatUnits(_assets, this.market.borrowed_token.decimals);
+        });
+    }
+    _vaultRedeem(amount_1) {
+        return __awaiter(this, arguments, void 0, function* (amount, estimateGas = false) {
+            const _amount = parseUnits(amount, 18);
+            const gas = yield this.llamalend.contracts[this.market.addresses.vault].contract.redeem.estimateGas(_amount, Object.assign({}, this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield this.llamalend.contracts[this.market.addresses.vault].contract.redeem(_amount, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultRedeemEstimateGas(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultRedeem(amount, true);
+        });
+    }
+    vaultRedeem(amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultRedeem(amount, false);
+        });
+    }
+    // ---------------- VAULT UTILS ----------------
+    vaultConvertToShares(assets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _assets = parseUnits(assets, this.market.borrowed_token.decimals);
+            const _shares = yield this.llamalend.contracts[this.market.addresses.vault].contract.convertToShares(_assets);
+            return this.llamalend.formatUnits(_shares);
+        });
+    }
+    vaultConvertToAssets(shares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _shares = parseUnits(shares);
+            const _assets = yield this.llamalend.contracts[this.market.addresses.vault].contract.convertToAssets(_shares);
+            return this.llamalend.formatUnits(_assets, this.market.borrowed_token.decimals);
+        });
+    }
+    // ---------------- VAULT STAKING ----------------
+    vaultStakeIsApproved(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`stakeIsApproved method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            return yield hasAllowance.call(this.llamalend, [this.market.addresses.vault], [vaultShares], this.llamalend.signerAddress, this.market.addresses.gauge);
+        });
+    }
+    vaultStakeApproveEstimateGas(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`stakeApproveEstimateGas method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.addresses.vault], [vaultShares], this.market.addresses.gauge);
+        });
+    }
+    vaultStakeApprove(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`stakeApprove method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            return yield ensureAllowance.call(this.llamalend, [this.market.addresses.vault], [vaultShares], this.market.addresses.gauge);
+        });
+    }
+    vaultStakeEstimateGas(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`stakeEstimateGas method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            const _vaultShares = parseUnits(vaultShares);
+            return smartNumber(yield this.llamalend.contracts[this.market.addresses.gauge].contract.deposit.estimateGas(_vaultShares, this.llamalend.constantOptions));
+        });
+    }
+    vaultStake(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`stake method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            const _vaultShares = parseUnits(vaultShares);
+            yield _ensureAllowance.call(this.llamalend, [this.market.addresses.vault], [_vaultShares], this.market.addresses.gauge);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(yield this.llamalend.contracts[this.market.addresses.gauge].contract.deposit.estimateGas(_vaultShares, this.llamalend.constantOptions)));
+            return (yield this.llamalend.contracts[this.market.addresses.gauge].contract.deposit(_vaultShares, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultUnstakeEstimateGas(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`unstakeEstimateGas method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            const _vaultShares = parseUnits(vaultShares);
+            return smartNumber(yield this.llamalend.contracts[this.market.addresses.gauge].contract.withdraw.estimateGas(_vaultShares, this.llamalend.constantOptions));
+        });
+    }
+    vaultUnstake(vaultShares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`unstake method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            const _vaultShares = parseUnits(vaultShares);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas((yield this.llamalend.contracts[this.market.addresses.gauge].contract.withdraw.estimateGas(_vaultShares, this.llamalend.constantOptions))));
+            return (yield this.llamalend.contracts[this.market.addresses.gauge].contract.withdraw(_vaultShares, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    // ---------------- VAULT STAKING REWARDS ----------------
+    vaultRewardsOnly() {
+        if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS)
+            throw Error(`${this.market.name} doesn't have gauge`);
+        const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].contract;
+        return !('inflation_rate()' in gaugeContract || 'inflation_rate(uint256)' in gaugeContract);
+    }
+    vaultTotalLiquidity() {
+        return __awaiter(this, arguments, void 0, function* (useAPI = true) {
+            const { cap } = yield this.market.stats.capAndAvailable(true, useAPI);
+            const price = yield _getUsdRate.call(this.llamalend, this.market.addresses.borrowed_token);
+            return BN(cap).times(price).toFixed(6);
+        });
+    }
+    vaultCrvApr() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.vaultRewardsOnly())
+                throw Error(`${this.market.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
+            // const isDisabledChain = [1313161554].includes(this.llamalend.chainId); // Disable Aurora
+            // if (useApi && !isDisabledChain) {
+            //     const crvAPYs = await _getCrvApyFromApi();
+            //     const poolCrvApy = crvAPYs[this.market.addresses.gauge] ?? [0, 0];  // new pools might be missing
+            //     return [poolCrvApy[0], poolCrvApy[1]];
+            // }
+            return yield this._calcCrvApr();
+        });
+    }
+    vaultClaimableCrv() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            if (this.vaultRewardsOnly())
+                throw Error(`${this.market.name} has Rewards-Only Gauge. Use claimableRewards instead`);
+            address = address || this.llamalend.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            return this.llamalend.formatUnits(yield this.llamalend.contracts[this.market.addresses.gauge].contract.claimable_tokens(address, this.llamalend.constantOptions));
+        });
+    }
+    _vaultClaimCrv(estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.vaultRewardsOnly())
+                throw Error(`${this.market.name} has Rewards-Only Gauge. Use claimRewards instead`);
+            let isOldFactory = false;
+            let contract;
+            if (this.llamalend.chainId !== 1) {
+                if (this.llamalend.constants.ALIASES.gauge_factory_old && this.llamalend.constants.ALIASES.gauge_factory_old !== this.llamalend.constants.ZERO_ADDRESS) {
+                    const oldFactoryContract = this.llamalend.contracts[this.llamalend.constants.ALIASES.gauge_factory_old].contract;
+                    const lpToken = yield this.llamalend.contracts[this.market.addresses.gauge].contract.lp_token();
+                    const gaugeAddress = yield oldFactoryContract.get_gauge_from_lp_token(lpToken);
+                    isOldFactory = gaugeAddress.toLowerCase() === this.market.addresses.gauge.toLowerCase();
+                    if (isOldFactory) {
+                        contract = oldFactoryContract;
+                    }
+                }
+            }
+            if (!isOldFactory) {
+                contract = this.llamalend.contracts[this.llamalend.constants.ALIASES.minter].contract;
+            }
+            if (!contract) {
+                throw Error(`${this.market.name} couldn't match gauge factory`);
+            }
+            const gas = yield contract.mint.estimateGas(this.market.addresses.gauge, this.llamalend.constantOptions);
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield contract.mint(this.market.addresses.gauge, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultClaimCrvEstimateGas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultClaimCrv(true);
+        });
+    }
+    vaultClaimCrv() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultClaimCrv(false);
+        });
+    }
+    vaultClaimableRewards() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`claimableRewards method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            address = address || this.llamalend.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].contract;
+            const rewardTokens = yield this.vaultRewardTokens();
+            const rewards = [];
+            for (const rewardToken of rewardTokens) {
+                const _amount = yield gaugeContract.claimable_reward(address, rewardToken.token, this.llamalend.constantOptions);
+                rewards.push({
+                    token: rewardToken.token,
+                    symbol: rewardToken.symbol,
+                    amount: this.llamalend.formatUnits(_amount, rewardToken.decimals),
+                });
+            }
+            return rewards;
+        });
+    }
+    _vaultClaimRewards(estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`claimRewards method doesn't exist for pool ${this.market.name} (id: ${this.market.name}). There is no gauge`);
+            }
+            const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].contract;
+            if (!("claim_rewards()" in gaugeContract))
+                throw Error(`${this.market.name} pool doesn't have such method`);
+            const gas = yield gaugeContract.claim_rewards.estimateGas(this.llamalend.constantOptions);
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield gaugeContract.claim_rewards(Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    vaultClaimRewardsEstimateGas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultClaimRewards(true);
+        });
+    }
+    vaultClaimRewards() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._vaultClaimRewards(false);
+        });
+    }
+}

package/lib/lendMarkets/modules/common/wallet.d.ts

@@ -0,0 +1,13 @@
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import { IWallet } from "../../interfaces/common";
+export declare class WalletModule implements IWallet {
+    private market;
+    private llamalend;
+    constructor(market: LendMarketTemplate);
+    balances(address?: string): Promise<{
+        collateral: string;
+        borrowed: string;
+        vaultShares: string;
+        gauge: string;
+    }>;
+}

package/lib/lendMarkets/modules/common/wallet.js

@@ -0,0 +1,28 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getBalances, } from "../../../utils";
+export class WalletModule {
+    constructor(market) {
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    balances() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                const [collateral, borrowed, vaultShares] = yield getBalances.call(this.llamalend, [this.market.collateral_token.address, this.market.borrowed_token.address, this.market.addresses.vault], address);
+                return { collateral, borrowed, vaultShares, gauge: "0" };
+            }
+            else {
+                const [collateral, borrowed, vaultShares, gauge] = yield getBalances.call(this.llamalend, [this.market.collateral_token.address, this.market.borrowed_token.address, this.market.addresses.vault, this.market.addresses.gauge], address);
+                return { collateral, borrowed, vaultShares, gauge };
+            }
+        });
+    }
+}

package/lib/lendMarkets/modules/index.d.ts

@@ -1 +1 @@
-export { LeverageZapV2Module } from './leverageZapV2.js';
+export { LeverageV1ZapV2Module } from './v1/leverageV1ZapV2';

package/lib/lendMarkets/modules/index.js

@@ -1 +1 @@
-export { LeverageZapV2Module } from './leverageZapV2.js';
+export { LeverageV1ZapV2Module } from './v1/leverageV1ZapV2';

package/lib/lendMarkets/modules/v1/index.d.ts

@@ -0,0 +1,4 @@
+export { LoanV1Module } from './loanV1.js';
+export { LeverageV1ZapV1Module } from './leverageV1ZapV1.js';
+export { LeverageV1ZapV2Module } from './leverageV1ZapV2.js';
+export { StatsV1Module } from './statsV1.js';

package/lib/lendMarkets/modules/v1/index.js

@@ -0,0 +1,4 @@
+export { LoanV1Module } from './loanV1.js';
+export { LeverageV1ZapV1Module } from './leverageV1ZapV1.js';
+export { LeverageV1ZapV2Module } from './leverageV1ZapV2.js';
+export { StatsV1Module } from './statsV1.js';

package/lib/lendMarkets/modules/v1/leverageV1ZapV1.d.ts

@@ -0,0 +1,3 @@
+import { LeverageZapV1BaseModule } from "../common/leverageZapV1Base.js";
+export declare class LeverageV1ZapV1Module extends LeverageZapV1BaseModule {
+}

package/lib/lendMarkets/modules/v1/leverageV1ZapV1.js

@@ -0,0 +1,3 @@
+import { LeverageZapV1BaseModule } from "../common/leverageZapV1Base.js";
+export class LeverageV1ZapV1Module extends LeverageZapV1BaseModule {
+}

package/lib/lendMarkets/modules/v1/leverageV1ZapV2.d.ts

@@ -0,0 +1,3 @@
+import { LeverageZapV2BaseModule } from "../common/leverageZapV2Base.js";
+export declare class LeverageV1ZapV2Module extends LeverageZapV2BaseModule {
+}

package/lib/lendMarkets/modules/v1/leverageV1ZapV2.js

@@ -0,0 +1,3 @@
+import { LeverageZapV2BaseModule } from "../common/leverageZapV2Base.js";
+export class LeverageV1ZapV2Module extends LeverageZapV2BaseModule {
+}

package/lib/lendMarkets/modules/v1/loanV1.d.ts

@@ -0,0 +1,4 @@
+import { LoanBaseModule } from "../common/loanBase.js";
+import { ILoanV1 } from "../../interfaces/v1/loanV1";
+export declare class LoanV1Module extends LoanBaseModule implements ILoanV1 {
+}

package/lib/lendMarkets/modules/v1/loanV1.js

@@ -0,0 +1,3 @@
+import { LoanBaseModule } from "../common/loanBase.js";
+export class LoanV1Module extends LoanBaseModule {
+}

package/lib/lendMarkets/modules/v1/statsV1.d.ts

@@ -0,0 +1,3 @@
+import { StatsBaseModule } from "../common/statsBase.js";
+export declare class StatsV1Module extends StatsBaseModule {
+}

package/lib/lendMarkets/modules/v1/statsV1.js

@@ -0,0 +1,3 @@
+import { StatsBaseModule } from "../common/statsBase.js";
+export class StatsV1Module extends StatsBaseModule {
+}

package/lib/lendMarkets/modules/v2/index.d.ts

@@ -0,0 +1,4 @@
+export { LoanV2Module } from './loanV2';
+export { LeverageV2ZapV1Module } from './leverageV2ZapV1';
+export { LeverageV2ZapV2Module } from './leverageV2ZapV2';
+export { StatsV2Module } from './statsV2';

package/lib/lendMarkets/modules/v2/index.js

@@ -0,0 +1,4 @@
+export { LoanV2Module } from './loanV2';
+export { LeverageV2ZapV1Module } from './leverageV2ZapV1';
+export { LeverageV2ZapV2Module } from './leverageV2ZapV2';
+export { StatsV2Module } from './statsV2';