@hobba-io/core 0.1.0

package/src/quote.ts

@@ -0,0 +1,310 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { collateralDecimals, collateralLabel } from "./amountUtils";
+import { getPosition, type HobbaPosition, type Lender } from "./position";
+import {
+  bestMarketName,
+  fetchCollateralPrice,
+  fetchRatesPayload,
+  fetchSupplyRatesPayload,
+  type RatesPayload,
+  type SupplyRatesPayload,
+} from "./positionMetrics";
+
+/** Calculator defaults — same values the app falls back to when rates are empty. */
+const FALLBACK_BORROW_APY = 5.6 / 100;
+const FALLBACK_SUPPLY_APY = 21.59 / 100;
+const SOL_STAKING_APY = 7 / 100;
+const MAX_USER_LTV_PCT = 50;
+
+export type RiskLevel = "safe" | "moderate" | "risky" | "none";
+
+/**
+ * Projection quote for the borrow calculator and the deposit/manage modals —
+ * the same math app.hobba.io runs (CalculatorSection + ActionModal /
+ * DepositBorrowModal), computed against live rates so partner UIs never
+ * re-implement Hobba's logic. All *Pct values are percent numbers, all *Usd
+ * values USD.
+ */
+export interface HobbaQuote {
+  lender: Lender;
+  collateralPriceUsd: number;
+  liquidationLtvPct: number;
+  maxUserLtvPct: number;
+
+  /** Current position (zeros for new users). UI units. */
+  current: {
+    collateralUi: number;
+    debtUsdc: number;
+    ltvPct: number;
+    loanApyPct: number | null;
+  };
+  /** Position after applying the requested deltas. UI units. */
+  projected: {
+    collateralUi: number;
+    debtUsdc: number;
+    ltvPct: number;
+    loanApyPct: number | null;
+    liquidationPriceUsd: number | null;
+    dropToLiquidationPct: number | null;
+    riskLabel: string;
+    riskLevel: RiskLevel;
+  };
+  /** Calculator figures for the projected position. */
+  calculator: {
+    depositValueUsd: number;
+    borrowValueUsd: number;
+    borrowLimitUsd: number;
+    loanApyPct: number;
+    earnMode: boolean;
+    earnApyPct: number;
+    borrowCostPerYearUsd: number;
+    earningPerYearUsd: number;
+    stakingEarnPerYearUsd: number;
+    /** dd/mm/yyyy when the projected loan APY is negative, else null. */
+    selfRepayDate: string | null;
+  };
+}
+
+function assessRisk(currentPrice: number, liquidationPrice: number): {
+  riskLabel: string;
+  riskLevel: RiskLevel;
+} {
+  if (currentPrice <= 0 || liquidationPrice <= 0) return { riskLabel: "—", riskLevel: "none" };
+  const fallPct = ((currentPrice - liquidationPrice) / currentPrice) * 100;
+  if (fallPct > 70) return { riskLabel: "Very Safe", riskLevel: "safe" };
+  if (fallPct > 50) return { riskLabel: "Safe", riskLevel: "safe" };
+  if (fallPct > 40) return { riskLabel: "Moderate Risk", riskLevel: "moderate" };
+  if (fallPct > 30) return { riskLabel: "Risky", riskLevel: "moderate" };
+  if (fallPct > 15) return { riskLabel: "Very Risky", riskLevel: "risky" };
+  return { riskLabel: "Extremely Risky", riskLevel: "risky" };
+}
+
+function selfRepayDateFor(loanApyFraction: number): string | null {
+  if (loanApyFraction >= 0) return null;
+  const yearsToRepay = 1 / Math.abs(loanApyFraction);
+  if (yearsToRepay > 10) return null;
+  const repayDate = new Date();
+  repayDate.setDate(repayDate.getDate() + Math.ceil(yearsToRepay * 365));
+  return `${repayDate.getDate().toString().padStart(2, "0")}/${(repayDate.getMonth() + 1)
+    .toString()
+    .padStart(2, "0")}/${repayDate.getFullYear()}`;
+}
+
+export interface GetQuoteParams {
+  connection: Connection;
+  collateralMint: PublicKey;
+  /** Wallet whose existing position the deltas apply to; omit for a fresh calculator quote. */
+  owner?: PublicKey;
+  /** Deltas in base units (collateral base units / micro-USDC), decimal strings. */
+  depositAmount?: string;
+  borrowAmount?: string;
+  repayAmount?: string;
+  withdrawAmount?: string;
+  apiBaseUrl?: string;
+}
+
+export async function getQuote(params: GetQuoteParams): Promise<HobbaQuote> {
+  const { connection, collateralMint } = params;
+  const base = (params.apiBaseUrl ?? "").replace(/\/+$/, "");
+  const label = collateralLabel(collateralMint);
+
+  const [position, rates, supplyRates, price] = await Promise.all([
+    params.owner
+      ? getPosition({ connection, owner: params.owner, collateralMint, apiBaseUrl: base })
+      : Promise.resolve<HobbaPosition | null>(null),
+    fetchRatesPayload(base),
+    fetchSupplyRatesPayload(base),
+    fetchCollateralPrice(base, label),
+  ]);
+
+  return computeQuote({
+    position,
+    rates,
+    supplyRates,
+    collateralPriceUsd: price,
+    collateralMint,
+    depositAmount: params.depositAmount,
+    borrowAmount: params.borrowAmount,
+    repayAmount: params.repayAmount,
+    withdrawAmount: params.withdrawAmount,
+  });
+}
+
+/**
+ * Inputs for the pure quote computation. The app feeds these from its cached
+ * hooks so calculator/modal math stays synchronous per keystroke;
+ * `getQuote` feeds them from the backend fetches above. Same math either way.
+ */
+export interface QuoteInputs {
+  position: HobbaPosition | null;
+  rates: RatesPayload;
+  supplyRates: SupplyRatesPayload;
+  collateralPriceUsd: number;
+  collateralMint: PublicKey;
+  /** Deltas in base units (collateral base units / micro-USDC), decimal strings. */
+  depositAmount?: string;
+  borrowAmount?: string;
+  repayAmount?: string;
+  withdrawAmount?: string;
+  /**
+   * Optional position-rate overrides (percent). When set they replace the
+   * internal market/vault lookups for the loan-APY math — the app passes its
+   * page-level figures so modal projections match what is already on screen
+   * (and xStocks markets, which the internal lookup doesn't resolve, price
+   * correctly). Headless callers normally omit them.
+   */
+  positionBorrowApyPct?: number;
+  positionVaultApyPct?: number;
+}
+
+export function computeQuote(inputs: QuoteInputs): HobbaQuote {
+  const { position, rates, supplyRates, collateralPriceUsd: price, collateralMint } = inputs;
+  const label = collateralLabel(collateralMint);
+  const decimals = collateralDecimals(collateralMint);
+  const divisor = Math.pow(10, decimals);
+  const isSol = label === "SOL";
+  const params = inputs;
+
+  // Best live rates with the app's hardcoded fallbacks (CalculatorSection).
+  const bestBorrowAPY = (() => {
+    if (rates.markets.length === 0) return FALLBACK_BORROW_APY;
+    let best = Infinity;
+    for (const m of rates.markets) if (m.borrowAPY < best) best = m.borrowAPY;
+    return best < Infinity ? best / 100 : FALLBACK_BORROW_APY;
+  })();
+  const bestSupplyAPY = (() => {
+    if (supplyRates.vaults.length === 0) return FALLBACK_SUPPLY_APY;
+    let best = -Infinity;
+    for (const v of supplyRates.vaults) if (v.supplyAPY > best) best = v.supplyAPY;
+    return best > -Infinity ? best / 100 : FALLBACK_SUPPLY_APY;
+  })();
+
+  const lender: Lender = position?.exists
+    ? position.lender
+    : bestMarketName(rates) === "JupLend"
+      ? "juplend"
+      : "kamino";
+  const isJuplendLender = lender === "juplend";
+
+  const ltvSource = isJuplendLender
+    ? rates.juplendCollateralLtvs[label]
+    : rates.collateralLtvs[label];
+  const liquidationLtvPct =
+    ltvSource?.liquidationThresholdPct ?? (label === "cbBTC" ? 80 : 75);
+
+  // Current position in UI units
+  const curCollateralUi = position ? Number(position.collateral) / divisor : 0;
+  const curDebtUsdc = position ? Number(position.userDebtUsdc) / 1e6 : 0;
+  const actualOperatorBorrowed = position ? Number(position.depositedToVault) / 1e6 : 0;
+
+  // Deltas in UI units
+  const depositUi = Number(params.depositAmount ?? "0") / divisor;
+  const withdrawUi = Number(params.withdrawAmount ?? "0") / divisor;
+  const borrowUsdc = Number(params.borrowAmount ?? "0") / 1e6;
+  const repayUsdc = Number(params.repayAmount ?? "0") / 1e6;
+
+  const projCollateralUi = Math.max(0, curCollateralUi + depositUi - withdrawUi);
+  const projDebtUsdc = Math.max(0, curDebtUsdc + borrowUsdc - repayUsdc);
+
+  const curCollateralUsd = curCollateralUi * price;
+  const projCollateralUsd = projCollateralUi * price;
+  const curLtvPct = curCollateralUsd > 0 ? (curDebtUsdc / curCollateralUsd) * 100 : 0;
+  const projLtvPct = projCollateralUsd > 0 ? (projDebtUsdc / projCollateralUsd) * 100 : 0;
+
+  // Loan APY for a position — ported from ActionModal.computeLoanAPY: the
+  // operator borrows up to the per-asset target LTV whenever vault yield beats
+  // borrow cost; rates follow the user's actual lender + vault (Dashboard).
+  const TARGET_LTV = isSol ? 0.6 : 0.65;
+  const borrowMarketNameForRates = !position?.exists
+    ? "Kamino Main Market"
+    : isJuplendLender
+      ? "JupLend"
+      : "Kamino Main Market";
+  const positionBorrowAPY =
+    params.positionBorrowApyPct ??
+    (rates.markets.find((m) => m.name === borrowMarketNameForRates)?.borrowAPY ??
+      bestBorrowAPY * 100);
+  const perenaVaultAPY = supplyRates.vaults.find((v) => v.name === "Perena USDC")?.supplyAPY ?? 0;
+  const positionVaultAPY =
+    params.positionVaultApyPct ?? (perenaVaultAPY > 0 ? perenaVaultAPY : bestSupplyAPY * 100);
+
+  const DUST_DEBT = 0.01;
+  const computeLoanApyPct = (userDebt: number, collateralUsd: number): number | null => {
+    if (userDebt < DUST_DEBT) return null;
+    let opDebt = actualOperatorBorrowed;
+    if (collateralUsd > 0 && positionVaultAPY > positionBorrowAPY) {
+      const projected = Math.max(0, collateralUsd * TARGET_LTV - userDebt);
+      opDebt = Math.max(actualOperatorBorrowed, projected);
+    } else if (positionVaultAPY <= positionBorrowAPY) {
+      opDebt = 0;
+    }
+    return ((userDebt + opDebt) * positionBorrowAPY - opDebt * positionVaultAPY) / userDebt;
+  };
+
+  const currentLoanApyPct = computeLoanApyPct(curDebtUsdc, curCollateralUsd);
+  const projectedLoanApyPct = computeLoanApyPct(projDebtUsdc, projCollateralUsd);
+
+  const projLiqPrice =
+    projCollateralUsd > 0 && projDebtUsdc > 0 && liquidationLtvPct > 0
+      ? price * (projLtvPct / liquidationLtvPct)
+      : 0;
+  const projBuffer =
+    price > 0 && projLiqPrice > 0 ? Math.max(0, ((price - projLiqPrice) / price) * 100) : null;
+  const { riskLabel, riskLevel } = assessRisk(price, projLiqPrice);
+
+  // --- Calculator math (ported from CalculatorSection) on projected values ---
+  const depositValueUsd = projCollateralUsd;
+  const borrowValueUsd = projDebtUsdc; // USDC ≈ $1
+  const borrowLimitUsd = depositValueUsd * (MAX_USER_LTV_PCT / 100);
+  const earningPerYearUsd =
+    depositValueUsd * TARGET_LTV > borrowValueUsd
+      ? (depositValueUsd * TARGET_LTV - borrowValueUsd) * (bestSupplyAPY - bestBorrowAPY)
+      : 0;
+  const borrowCostPerYearUsd = borrowValueUsd * bestBorrowAPY;
+  const calcLoanApy =
+    depositValueUsd > 0 && borrowValueUsd > 0
+      ? (borrowCostPerYearUsd - earningPerYearUsd) / borrowValueUsd
+      : 0;
+  const stakingEarnPerYearUsd = isSol ? depositValueUsd * SOL_STAKING_APY : 0;
+  const hasSpreadEarn =
+    depositValueUsd > 0 && borrowValueUsd <= 0 && bestSupplyAPY > bestBorrowAPY;
+  const earnMode =
+    depositValueUsd > 0 && borrowValueUsd <= 0 && (hasSpreadEarn || stakingEarnPerYearUsd > 0);
+  const totalEarnPerYear = (hasSpreadEarn ? earningPerYearUsd : 0) + stakingEarnPerYearUsd;
+  const earnApy = earnMode && depositValueUsd > 0 ? totalEarnPerYear / depositValueUsd : 0;
+
+  return {
+    lender,
+    collateralPriceUsd: price,
+    liquidationLtvPct,
+    maxUserLtvPct: MAX_USER_LTV_PCT,
+    current: {
+      collateralUi: curCollateralUi,
+      debtUsdc: curDebtUsdc,
+      ltvPct: curLtvPct,
+      loanApyPct: currentLoanApyPct,
+    },
+    projected: {
+      collateralUi: projCollateralUi,
+      debtUsdc: projDebtUsdc,
+      ltvPct: projLtvPct,
+      loanApyPct: projectedLoanApyPct,
+      liquidationPriceUsd: projLiqPrice > 0 ? projLiqPrice : null,
+      dropToLiquidationPct: projBuffer,
+      riskLabel,
+      riskLevel,
+    },
+    calculator: {
+      depositValueUsd,
+      borrowValueUsd,
+      borrowLimitUsd,
+      loanApyPct: calcLoanApy * 100,
+      earnMode,
+      earnApyPct: earnApy * 100,
+      borrowCostPerYearUsd,
+      earningPerYearUsd,
+      stakingEarnPerYearUsd,
+      selfRepayDate: selfRepayDateFor(calcLoanApy),
+    },
+  };
+}

package/src/rates/borrowRates.ts

@@ -0,0 +1,270 @@
+/**
+ * Shared borrow rate computation functions.
+ * Extracted from /api/rates/route.ts to be reused by /api/market-data and the rebalancer.
+ */
+
+import { createRequire } from "node:module";
+
+const SF_SCALE = BigInt("1152921504606846976"); // 2^60
+const SLOTS_PER_YEAR = 63072000;
+const SLOTS_PER_SECOND = 2;
+const DEFAULT_SLOT_DURATION_MS = 400;
+const JUPLEND_EXCHANGE_PRECISION = BigInt("1000000000000"); // 1e12
+const JUPLEND_SECONDS_PER_YEAR = 31536000;
+
+/** Measure actual slot duration from recent performance samples. */
+export async function getRecentSlotDurationMs(connection: { getRecentPerformanceSamples: (limit: number) => Promise<Array<{ numSlots: number; samplePeriodSecs: number }>> }): Promise<number> {
+  try {
+    const samples = await connection.getRecentPerformanceSamples(10);
+    if (samples.length === 0) return DEFAULT_SLOT_DURATION_MS;
+    let totalSlots = 0, totalSecs = 0;
+    for (const s of samples) {
+      totalSlots += s.numSlots;
+      totalSecs += s.samplePeriodSecs;
+    }
+    if (totalSlots === 0) return DEFAULT_SLOT_DURATION_MS;
+    const measured = (totalSecs * 1000) / totalSlots;
+    // Sanity check: local validators report unrealistic durations
+    if (measured < 200 || measured > 600) return DEFAULT_SLOT_DURATION_MS;
+    return measured;
+  } catch {
+    return DEFAULT_SLOT_DURATION_MS;
+  }
+}
+
+export interface CurvePoint {
+  utilizationRateBps: number;
+  borrowRateBps: number;
+}
+
+export interface BorrowRateResult {
+  availableLiquidity: number;
+  totalBorrowed: number;
+  utilization: number;   // percentage (0–100)
+  borrowAPR: number;     // percentage
+  borrowAPY: number;     // percentage
+}
+
+export interface CollateralInfo {
+  totalDeposited: number;
+  depositLimit: number;
+}
+
+export function decodeReserve(data: Buffer) {
+  // Lazy + server-only by design: resolves klend-sdk (an optional peer) from
+  // the consumer's node_modules at call time, keeping the heavy SDK out of
+  // browser bundles and out of load-time module evaluation. createRequire is
+  // invoked inside the function so importing this subpath never throws in
+  // environments without the optional peer installed.
+  const nodeRequire = createRequire(import.meta.url);
+  const { Reserve } = nodeRequire(
+    "@kamino-finance/klend-sdk/dist/@codegen/klend/accounts/Reserve"
+  );
+  return Reserve.decode(data);
+}
+
+export function computeKaminoBorrowRate(reserve: any, recentSlotDurationMs = DEFAULT_SLOT_DURATION_MS): BorrowRateResult {
+  const availableAmount = Number(reserve.liquidity.availableAmount);
+  const borrowedAmount = Number(BigInt(reserve.liquidity.borrowedAmountSf.toString()) / SF_SCALE);
+  const protocolFees = Number(BigInt(reserve.liquidity.accumulatedProtocolFeesSf.toString()) / SF_SCALE);
+  const referrerFees = Number(BigInt(reserve.liquidity.accumulatedReferrerFeesSf.toString()) / SF_SCALE);
+  const pendingFees = Number(BigInt(reserve.liquidity.pendingReferrerFeesSf.toString()) / SF_SCALE);
+
+  const totalSupply = availableAmount + borrowedAmount - protocolFees - referrerFees - pendingFees;
+  const utilization = totalSupply > 0 ? borrowedAmount / totalSupply : 0;
+
+  const curve: CurvePoint[] = reserve.config.borrowRateCurve.points;
+  const utilBps = utilization * 10000;
+  let borrowRateBps = 0;
+  for (let i = 1; i < curve.length; i++) {
+    if (curve[i].utilizationRateBps === 0 && curve[i].borrowRateBps === 0 && i > 1) break;
+    if (utilBps <= curve[i].utilizationRateBps) {
+      const x0 = curve[i - 1].utilizationRateBps;
+      const x1 = curve[i].utilizationRateBps;
+      const y0 = curve[i - 1].borrowRateBps;
+      const y1 = curve[i].borrowRateBps;
+      borrowRateBps = y0 + ((utilBps - x0) * (y1 - y0)) / (x1 - x0);
+      break;
+    }
+  }
+
+  const slotAdjustment = 1000 / SLOTS_PER_SECOND / recentSlotDurationMs;
+  const adjustedRate = (borrowRateBps / 10000) * slotAdjustment;
+  const hostFixedRate = (reserve.config.hostFixedInterestRateBps / 10000) * slotAdjustment;
+  const borrowAPR = adjustedRate + hostFixedRate;
+  const borrowAPY = Math.pow(1 + borrowAPR / SLOTS_PER_YEAR, SLOTS_PER_YEAR) - 1;
+
+  const mintDecimals = Number(reserve.liquidity.mintDecimals);
+  const divisor = Math.pow(10, mintDecimals);
+
+  return {
+    availableLiquidity: availableAmount / divisor,
+    totalBorrowed: borrowedAmount / divisor,
+    utilization: utilization * 100,
+    borrowAPR: borrowAPR * 100,
+    borrowAPY: borrowAPY * 100,
+  };
+}
+
+export function computeKaminoSupplyRate(reserve: any, recentSlotDurationMs = DEFAULT_SLOT_DURATION_MS): { supplyAPY: number } {
+  const availableAmount = Number(reserve.liquidity.availableAmount);
+  const borrowedAmount = Number(BigInt(reserve.liquidity.borrowedAmountSf.toString()) / SF_SCALE);
+  const protocolFees = Number(BigInt(reserve.liquidity.accumulatedProtocolFeesSf.toString()) / SF_SCALE);
+  const referrerFees = Number(BigInt(reserve.liquidity.accumulatedReferrerFeesSf.toString()) / SF_SCALE);
+  const pendingFees = Number(BigInt(reserve.liquidity.pendingReferrerFeesSf.toString()) / SF_SCALE);
+
+  const totalSupply = availableAmount + borrowedAmount - protocolFees - referrerFees - pendingFees;
+  const utilization = totalSupply > 0 ? borrowedAmount / totalSupply : 0;
+
+  const curve: CurvePoint[] = reserve.config.borrowRateCurve.points;
+  const utilBps = utilization * 10000;
+  let borrowRateBps = 0;
+  for (let i = 1; i < curve.length; i++) {
+    if (curve[i].utilizationRateBps === 0 && curve[i].borrowRateBps === 0 && i > 1) break;
+    if (utilBps <= curve[i].utilizationRateBps) {
+      const x0 = curve[i - 1].utilizationRateBps;
+      const x1 = curve[i].utilizationRateBps;
+      const y0 = curve[i - 1].borrowRateBps;
+      const y1 = curve[i].borrowRateBps;
+      borrowRateBps = y0 + ((utilBps - x0) * (y1 - y0)) / (x1 - x0);
+      break;
+    }
+  }
+
+  const slotAdjustment = 1000 / SLOTS_PER_SECOND / recentSlotDurationMs;
+  const adjustedRate = (borrowRateBps / 10000) * slotAdjustment;
+  const hostFixedRate = (reserve.config.hostFixedInterestRateBps / 10000) * slotAdjustment;
+  const borrowAPR = adjustedRate + hostFixedRate;
+
+  // Protocol take rate: fraction of interest kept by protocol (in bps)
+  const protocolTakeRatePct = (reserve.config.protocolTakeRatePct ?? 0) / 100;
+  const supplyAPR = borrowAPR * utilization * (1 - protocolTakeRatePct);
+  const supplyAPY = Math.pow(1 + supplyAPR / SLOTS_PER_YEAR, SLOTS_PER_YEAR) - 1;
+
+  return { supplyAPY: supplyAPY * 100 };
+}
+
+export interface CollateralLtvInfo {
+  loanToValuePct: number;       // max LTV for borrowing (e.g. 65)
+  liquidationThresholdPct: number; // liquidation LTV (e.g. 85)
+}
+
+export function getCollateralLtvInfo(reserve: any): CollateralLtvInfo {
+  return {
+    loanToValuePct: reserve.config.loanToValuePct ?? 0,
+    liquidationThresholdPct: reserve.config.liquidationThresholdPct ?? 0,
+  };
+}
+
+export function getCollateralInfo(reserve: any): CollateralInfo {
+  const availableAmount = Number(reserve.liquidity.availableAmount);
+  const borrowedAmount = Number(BigInt(reserve.liquidity.borrowedAmountSf.toString()) / SF_SCALE);
+  const mintDecimals = Number(reserve.liquidity.mintDecimals);
+  const divisor = Math.pow(10, mintDecimals);
+
+  const totalDeposited = (availableAmount + borrowedAmount) / divisor;
+  const depositLimit = Number(BigInt(reserve.config.depositLimit.toString())) / divisor;
+
+  return { totalDeposited, depositLimit };
+}
+
+export function getJuplendCollateralLtvInfo(vaultConfigData: Buffer): CollateralLtvInfo {
+  // VaultConfig layout (packed C):
+  //   8 (anchor disc) + 2 vaultId + 2 supplyRateMagnifier (i16) + 2 borrowRateMagnifier (i16)
+  //   + 2 collateralFactor (u16) + 2 liquidationThreshold (u16)
+  // Both factor fields are permille — divide by 10 to get percent. (See JupLend SDK
+  // lend.*.mjs liquidationThresholdRatio = ratio * threshold / 1000.)
+  const collateralFactor = vaultConfigData.readUInt16LE(8 + 2 + 2 + 2);
+  const liquidationThreshold = vaultConfigData.readUInt16LE(8 + 2 + 2 + 2 + 2);
+  return {
+    loanToValuePct: collateralFactor / 10,
+    liquidationThresholdPct: liquidationThreshold / 10,
+  };
+}
+
+export function getJuplendCollateral(vaultStateData: Buffer): CollateralInfo {
+  let off = 8; // discriminator
+  off += 2 + 1 + 4 + 4 + 4; // vaultId + branchLiquidated + topmostTick + currentBranchId + totalBranchId
+  const totalSupplyRaw = Number(vaultStateData.readBigUInt64LE(off));
+  const totalDeposited = totalSupplyRaw / 1e8; // cbBTC has 8 decimals
+  return { totalDeposited, depositLimit: 0 };
+}
+
+export function computeJuplendBorrowRate(data: Buffer): BorrowRateResult {
+  let off = 8; // skip discriminator
+  off += 32; // mint
+  off += 32; // vault
+  const borrowRateBps = data.readUInt16LE(off); off += 2;
+  off += 2; // feeOnInterest
+  off += 2; // lastUtilization
+  off += 8; // lastUpdateTimestamp
+  const supplyExchangePrice = data.readBigUInt64LE(off); off += 8;
+  const borrowExchangePrice = data.readBigUInt64LE(off); off += 8;
+  off += 2; // maxUtilization
+  const totalSupplyWithInterest = data.readBigUInt64LE(off); off += 8;
+  const totalSupplyInterestFree = data.readBigUInt64LE(off); off += 8;
+  const totalBorrowWithInterest = data.readBigUInt64LE(off); off += 8;
+  const totalBorrowInterestFree = data.readBigUInt64LE(off); off += 8;
+
+  const totalSupply =
+    Number(totalSupplyWithInterest * supplyExchangePrice / JUPLEND_EXCHANGE_PRECISION) +
+    Number(totalSupplyInterestFree);
+  const totalBorrow =
+    Number(totalBorrowWithInterest * borrowExchangePrice / JUPLEND_EXCHANGE_PRECISION) +
+    Number(totalBorrowInterestFree);
+
+  const USDC_DIVISOR = 1e6;
+  const availableLiquidity = (totalSupply - totalBorrow) / USDC_DIVISOR;
+  const totalBorrowed = totalBorrow / USDC_DIVISOR;
+  const utilization = totalSupply > 0 ? (totalBorrow / totalSupply) * 100 : 0;
+
+  const borrowAPR = borrowRateBps / 100; // percent
+  const apr = borrowRateBps / 10000; // as fraction
+  const borrowAPY = (Math.pow(1 + apr / JUPLEND_SECONDS_PER_YEAR, JUPLEND_SECONDS_PER_YEAR) - 1) * 100;
+
+  return {
+    availableLiquidity,
+    totalBorrowed,
+    utilization,
+    borrowAPR,
+    borrowAPY,
+  };
+}
+
+// Supply (deposit) APY for a JupLend liquidity reserve — the lender rate earned
+// by collateral supplied into that reserve. Decodes the same tokenReserve struct
+// as computeJuplendBorrowRate and mirrors the SDK's getLiquidityAssetSupplyRate:
+//   supplyRate = borrowRate * (1e4 - fee) * borrowWithInterest
+//                / (supplyWithInterest * 1e4)
+// (the JupLend analog of Kamino's borrowAPR * utilization * (1 - fee)).
+export function computeJuplendSupplyRate(data: Buffer): { supplyAPY: number } {
+  let off = 8; // skip discriminator
+  off += 32; // mint
+  off += 32; // vault
+  const borrowRateBps = data.readUInt16LE(off); off += 2;
+  const feeOnInterestBps = data.readUInt16LE(off); off += 2;
+  off += 2; // lastUtilization
+  off += 8; // lastUpdateTimestamp
+  const supplyExchangePrice = data.readBigUInt64LE(off); off += 8;
+  const borrowExchangePrice = data.readBigUInt64LE(off); off += 8;
+  off += 2; // maxUtilization
+  const totalSupplyWithInterest = data.readBigUInt64LE(off); off += 8;
+  off += 8; // totalSupplyInterestFree
+  const totalBorrowWithInterest = data.readBigUInt64LE(off); off += 8;
+
+  const supplyWithInterest =
+    (totalSupplyWithInterest * supplyExchangePrice) / JUPLEND_EXCHANGE_PRECISION;
+  const borrowWithInterest =
+    (totalBorrowWithInterest * borrowExchangePrice) / JUPLEND_EXCHANGE_PRECISION;
+  if (supplyWithInterest <= BigInt(0)) return { supplyAPY: 0 };
+
+  const supplyRateBps =
+    borrowRateBps *
+    (1 - feeOnInterestBps / 10000) *
+    (Number(borrowWithInterest) / Number(supplyWithInterest));
+
+  const apr = supplyRateBps / 10000; // as fraction
+  const supplyAPY =
+    (Math.pow(1 + apr / JUPLEND_SECONDS_PER_YEAR, JUPLEND_SECONDS_PER_YEAR) - 1) * 100;
+  return { supplyAPY };
+}