@curvefi/llamalend-api 1.1.10 → 2.0.0

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

@@ -0,0 +1,223 @@
+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 { BN, formatUnits, _getAddress, toBN, } from "../../../utils";
+import { _getUserCollateral, _getUserCollateralForce } from "../../../external-api";
+export class UserPositionModule {
+    constructor(market) {
+        this._userState = memoize((...args_1) => __awaiter(this, [...args_1], void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            const contract = this.llamalend.contracts[this.market.addresses.controller].contract;
+            const [_collateral, _borrowed, _debt, _N] = yield contract.user_state(address, this.llamalend.constantOptions);
+            return { _collateral, _borrowed, _debt, _N };
+        }), {
+            promise: true,
+            maxAge: 10 * 1000, // 10s
+        });
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    userLoanExists() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            return yield this.llamalend.contracts[this.market.addresses.controller].contract.loan_exists(address, this.llamalend.constantOptions);
+        });
+    }
+    userState() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            const { _collateral, _borrowed, _debt, _N } = yield this._userState(address);
+            return {
+                collateral: formatUnits(_collateral, this.market.collateral_token.decimals),
+                borrowed: formatUnits(_borrowed, this.market.borrowed_token.decimals),
+                debt: formatUnits(_debt, this.market.borrowed_token.decimals),
+                N: formatUnits(_N, 0),
+            };
+        });
+    }
+    userStateBigInt() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            return yield this._userState(address);
+        });
+    }
+    userHealth() {
+        return __awaiter(this, arguments, void 0, function* (full = true, address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            let _health = yield this.llamalend.contracts[this.market.addresses.controller].contract.health(address, full, this.llamalend.constantOptions);
+            _health = _health * BigInt(100);
+            return formatUnits(_health);
+        });
+    }
+    _userBands(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            address = _getAddress.call(this.llamalend, address);
+            const _bands = yield this.llamalend.contracts[this.market.addresses.amm].contract.read_user_tick_numbers(address, this.llamalend.constantOptions);
+            return Array.from(_bands).reverse();
+        });
+    }
+    userBands() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            return (yield this._userBands(address)).map((_t) => Number(_t));
+        });
+    }
+    userBandsBigInt() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            return yield this._userBands(address);
+        });
+    }
+    userRange() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            const [n2, n1] = yield this.userBands(address);
+            if (n1 == n2)
+                return 0;
+            return n2 - n1 + 1;
+        });
+    }
+    userPrices() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            const _prices = yield this.llamalend.contracts[this.market.addresses.controller].contract.user_prices(address, this.llamalend.constantOptions);
+            return _prices.map((_p) => formatUnits(_p)).reverse();
+        });
+    }
+    userLoss() {
+        return __awaiter(this, arguments, void 0, function* (userAddress = "") {
+            userAddress = _getAddress.call(this.llamalend, userAddress);
+            const [userCollateral, _current_collateral_estimation] = yield Promise.all([
+                _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress),
+                this.llamalend.contracts[this.market.addresses.amm].contract.get_y_up(userAddress),
+            ]);
+            const deposited_collateral = userCollateral.total_deposit_precise;
+            const current_collateral_estimation = this.llamalend.formatUnits(_current_collateral_estimation, this.market.collateral_token.decimals);
+            if (BN(deposited_collateral).lte(0)) {
+                return {
+                    deposited_collateral,
+                    current_collateral_estimation,
+                    loss: "0.0",
+                    loss_pct: "0.0",
+                };
+            }
+            const loss = BN(deposited_collateral).minus(current_collateral_estimation).toString();
+            const loss_pct = BN(loss).div(deposited_collateral).times(100).toString();
+            return {
+                deposited_collateral,
+                current_collateral_estimation,
+                loss,
+                loss_pct,
+            };
+        });
+    }
+    userBandsBalances() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            const [n2, n1] = yield this.userBands(address);
+            if (n1 == 0 && n2 == 0)
+                return {};
+            address = _getAddress.call(this.llamalend, address);
+            const contract = this.llamalend.contracts[this.market.addresses.amm].contract;
+            const [_borrowed, _collateral] = yield contract.get_xy(address, this.llamalend.constantOptions);
+            const res = {};
+            for (let i = n1; i <= n2; i++) {
+                res[i] = {
+                    collateral: formatUnits(_collateral[i - n1], this.market.collateral_token.decimals),
+                    borrowed: formatUnits(_borrowed[i - n1], this.market.borrowed_token.decimals),
+                };
+            }
+            return res;
+        });
+    }
+    currentLeverage() {
+        return __awaiter(this, arguments, void 0, function* (userAddress = '') {
+            userAddress = _getAddress.call(this.llamalend, userAddress);
+            const [userCollateral, { collateral }] = yield Promise.all([
+                _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress),
+                this.userState(userAddress),
+            ]);
+            const total_deposit_from_user = userCollateral.total_deposit_from_user_precise;
+            return BN(collateral).div(total_deposit_from_user).toString();
+        });
+    }
+    currentPnL() {
+        return __awaiter(this, arguments, void 0, function* (userAddress = '') {
+            userAddress = _getAddress.call(this.llamalend, userAddress);
+            const calls = [
+                this.llamalend.contracts[this.market.addresses.controller].multicallContract.user_state(userAddress, this.llamalend.constantOptions),
+                this.llamalend.contracts[this.market.addresses.amm].multicallContract.price_oracle(userAddress),
+            ];
+            const [userState, oraclePrice] = yield this.llamalend.multicallProvider.all(calls);
+            if (!(userState || oraclePrice)) {
+                throw new Error('Multicall error');
+            }
+            const debt = userState[2];
+            const userCollateral = yield _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress);
+            const totalDepositUsdValueFull = userCollateral.total_deposit_usd_value;
+            const totalDepositUsdValueUser = userCollateral.total_deposit_from_user_usd_value;
+            const totalBorrowed = userCollateral.total_borrowed;
+            const oraclePriceFormatted = this.llamalend.formatUnits(oraclePrice, 18);
+            const debtFormatted = this.llamalend.formatUnits(debt, 18);
+            const { _collateral: AmmCollateral, _borrowed: AmmBorrowed } = yield this._userState(userAddress);
+            const [AmmCollateralFormatted, AmmBorrowedFormatted] = [this.llamalend.formatUnits(AmmCollateral, this.market.collateral_token.decimals), this.llamalend.formatUnits(AmmBorrowed, this.market.borrowed_token.decimals)];
+            const a = BN(AmmCollateralFormatted).times(oraclePriceFormatted);
+            const b = BN(totalBorrowed).minus(debtFormatted);
+            const currentPosition = a.plus(AmmBorrowedFormatted).plus(b);
+            const currentProfit = currentPosition.minus(totalDepositUsdValueFull);
+            const percentage = currentProfit.div(totalDepositUsdValueUser).times(100);
+            return {
+                currentPosition: currentPosition.toFixed(this.market.borrowed_token.decimals).toString(),
+                deposited: totalDepositUsdValueUser.toString(),
+                currentProfit: currentProfit.toFixed(this.market.borrowed_token.decimals).toString(),
+                percentage: percentage.toFixed(2).toString(),
+            };
+        });
+    }
+    userBoost() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+                throw Error(`${this.market.name} doesn't have gauge`);
+            }
+            if (this.market.vault.rewardsOnly()) {
+                throw Error(`${this.market.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
+            }
+            address = _getAddress.call(this.llamalend, address);
+            const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+            const [workingBalanceBN, balanceBN] = (yield this.llamalend.multicallProvider.all([
+                gaugeContract.working_balances(address),
+                gaugeContract.balanceOf(address),
+            ])).map((value) => toBN(value));
+            if (balanceBN.isZero()) {
+                return '1.0';
+            }
+            const boostBN = workingBalanceBN.div(0.4).div(balanceBN);
+            if (boostBN.lt(1))
+                return '1.0';
+            if (boostBN.gt(2.5))
+                return '2.5';
+            return boostBN.toFixed(4).replace(/([0-9])0+$/, '$1');
+        });
+    }
+    getCurrentLeverageParams(userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [userCollateralData, { collateral: stateCollateral }] = yield Promise.all([
+                _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress),
+                this.userState(userAddress),
+            ]);
+            return {
+                stateCollateral,
+                totalDepositFromUser: String(userCollateralData.total_deposit_from_user_precise),
+            };
+        });
+    }
+    forceUpdateUserState(newTx, userAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = userAddress || this.llamalend.signerAddress;
+            if (!address)
+                throw Error("Need to connect wallet or pass address into args");
+            yield _getUserCollateralForce(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, address, newTx);
+        });
+    }
+}

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

@@ -0,0 +1,69 @@
+import memoize from "memoizee";
+import type { TAmount, TGas, IReward } from "../../../interfaces";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+export declare class VaultModule {
+    private market;
+    private llamalend;
+    constructor(market: LendMarketTemplate);
+    vaultMaxDeposit(address?: string): Promise<string>;
+    vaultPreviewDeposit(amount: TAmount): Promise<string>;
+    vaultDepositIsApproved(borrowed: TAmount): Promise<boolean>;
+    vaultDepositApproveEstimateGas(borrowed: TAmount): Promise<TGas>;
+    vaultDepositApprove(borrowed: TAmount): Promise<string[]>;
+    private _vaultDeposit;
+    vaultDepositEstimateGas(amount: TAmount): Promise<TGas>;
+    vaultDeposit(amount: TAmount): Promise<string>;
+    vaultMaxMint(address?: string): Promise<string>;
+    vaultPreviewMint(amount: TAmount): Promise<string>;
+    vaultMintIsApproved(borrowed: TAmount): Promise<boolean>;
+    vaultMintApproveEstimateGas(borrowed: TAmount): Promise<TGas>;
+    vaultMintApprove(borrowed: TAmount): Promise<string[]>;
+    private _vaultMint;
+    vaultMintEstimateGas(amount: TAmount): Promise<TGas>;
+    vaultMint(amount: TAmount): Promise<string>;
+    vaultMaxWithdraw(address?: string): Promise<string>;
+    vaultPreviewWithdraw(amount: TAmount): Promise<string>;
+    private _vaultWithdraw;
+    vaultWithdrawEstimateGas(amount: TAmount): Promise<TGas>;
+    vaultWithdraw(amount: TAmount): Promise<string>;
+    vaultMaxRedeem(address?: string): Promise<string>;
+    vaultPreviewRedeem(amount: TAmount): Promise<string>;
+    private _vaultRedeem;
+    vaultRedeemEstimateGas(amount: TAmount): Promise<TGas>;
+    vaultRedeem(amount: TAmount): Promise<string>;
+    vaultConvertToShares(assets: TAmount): Promise<string>;
+    vaultConvertToAssets(shares: TAmount): Promise<string>;
+    vaultStakeIsApproved(vaultShares: number | string): Promise<boolean>;
+    vaultStakeApproveEstimateGas(vaultShares: number | string): Promise<TGas>;
+    vaultStakeApprove(vaultShares: number | string): Promise<string[]>;
+    vaultStakeEstimateGas(vaultShares: number | string): Promise<TGas>;
+    vaultStake(vaultShares: number | string): Promise<string>;
+    vaultUnstakeEstimateGas(vaultShares: number | string): Promise<TGas>;
+    vaultUnstake(vaultShares: number | string): Promise<string>;
+    vaultRewardsOnly(): boolean;
+    vaultTotalLiquidity(useAPI?: boolean): Promise<string>;
+    private _calcCrvApr;
+    vaultCrvApr(): Promise<[baseApy: number, boostedApy: number]>;
+    vaultClaimableCrv(address?: string): Promise<string>;
+    private _vaultClaimCrv;
+    vaultClaimCrvEstimateGas(): Promise<TGas>;
+    vaultClaimCrv(): Promise<string>;
+    vaultRewardTokens: (() => Promise<{
+        token: string;
+        symbol: string;
+        decimals: number;
+    }[]>) & memoize.Memoized<() => Promise<{
+        token: string;
+        symbol: string;
+        decimals: number;
+    }[]>>;
+    vaultRewardsApr: (useApi?: boolean) => Promise<IReward[]>;
+    vaultClaimableRewards(address?: string): Promise<{
+        token: string;
+        symbol: string;
+        amount: string;
+    }[]>;
+    private _vaultClaimRewards;
+    vaultClaimRewardsEstimateGas(): Promise<TGas>;
+    vaultClaimRewards(): Promise<string>;
+}