@curvefi/llamalend-api 2.0.3 → 2.0.5

package/lib/lendMarkets/utils.d.ts

@@ -0,0 +1,14 @@
+import { INetworkName, IMarketData, IMarketDataAPI } from "../interfaces";
+export type RatesResult = {
+    borrowApr: string;
+    lendApr: string;
+    borrowApy: string;
+    lendApy: string;
+};
+/**
+ * Computes borrow/lend APR and APY from a raw per-second rate and current debt/cap.
+ * borrowApy = e^(rate * 365 * 86400) - 1
+ * lendApy   = (debt * e^(rate * 365 * 86400) - debt) / cap
+ */
+export declare const computeRatesFromRate: (_rate: bigint, debt: string | number, cap: string | number) => RatesResult;
+export declare const fetchMarketDataByVault: (networkName: INetworkName, vaultAddress: string, getData: (network: INetworkName) => Promise<IMarketData>) => Promise<IMarketDataAPI>;

package/lib/lendMarkets/utils.js

@@ -0,0 +1,33 @@
+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 { BN, toBN } from "../utils";
+/**
+ * Computes borrow/lend APR and APY from a raw per-second rate and current debt/cap.
+ * borrowApy = e^(rate * 365 * 86400) - 1
+ * lendApy   = (debt * e^(rate * 365 * 86400) - debt) / cap
+ */
+export const computeRatesFromRate = (_rate, debt, cap) => {
+    const annualFactor = toBN(_rate).times(365).times(86400);
+    const expFactor = Math.pow(Math.E, annualFactor.toNumber());
+    const borrowApr = annualFactor.times(100).toString();
+    const borrowApy = String((expFactor - 1) * 100);
+    const lendAprRaw = annualFactor.times(debt).div(cap).times(100);
+    const lendApr = lendAprRaw.isNaN() ? "0" : lendAprRaw.toString();
+    const lendApyRaw = BN(debt).times(expFactor).minus(debt).div(cap).times(100);
+    const lendApy = lendApyRaw.isNaN() ? "0" : lendApyRaw.toString();
+    return { borrowApr, lendApr, borrowApy, lendApy };
+};
+export const fetchMarketDataByVault = (networkName, vaultAddress, getData) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield getData(networkName);
+    const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === vaultAddress.toLowerCase());
+    if (!market)
+        throw new Error("Market not found in API");
+    return market;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/llamalend-api",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "JavaScript library for Curve Lending",
   "main": "lib/index.js",
   "author": "Macket",

package/src/interfaces.ts

@@ -193,6 +193,7 @@ export interface IMarketDataAPI {
     totalSupplied: Total;
     borrowed: Total;
     availableToBorrow: Total;
+    borrowCap: Total;
     lendingVaultUrls: LendingVaultUrls;
     usdTotal: number;
     ammBalances: AmmBalances;

package/src/lendMarkets/LendMarketTemplate.ts

@@ -166,20 +166,21 @@ export class LendMarketTemplate<V extends 'v1' | 'v2' = 'v1' | 'v2'> {
         }
 
         this.stats = {
-            parameters: stats.statsParameters.bind(this),
-            rates: stats.statsRates.bind(this),
-            futureRates: stats.statsFutureRates.bind(this),
-            balances: stats.statsBalances.bind(this),
-            bandsInfo: stats.statsBandsInfo.bind(this),
-            bandBalances: stats.statsBandBalances.bind(this),
-            bandsBalances: stats.statsBandsBalances.bind(this),
-            totalDebt: stats.statsTotalDebt.bind(this),
-            ammBalances: stats.statsAmmBalances.bind(this),
-            capAndAvailable: stats.statsCapAndAvailable.bind(this),
+            parameters: stats.statsParameters.bind(stats),
+            rates: stats.statsRates.bind(stats),
+            futureRates: stats.statsFutureRates.bind(stats),
+            balances: stats.statsBalances.bind(stats),
+            bandsInfo: stats.statsBandsInfo.bind(stats),
+            bandBalances: stats.statsBandBalances.bind(stats),
+            bandsBalances: stats.statsBandsBalances.bind(stats),
+            totalDebt: stats.statsTotalDebt.bind(stats),
+            ammBalances: stats.statsAmmBalances.bind(stats),
+            capAndAvailable: stats.statsCapAndAvailable.bind(stats),
+            adminPercentage: stats.statsAdminPercentage.bind(stats),
         } as StatsForVersion<V>
 
         this.wallet = {
-            balances: wallet.balances.bind(this),
+            balances: wallet.balances.bind(wallet),
         }
 
         this.prices = {

package/src/lendMarkets/interfaces/v1/statsV1.ts

@@ -17,5 +17,6 @@ export interface IStatsV1 {
     bandsBalances: () => Promise<{ [index: number]: { borrowed: string, collateral: string } }>,
     totalDebt: (isGetter?: boolean, useAPI?: boolean) => Promise<string>,
     ammBalances: (isGetter?: boolean, useAPI?: boolean) => Promise<{ borrowed: string, collateral: string }>,
-    capAndAvailable: (isGetter?: boolean, useAPI?: boolean) => Promise<{ cap: string, available: string }>,
+    capAndAvailable: (isGetter?: boolean, useAPI?: boolean) => Promise<{ borrowCap: string, available: string, totalAssets: string, availableForBorrow: string }>,
+    adminPercentage: () => Promise<string>,
 }

package/src/lendMarkets/interfaces/v2/statsV2.ts

@@ -17,5 +17,6 @@ export interface IStatsV2 {
     bandsBalances: () => Promise<{ [index: number]: { borrowed: string, collateral: string } }>,
     totalDebt: (isGetter?: boolean, useAPI?: boolean) => Promise<string>,
     ammBalances: (isGetter?: boolean, useAPI?: boolean) => Promise<{ borrowed: string, collateral: string }>,
-    capAndAvailable: (isGetter?: boolean, useAPI?: boolean) => Promise<{ cap: string, available: string }>,
+    capAndAvailable: (isGetter?: boolean, useAPI?: boolean) => Promise<{ borrowCap: string, available: string, totalAssets: string, availableForBorrow: string }>,
+    adminPercentage: () => Promise<string>,
 }

package/src/lendMarkets/modules/common/statsBase.ts

@@ -1,9 +1,8 @@
 import memoize from "memoizee";
-import {TAmount} from "../../../interfaces";
+import {TAmount, IMarketDataAPI} from "../../../interfaces";
 import type { LendMarketTemplate } from "../../LendMarketTemplate";
 import {
     parseUnits,
-    BN,
     toBN,
     formatUnits,
     formatNumber,
@@ -11,6 +10,8 @@ import {
 import {Llamalend} from "../../../llamalend";
 import {_getMarketsData} from "../../../external-api";
 import {cacheKey, cacheStats} from "../../../cache";
+import { computeRatesFromRate, fetchMarketDataByVault } from "../../utils";
+const PRECISION = BigInt("1000000000000000000"); // 1e18
 
 export class StatsBaseModule {
     protected market: LendMarketTemplate;
@@ -21,6 +22,63 @@ export class StatsBaseModule {
         this.llamalend = market.getLlamalend();
     }
 
+    protected async _fetchMarketDataFromAPI(): Promise<IMarketDataAPI> {
+        return fetchMarketDataByVault(
+            this.llamalend.constants.NETWORK_NAME,
+            this.market.addresses.vault,
+            _getMarketsData
+        );
+    }
+
+    protected _fetchAdminPercentage = async (): Promise<bigint> => {
+        return BigInt(0)
+    }
+
+    protected _fetchAdminFee = async (): Promise<bigint> => {
+        return this.llamalend.contracts[this.market.addresses.amm].contract.admin_fee(this.llamalend.constantOptions);
+    }
+
+    protected async _getAdminFeesXY(isGetter: boolean): Promise<[bigint, bigint]> {
+        if(isGetter) {
+            return [
+                cacheStats.get(cacheKey(this.market.addresses.amm, 'admin_fees_x')),
+                cacheStats.get(cacheKey(this.market.addresses.amm, 'admin_fees_y')),
+            ];
+        }
+        const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        const [_fee_x, _fee_y] = await this.llamalend.multicallProvider.all([
+            ammContract.admin_fees_x(),
+            ammContract.admin_fees_y(),
+        ]) as [bigint, bigint];
+        cacheStats.set(cacheKey(this.market.addresses.amm, 'admin_fees_x'), _fee_x);
+        cacheStats.set(cacheKey(this.market.addresses.amm, 'admin_fees_y'), _fee_y);
+        return [_fee_x, _fee_y];
+    }
+
+    private _getRate = async (isGetter = true): Promise<bigint> => {
+        if (isGetter) {
+            const _rate: bigint = cacheStats.get(cacheKey(this.market.addresses.amm, 'rate'));
+            const _adminPercentage = await this._fetchAdminPercentage();
+            return _rate * (PRECISION - _adminPercentage) / PRECISION;
+        } else {
+            const [_rate, _adminPercentage] = await Promise.all([
+                this.llamalend.contracts[this.market.addresses.amm].contract.rate(this.llamalend.constantOptions),
+                this._fetchAdminPercentage(),
+            ]);
+            cacheStats.set(cacheKey(this.market.addresses.controller, 'rate'), _rate);
+            return _rate * (PRECISION - _adminPercentage) / PRECISION;
+        }
+    }
+
+    private _getFutureRate = async (_dReserves: bigint, _dDebt: bigint): Promise<bigint> => {
+        const mpContract = this.llamalend.contracts[this.market.addresses.monetary_policy].contract;
+        const [_rate, _adminPercentage] = await Promise.all([
+            mpContract.future_rate(this.market.addresses.controller, _dReserves, _dDebt),
+            this._fetchAdminPercentage(),
+        ]);
+        return _rate * (PRECISION - _adminPercentage) / PRECISION;
+    }
+
     public statsParameters = memoize(async (): Promise<{
         fee: string, // %
         admin_fee: string, // %
@@ -32,16 +90,17 @@ export class StatsBaseModule {
         const llammaContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
         const controllerContract = this.llamalend.contracts[this.market.addresses.controller].multicallContract;
 
-        const calls = [
-            llammaContract.fee(),
-            llammaContract.admin_fee(), // TODO: removed
-            controllerContract.liquidation_discount(),
-            controllerContract.loan_discount(),
-            llammaContract.get_base_price(),
-            llammaContract.A(),
-        ]
+        const [[_fee, _liquidation_discount, _loan_discount, _base_price, _A], _admin_fee] = await Promise.all([
+            this.llamalend.multicallProvider.all([
+                llammaContract.fee(),
+                controllerContract.liquidation_discount(),
+                controllerContract.loan_discount(),
+                llammaContract.get_base_price(),
+                llammaContract.A(),
+            ]),
+            this._fetchAdminFee(),
+        ]) as [bigint[], bigint];
 
-        const [_fee, _admin_fee, _liquidation_discount, _loan_discount, _base_price, _A]: bigint[] = await this.llamalend.multicallProvider.all(calls) as bigint[];
         const A = formatUnits(_A, 0)
         const base_price = formatUnits(_base_price)
         const [fee, admin_fee, liquidation_discount, loan_discount] = [_fee, _admin_fee, _liquidation_discount, _loan_discount]
@@ -53,55 +112,20 @@ export class StatsBaseModule {
         maxAge: 5 * 60 * 1000, // 5m
     });
 
-    private _getRate = async (isGetter = true): Promise<bigint> => {
-        let _rate;
-        if(isGetter) {
-            _rate = cacheStats.get(cacheKey(this.market.addresses.amm, 'rate'));
-        } else {
-            _rate = await this.llamalend.contracts[this.market.addresses.amm].contract.rate(this.llamalend.constantOptions);
-            cacheStats.set(cacheKey(this.market.addresses.controller, 'rate'), _rate);
-        }
-        return _rate;
-    }
-
-    private _getFutureRate = async (_dReserves: bigint, _dDebt: bigint): Promise<bigint> => {
-        const mpContract = this.llamalend.contracts[this.market.addresses.monetary_policy].contract;
-        return await mpContract.future_rate(this.market.addresses.controller, _dReserves, _dDebt);
-    }
-
     public async statsRates(isGetter = true, useAPI = false): Promise<{borrowApr: string, lendApr: string, borrowApy: string, lendApy: string}> {
         if(useAPI) {
-            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
-
-            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
-
-            if(market) {
-                return {
-                    borrowApr: (market.rates.borrowApr * 100).toString(),
-                    lendApr: (market.rates.lendApr * 100).toString(),
-                    borrowApy: (market.rates.borrowApy * 100).toString(),
-                    lendApy: (market.rates.lendApy * 100).toString(),
-                }
-            } else {
-                throw new Error('Market not found in API')
-            }
+            const market = await this._fetchMarketDataFromAPI();
+            return {
+                borrowApr: (market.rates.borrowApr * 100).toString(),
+                lendApr: (market.rates.lendApr * 100).toString(),
+                borrowApy: (market.rates.borrowApy * 100).toString(),
+                lendApy: (market.rates.lendApy * 100).toString(),
+            };
         } else {
             const _rate = await this._getRate(isGetter);
-            const borrowApr =  toBN(_rate).times(365).times(86400).times(100).toString();
-            // borrowApy = e**(rate*365*86400) - 1
-            const borrowApy = String(((2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber()) - 1) * 100);
-            let lendApr = "0";
-            let lendApy = "0";
-            const debt = await this.statsTotalDebt(isGetter);
-            if (Number(debt) > 0) {
-                const { cap } = await this.statsCapAndAvailable(isGetter);
-                lendApr = toBN(_rate).times(365).times(86400).times(debt).div(cap).times(100).toString();
-                // lendApy = (debt * e**(rate*365*86400) - debt) / cap
-                const debtInAYearBN = BN(debt).times(2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber());
-                lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
-            }
-
-            return { borrowApr, lendApr, borrowApy, lendApy }
+            const debt = await this.statsTotalDebt(isGetter, false);
+            const { totalAssets } = Number(debt) > 0 ? await this.statsCapAndAvailable(isGetter, false) : { totalAssets: "0" };
+            return computeRatesFromRate(_rate, debt, totalAssets);
         }
     }
 
@@ -109,34 +133,22 @@ export class StatsBaseModule {
         const _dReserves = parseUnits(dReserves, this.market.borrowed_token.decimals);
         const _dDebt = parseUnits(dDebt, this.market.borrowed_token.decimals);
         const _rate = await this._getFutureRate(_dReserves, _dDebt);
-        const borrowApr =  toBN(_rate).times(365).times(86400).times(100).toString();
-        // borrowApy = e**(rate*365*86400) - 1
-        const borrowApy = String(((2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber()) - 1) * 100);
-        let lendApr = "0";
-        let lendApy = "0";
         const debt = Number(await this.statsTotalDebt()) + Number(dDebt);
-        if (Number(debt) > 0) {
-            const cap = Number((await this.statsCapAndAvailable(true, useAPI)).cap) + Number(dReserves);
-            lendApr = toBN(_rate).times(365).times(86400).times(debt).div(cap).times(100).toString();
-            // lendApy = (debt * e**(rate*365*86400) - debt) / cap
-            const debtInAYearBN = BN(debt).times(2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber());
-            lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
-        }
-
-        return { borrowApr, lendApr, borrowApy, lendApy }
+        const cap = Number((await this.statsCapAndAvailable(true, useAPI)).totalAssets) + Number(dReserves);
+        return computeRatesFromRate(_rate, debt, cap);
     }
 
     public async statsBalances(): Promise<[string, string]> {
         const borrowedContract = this.llamalend.contracts[this.market.borrowed_token.address].multicallContract;
         const collateralContract = this.llamalend.contracts[this.market.collateral_token.address].multicallContract;
-        const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
-        const calls = [
-            borrowedContract.balanceOf(this.market.addresses.amm),
-            collateralContract.balanceOf(this.market.addresses.amm),
-            ammContract.admin_fees_x(), // TODO: always 0
-            ammContract.admin_fees_y(), // TODO: always 0
-        ]
-        const [_borrowedBalance, _collateralBalance, _borrowedAdminFees, _collateralAdminFees]: bigint[] = await this.llamalend.multicallProvider.all(calls);
+
+        const [[_borrowedBalance, _collateralBalance], [_borrowedAdminFees, _collateralAdminFees]] = await Promise.all([
+            this.llamalend.multicallProvider.all([
+                borrowedContract.balanceOf(this.market.addresses.amm),
+                collateralContract.balanceOf(this.market.addresses.amm),
+            ]),
+            this._getAdminFeesXY(false),
+        ]) as [bigint[], [bigint, bigint]];
 
         return [
             formatUnits(_borrowedBalance - _borrowedAdminFees, this.market.borrowed_token.decimals),
@@ -202,15 +214,8 @@ export class StatsBaseModule {
 
     public async statsTotalDebt(isGetter = true, useAPI = true): Promise<string> {
         if(useAPI) {
-            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
-
-            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
-
-            if(market) {
-                return market.borrowed.total.toString();
-            } else {
-                throw new Error('Market not found in API')
-            }
+            const market = await this._fetchMarketDataFromAPI();
+            return market.borrowed.total.toString();
         } else {
             let _debt;
             if(isGetter) {
@@ -226,42 +231,32 @@ export class StatsBaseModule {
 
     public statsAmmBalances = async (isGetter = true, useAPI = false): Promise<{ borrowed: string, collateral: string }> => {
         if(useAPI) {
-            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
-
-            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
-
-            if(market) {
-                return {
-                    borrowed: market.ammBalances.ammBalanceBorrowed.toString(),
-                    collateral: market.ammBalances.ammBalanceCollateral.toString(),
-                }
-            } else {
-                throw new Error('Market not found in API')
-            }
+            const market = await this._fetchMarketDataFromAPI();
+            return {
+                borrowed: market.ammBalances.ammBalanceBorrowed.toString(),
+                collateral: market.ammBalances.ammBalanceCollateral.toString(),
+            };
         } else {
             const borrowedContract = this.llamalend.contracts[this.market.addresses.borrowed_token].multicallContract;
             const collateralContract = this.llamalend.contracts[this.market.addresses.collateral_token].multicallContract;
-            const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
 
-            let _balance_x, _fee_x, _balance_y, _fee_y; // TODO: fees are always 0
+            let _balance_x: bigint, _balance_y: bigint;
+            let _fee_x: bigint, _fee_y: bigint;
+
             if(isGetter) {
-                [_balance_x, _fee_x, _balance_y, _fee_y] = [
-                    cacheStats.get(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.amm)),
-                    cacheStats.get(cacheKey(this.market.addresses.amm, 'admin_fees_x')),
-                    cacheStats.get(cacheKey(this.market.addresses.collateral_token, 'balanceOf', this.market.addresses.amm)),
-                    cacheStats.get(cacheKey(this.market.addresses.amm, 'admin_fees_y')),
-                ]
+                _balance_x = cacheStats.get(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.amm));
+                _balance_y = cacheStats.get(cacheKey(this.market.addresses.collateral_token, 'balanceOf', this.market.addresses.amm));
+                [_fee_x, _fee_y] = await this._getAdminFeesXY(true);
             } else {
-                [_balance_x, _fee_x, _balance_y, _fee_y] = await this.llamalend.multicallProvider.all([
-                    borrowedContract.balanceOf(this.market.addresses.amm),
-                    ammContract.admin_fees_x(),
-                    collateralContract.balanceOf(this.market.addresses.amm),
-                    ammContract.admin_fees_y(),
-                ]);
+                [[_balance_x, _balance_y], [_fee_x, _fee_y]] = await Promise.all([
+                    this.llamalend.multicallProvider.all([
+                        borrowedContract.balanceOf(this.market.addresses.amm),
+                        collateralContract.balanceOf(this.market.addresses.amm),
+                    ]),
+                    this._getAdminFeesXY(false),
+                ]) as [[bigint, bigint], [bigint, bigint]];
                 cacheStats.set(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.amm), _balance_x);
-                cacheStats.set(cacheKey(this.market.addresses.amm, 'admin_fees_x'), _fee_x);
                 cacheStats.set(cacheKey(this.market.addresses.collateral_token, 'balanceOf', this.market.addresses.amm), _balance_y);
-                cacheStats.set(cacheKey(this.market.addresses.amm, 'admin_fees_y'), _fee_y);
             }
 
             return {
@@ -271,43 +266,49 @@ export class StatsBaseModule {
         }
     }
 
-    public async statsCapAndAvailable(isGetter = true, useAPI = false): Promise<{ cap: string, available: string }> {
-        if(useAPI) {
-            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
+    protected async _statsCapAndAvailableFromAPI(): Promise<{ borrowCap: string, available: string, totalAssets: string, availableForBorrow: string }> {
+        const market = await this._fetchMarketDataFromAPI();
+        return {
+            totalAssets: market.totalSupplied.total.toString(),
+            borrowCap: Infinity.toString(),
+            available: market.availableToBorrow.total.toString(),
+            availableForBorrow: market.availableToBorrow.total.toString(),
+        };
+    }
 
-            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
+    protected async _statsCapAndAvailableOnChain(isGetter: boolean): Promise<{ borrowCap: string, available: string, totalAssets: string, availableForBorrow: string }> {
+        const vaultContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
+        const borrowedContract = this.llamalend.contracts[this.market.addresses.borrowed_token].multicallContract;
 
-            if(market) {
-                return {
-                    cap: market.totalSupplied.total.toString(),
-                    available: market.availableToBorrow.total.toString(),
-                }
-            } else {
-                throw new Error('Market not found in API')
-            }
+        let _cap, _available;
+        if(isGetter) {
+            _cap = cacheStats.get(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller));
+            _available = cacheStats.get(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.controller));
         } else {
-            const vaultContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
-            const borrowedContract = this.llamalend.contracts[this.market.addresses.borrowed_token].multicallContract;
-
-            let _cap, _available;
-            if(isGetter) { // TODO: should call controller.available_balance() instead of borrowed_token.balanceOf(controller)
-                _cap = cacheStats.get(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller));
-                _available = cacheStats.get(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.controller));
-            } else {
-                [_cap, _available] =await this.llamalend.multicallProvider.all([
-                    vaultContract.totalAssets(this.market.addresses.controller),
-                    borrowedContract.balanceOf(this.market.addresses.controller),
-                ]);
-                cacheStats.set(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller), _cap);
-                cacheStats.set(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.controller), _available);
-            }
+            [_cap, _available] = await this.llamalend.multicallProvider.all([
+                vaultContract.totalAssets(this.market.addresses.controller),
+                borrowedContract.balanceOf(this.market.addresses.controller),
+            ]);
+            cacheStats.set(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller), _cap);
+            cacheStats.set(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.controller), _available);
+        }
 
-            return {
-                cap: this.llamalend.formatUnits(_cap, this.market.borrowed_token.decimals),
-                available: this.llamalend.formatUnits(_available, this.market.borrowed_token.decimals),
-            }
-            // cap -> totalAssets
-            // add cap: controller.borrow_cap() // Display
+        const available = this.llamalend.formatUnits(_available, this.market.borrowed_token.decimals);
+        return {
+            totalAssets: this.llamalend.formatUnits(_cap, this.market.borrowed_token.decimals),
+            borrowCap: Infinity.toString(),
+            available,
+            availableForBorrow: available,
         }
     }
+
+    public async statsCapAndAvailable(isGetter = true, useAPI = false): Promise<{ borrowCap: string, available: string, totalAssets: string, availableForBorrow: string }> {
+        if(useAPI) return this._statsCapAndAvailableFromAPI();
+        return this._statsCapAndAvailableOnChain(isGetter);
+    }
+
+    public statsAdminPercentage = async (): Promise<string> => {
+        const _adminPercentage = await this._fetchAdminPercentage();
+        return formatUnits(_adminPercentage * BigInt(100));
+    }
 }

package/src/lendMarkets/modules/common/vault.ts

@@ -289,10 +289,10 @@ export class VaultModule {
     }
 
     public async vaultTotalLiquidity(useAPI = true): Promise<string> {
-        const { cap } = await this.market.stats.capAndAvailable(true, useAPI);
+        const { totalAssets } = await this.market.stats.capAndAvailable(true, useAPI);
         const price = await _getUsdRate.call(this.llamalend, this.market.addresses.borrowed_token);
 
-        return BN(cap).times(price).toFixed(6)
+        return BN(totalAssets).times(price).toFixed(6)
     }
 
     private _calcCrvApr = async (futureWorkingSupplyBN: BigNumber | null = null): Promise<[baseApy: number, boostedApy: number]> => {

package/src/lendMarkets/modules/v2/statsV2.ts

@@ -1,3 +1,61 @@
+import memoize from "memoizee";
 import { StatsBaseModule } from "../common/statsBase.js";
+import {cacheKey, cacheStats} from "../../../cache";
+import BigNumber from "bignumber.js";
+import {BN} from "../../../utils";
 
-export class StatsV2Module extends StatsBaseModule {}
+export class StatsV2Module extends StatsBaseModule {
+    protected _fetchAdminPercentage = memoize(async (): Promise<bigint> => {
+        return await this.llamalend.contracts[this.market.addresses.controller].contract.admin_percentage(this.llamalend.constantOptions);
+    }, {
+        promise: true,
+        maxAge: 30 * 60 * 1000, // 30m
+    });
+
+    protected _fetchAdminFee = async (): Promise<bigint> => BigInt(0);
+
+    protected _getAdminFeesXY = async (): Promise<[bigint, bigint]> => [BigInt(0), BigInt(0)];
+
+    protected async _statsCapAndAvailableFromAPI() {
+        const market = await this._fetchMarketDataFromAPI();
+        return {
+            totalAssets: market.totalSupplied.total.toString(),
+            borrowCap: market.borrowCap.total.toString(),
+            available: market.availableToBorrow.total.toString(),
+            availableForBorrow: market.availableToBorrow.total.toString(),
+        };
+    }
+
+    protected async _statsCapAndAvailableOnChain(isGetter: boolean): Promise<{ borrowCap: string, available: string, totalAssets: string, availableForBorrow: string }> {
+        const vaultContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
+        const controllerContract = this.llamalend.contracts[this.market.addresses.controller].multicallContract;
+
+        let _cap: bigint, _available: bigint, _totalAssets: bigint, _totalDebt: bigint;
+        if(isGetter) {
+            _totalAssets = cacheStats.get(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller));
+            _cap = cacheStats.get(cacheKey(this.market.addresses.controller, 'borrow_cap'));
+            _available = cacheStats.get(cacheKey(this.market.addresses.controller, 'available_balance'));
+            _totalDebt = cacheStats.get(cacheKey(this.market.addresses.controller, 'total_debt'));
+        } else {
+            [_totalAssets, _available, _cap, _totalDebt] = await this.llamalend.multicallProvider.all([
+                vaultContract.totalAssets(this.market.addresses.controller),
+                controllerContract.available_balance(),
+                controllerContract.borrow_cap(),
+                controllerContract.total_debt(),
+            ]);
+
+            cacheStats.set(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller), _totalAssets);
+            cacheStats.set(cacheKey(this.market.addresses.controller, 'borrow_cap'), _cap);
+            cacheStats.set(cacheKey(this.market.addresses.controller, 'available_balance'), _available);
+            cacheStats.set(cacheKey(this.market.addresses.controller, 'total_debt'), _totalDebt);
+        }
+
+        const totalAssets = this.llamalend.formatUnits(_totalAssets, this.market.borrowed_token.decimals);
+        const borrowCap = this.llamalend.formatUnits(_cap, this.market.borrowed_token.decimals);
+        const available = this.llamalend.formatUnits(_available, this.market.borrowed_token.decimals);
+        const totalDebt = this.llamalend.formatUnits(_totalDebt, this.market.borrowed_token.decimals);
+        const availableForBorrow = BigNumber.min(BN(available), BN(borrowCap).minus(BN(totalDebt))).toFixed();
+
+        return { totalAssets, borrowCap, available, availableForBorrow }
+    }
+}

package/src/lendMarkets/utils.ts

@@ -0,0 +1,46 @@
+import { BN, toBN } from "../utils";
+import { INetworkName, IMarketData, IMarketDataAPI } from "../interfaces";
+
+export type RatesResult = {
+    borrowApr: string;
+    lendApr: string;
+    borrowApy: string;
+    lendApy: string;
+};
+
+/**
+ * Computes borrow/lend APR and APY from a raw per-second rate and current debt/cap.
+ * borrowApy = e^(rate * 365 * 86400) - 1
+ * lendApy   = (debt * e^(rate * 365 * 86400) - debt) / cap
+ */
+export const computeRatesFromRate = (
+    _rate: bigint,
+    debt: string | number,
+    cap: string | number
+): RatesResult => {
+    const annualFactor = toBN(_rate).times(365).times(86400);
+    const expFactor = Math.E ** annualFactor.toNumber();
+
+    const borrowApr = annualFactor.times(100).toString();
+    const borrowApy = String((expFactor - 1) * 100);
+
+    const lendAprRaw = annualFactor.times(debt).div(cap).times(100);
+    const lendApr = lendAprRaw.isNaN() ? "0" : lendAprRaw.toString();
+    const lendApyRaw = BN(debt).times(expFactor).minus(debt).div(cap).times(100);
+    const lendApy = lendApyRaw.isNaN() ? "0" : lendApyRaw.toString();
+
+    return { borrowApr, lendApr, borrowApy, lendApy };
+}
+
+export const fetchMarketDataByVault = async (
+    networkName: INetworkName,
+    vaultAddress: string,
+    getData: (network: INetworkName) => Promise<IMarketData>
+): Promise<IMarketDataAPI> => {
+    const response = await getData(networkName);
+    const market = response.lendingVaultData.find(
+        (item) => item.address.toLowerCase() === vaultAddress.toLowerCase()
+    );
+    if (!market) throw new Error("Market not found in API");
+    return market;
+}