@raac/rpc 1.2.0-beta.13 → 1.2.0-beta.14

package/dist/pools/lendingPool/getLendingPoolInfo.js

@@ -1,14 +1,38 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
 const _helpers_1 = require("./_helpers");
 const artifacts_1 = require("../../utils/artifacts");
+const getContractAddress_1 = __importDefault(require("../../contracts/getContractAddress"));
+const RAY = 10n ** 27n;
+const HALF_RAY = RAY / 2n;
+/** Mirrors WadRayMath.rayMul (half-up rounding). */
+const rayMul = (a, b) => (a * b + HALF_RAY) / RAY;
+/** A RAY-denominated annual rate as a percentage string, e.g. 5e25 -> "5.00". */
+const asPercent = (rate) => (Number(rate) / 1e25).toFixed(2);
+/** A RAY-denominated value as a unit decimal string, e.g. RAY -> "1.000000". */
+const asDecimal = (value) => (Number(value) / 1e27).toFixed(6);
+/**
+ * Effective yearly cost of a nominal RAY borrow rate: e^r - 1.
+ * The usage index compounds (ReserveLibrary.calculateCompoundedInterest), so the
+ * borrow side's effective rate exceeds its nominal rate. The liquidity index
+ * accrues linearly, so the supply side has no equivalent gap.
+ */
+const toCompoundedApy = (rate) => Math.expm1(Number(rate) / 1e27);
 async function getLendingPoolInfo(chainId, userAddress, provider) {
     try {
+        if (!provider) {
+            const rpc = chains_1.default[chainId].rpcs[0];
+            provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+        }
         const lendingPoolContract = await (0, _helpers_1.getLendingPoolContract)(chainId, provider);
         const handleError = (operation, returnType) => (error) => {
             if (error.code === "BAD_DATA") {
-                console.log(`BAD_DATA from ${operation} - Pool empty?`, error.messag);
+                console.log(`BAD_DATA from ${operation} - Pool empty?`, error.message);
                 return returnType || null;
             }
             throw error;
@@ -19,85 +43,93 @@ async function getLendingPoolInfo(chainId, userAddress, provider) {
             lendingPoolContract.getNormalizedIncome().catch(handleError("getNormalizedIncome", 0n)),
             lendingPoolContract.getNormalizedDebt().catch(handleError("getNormalizedDebt", 0n)),
         ]);
-        // Extract data from reserve
+        // Reserve state
         const totalLiquidity = reserve?.totalLiquidity ?? 0n;
         const totalUsage = reserve?.totalUsage ?? 0n;
         const liquidityIndex = reserve?.liquidityIndex ?? 0n;
         const usageIndex = reserve?.usageIndex ?? 0n;
-        // Compute utilization
-        let utilization = 0n;
-        if (totalLiquidity + totalUsage > 0n) {
-            utilization = (totalUsage * BigInt(1e27)) / (totalLiquidity + totalUsage);
-        }
-        // Extract rate data
-        const currentLiquidityRate = rateData?.currentLiquidityRate ?? 0n;
-        const currentUsageRate = rateData?.currentUsageRate ?? 0n;
-        // why is prime rate 0?
+        // Rates as maintained by the pool. These are written by
+        // ReserveLibrary.updateInterestRatesAndLiquidity on every operation that moves
+        // liquidity or debt, and interest accrues at them until the next one, so they
+        // are the rates actually in effect - not a stale snapshot to be recomputed.
+        const supplyRate = rateData?.currentLiquidityRate ?? 0n;
+        const borrowRate = rateData?.currentUsageRate ?? 0n;
+        const utilization = rateData?.currentUtilizationRate ?? 0n;
+        const currentProtocolFeeRate = rateData?.currentProtocolFeeRate ?? 0n;
+        // Rate curve parameters
         const primeRate = rateData?.primeRate ?? 0n;
         const baseRate = rateData?.baseRate ?? 0n;
         const optimalRate = rateData?.optimalRate ?? 0n;
         const maxRate = rateData?.maxRate ?? 0n;
         const optimalUtilizationRate = rateData?.optimalUtilizationRate ?? 0n;
         const protocolFeeRate = rateData?.protocolFeeRate ?? 0n;
-        const pendingProtocolFeeAmount = reserve?.[8];
-        // Compute APY
-        let apr;
-        if (utilization <= optimalUtilizationRate && optimalUtilizationRate > 0) {
-            apr = optimalRate;
-        }
-        else {
-            const excessUtilization = utilization - optimalUtilizationRate;
-            const maxExcessUtilization = BigInt(1e27) - optimalUtilizationRate;
-            const rateSlope = maxRate - optimalRate;
-            const rateIncrease = (excessUtilization * rateSlope) / maxExcessUtilization;
-            apr = primeRate + rateIncrease;
-            apr = apr > maxRate ? maxRate : apr;
-        }
-        // compute the APY
-        // FIXME: This is not correct
-        let apy;
-        const grossLiquidityRate = utilization * currentUsageRate / BigInt(1e27);
-        const protocolFeeAmount = grossLiquidityRate * protocolFeeRate / BigInt(1e27);
-        apy = grossLiquidityRate - protocolFeeAmount;
-        console.log("apr", apy);
+        const pendingProtocolFeeAmount = await getPendingProtocolFee(chainId, provider, reserve, normalizedIncome);
         let userRedeemable = 0n;
         if (userAddress) {
-            // Fetch user's scaled RToken balance
+            // RToken.balanceOf already applies the liquidity index, so it is the
+            // redeemable underlying amount - do not scale it again.
             const rTokenAddress = reserve?.reserveRTokenAddress;
             const rTokenABI = (0, artifacts_1.getABI)("rtoken");
             const rTokenContract = new ethers_1.ethers.Contract(rTokenAddress, rTokenABI, provider);
-            const userScaledBalance = await rTokenContract
-                .balanceOf(userAddress)
-                .catch(handleError("rToken balanceOf"));
-            // Compute user's redeemable balance: userRedeemable = userScaledBalance * liquidityIndex / RAY
-            userRedeemable = (userScaledBalance * liquidityIndex) / BigInt(1e27);
+            userRedeemable =
+                (await rTokenContract
+                    .balanceOf(userAddress)
+                    .catch(handleError("rToken balanceOf", 0n))) ?? 0n;
         }
-        const result = {
+        return {
             totalLiquidity: ethers_1.ethers.formatEther(totalLiquidity),
             totalBorrow: ethers_1.ethers.formatEther(totalUsage),
-            utilization: (Number(utilization.toString()) / 1e27).toFixed(6), // Utilization as a decimal value between 0 and 1
-            liquidityIndex: (Number(liquidityIndex.toString()) / 1e27).toFixed(6),
-            usageIndex: (Number(usageIndex.toString()) / 1e27).toFixed(6),
-            currentLiquidityRate: (Number(currentLiquidityRate.toString()) / 1e25).toFixed(2),
-            currentUsageRate: (Number(currentUsageRate.toString()) / 1e25).toFixed(2),
-            primeRate: (Number(primeRate.toString()) / 1e25).toFixed(2),
-            baseRate: (Number(baseRate.toString()) / 1e25).toFixed(2),
-            optimalRate: (Number(optimalRate.toString()) / 1e25).toFixed(2),
-            maxRate: (Number(maxRate.toString()) / 1e25).toFixed(2),
-            optimalUtilizationRate: (Number(optimalUtilizationRate.toString()) / 1e27).toFixed(6),
-            protocolFeeRate: (Number(protocolFeeRate.toString()) / 1e25).toFixed(2),
-            normalizedIncome: (Number(normalizedIncome.toString()) / 1e27).toFixed(6),
-            normalizedDebt: (Number(normalizedDebt.toString()) / 1e27).toFixed(6),
-            apy: (Number(apy.toString()) / 1e25).toFixed(2),
-            userRedeemable: ethers_1.ethers.formatEther(userRedeemable ?? 0n),
-            apr: (Number(apr.toString()) / 1e25).toFixed(2),
+            utilization: asDecimal(utilization),
+            liquidityIndex: asDecimal(liquidityIndex),
+            usageIndex: asDecimal(usageIndex),
+            supplyRate: asPercent(supplyRate),
+            borrowRate: asPercent(borrowRate),
+            supplyApy: asPercent(supplyRate),
+            borrowApy: (toCompoundedApy(borrowRate) * 100).toFixed(2),
+            primeRate: asPercent(primeRate),
+            baseRate: asPercent(baseRate),
+            optimalRate: asPercent(optimalRate),
+            maxRate: asPercent(maxRate),
+            optimalUtilizationRate: asDecimal(optimalUtilizationRate),
+            protocolFeeRate: asPercent(protocolFeeRate),
+            currentProtocolFeeRate: asPercent(currentProtocolFeeRate),
+            normalizedIncome: asDecimal(normalizedIncome),
+            normalizedDebt: asDecimal(normalizedDebt),
+            userRedeemable: ethers_1.ethers.formatEther(userRedeemable),
             pendingProtocolFeeAmount: ethers_1.ethers.formatEther(pendingProtocolFeeAmount),
+            /** @deprecated use `supplyRate` */
+            currentLiquidityRate: asPercent(supplyRate),
+            /** @deprecated use `borrowRate` */
+            currentUsageRate: asPercent(borrowRate),
+            /** @deprecated use `borrowRate` */
+            apr: asPercent(borrowRate),
+            /** @deprecated use `supplyRate` */
+            apy: asPercent(supplyRate),
         };
-        return result;
     }
     catch (error) {
         console.error("Error fetching lending pool info:", error);
         throw error;
     }
 }
+/**
+ * Resolves the protocol fee owed in underlying asset units.
+ *
+ * Newer pools bank the fee scaled by the liquidity index and expose
+ * `getPendingProtocolFee()`, which re-values it at the current index. Older pools
+ * store the unscaled amount in the reserve's ninth slot and have no getter, so
+ * fall back to reading it directly.
+ */
+async function getPendingProtocolFee(chainId, provider, reserve, normalizedIncome) {
+    const stored = reserve?.[8] ?? 0n;
+    if (stored === 0n)
+        return 0n;
+    try {
+        const pool = new ethers_1.ethers.Contract((0, getContractAddress_1.default)(chainId, "lendingpool"), ["function getPendingProtocolFee() view returns (uint256)"], provider);
+        return await pool.getPendingProtocolFee();
+    }
+    catch {
+        return normalizedIncome > 0n ? rayMul(stored, normalizedIncome) : stored;
+    }
+}
 exports.default = getLendingPoolInfo;

package/dist/types/pools/lendingPool/getLendingPoolInfo.d.ts

@@ -1,24 +1,33 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains";
-declare function getLendingPoolInfo(chainId: ChainId, userAddress: string, provider: Provider): Promise<{
+declare function getLendingPoolInfo(chainId: ChainId, userAddress?: string, provider?: Provider): Promise<{
     totalLiquidity: string;
     totalBorrow: string;
     utilization: string;
     liquidityIndex: string;
     usageIndex: string;
-    currentLiquidityRate: string;
-    currentUsageRate: string;
+    supplyRate: string;
+    borrowRate: string;
+    supplyApy: string;
+    borrowApy: string;
     primeRate: string;
     baseRate: string;
     optimalRate: string;
     maxRate: string;
     optimalUtilizationRate: string;
     protocolFeeRate: string;
+    currentProtocolFeeRate: string;
     normalizedIncome: string;
     normalizedDebt: string;
-    apy: string;
     userRedeemable: string;
-    apr: string;
     pendingProtocolFeeAmount: string;
+    /** @deprecated use `supplyRate` */
+    currentLiquidityRate: string;
+    /** @deprecated use `borrowRate` */
+    currentUsageRate: string;
+    /** @deprecated use `borrowRate` */
+    apr: string;
+    /** @deprecated use `supplyRate` */
+    apy: string;
 }>;
 export default getLendingPoolInfo;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "1.2.0-beta.13",
+	"version": "1.2.0-beta.14",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",