@hobba-io/core 0.1.0

package/src/rates/collateralInfo.ts

@@ -0,0 +1,136 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import {
+  decodeReserve,
+  computeKaminoSupplyRate,
+  computeJuplendSupplyRate,
+  getCollateralLtvInfo,
+  getJuplendCollateralLtvInfo,
+} from "./borrowRates";
+import {
+  deriveJuplendVaultConfigPda,
+  JUPLEND_VAULT_ID,
+  JUPLEND_SOL_VAULT_ID,
+  JUPLEND_LIQUIDITY_PROGRAM,
+  SOL_MINT,
+  CBBTC_MINT,
+} from "../constants";
+
+// Collateral reserve addresses for supply APY (Kamino Main Market)
+const COLLATERAL_RESERVES: Record<string, string> = {
+  cbBTC: "37Jk2zkz23vkAYBT66HM2gaqJuNg2nYLsCreQAVt5MWK",
+  SOL: "d4A2prbA2whesmvHaL88BH6Ewn5N4bTSU2Ze8P6Bc4Q",
+};
+
+export interface CollateralRatesInfo {
+  collateralSupplyAPYs: Record<string, number>;
+  collateralLtvs: Record<string, { loanToValuePct: number; liquidationThresholdPct: number }>;
+  juplendCollateralSupplyAPYs: Record<string, number>;
+  juplendCollateralRewardsAPYs: Record<string, number>;
+  juplendCollateralLtvs: Record<string, { loanToValuePct: number; liquidationThresholdPct: number }>;
+}
+
+/**
+ * Per-collateral supply APYs + LTV thresholds for both lenders. Shared by
+ * /api/rates and /api/market-data so widget integrators get liquidation LTVs
+ * from the same source the app uses.
+ */
+export async function computeCollateralRatesInfo(
+  connection: Connection,
+  recentSlotDurationMs: number,
+): Promise<CollateralRatesInfo> {
+  // Kamino collateral info: supply APY + LTV thresholds per asset
+  const collateralSupplyAPYs: Record<string, number> = {};
+  const collateralLtvs: CollateralRatesInfo["collateralLtvs"] = {};
+  await Promise.all(
+    Object.entries(COLLATERAL_RESERVES).map(async ([asset, reserveAddr]) => {
+      try {
+        const info = await connection.getAccountInfo(new PublicKey(reserveAddr));
+        if (info) {
+          const reserve = decodeReserve(info.data as Buffer);
+          const { supplyAPY } = computeKaminoSupplyRate(reserve, recentSlotDurationMs);
+          collateralSupplyAPYs[asset] = supplyAPY;
+          collateralLtvs[asset] = getCollateralLtvInfo(reserve);
+        }
+      } catch (e: any) {
+        console.error(`Error computing ${asset} supply APY:`, e.message);
+      }
+    })
+  );
+
+  // JupLend collateral supply APYs — the lender rate on the SOL/cbBTC liquidity
+  // reserve, used when a position is deposited into JupLend rather than Kamino.
+  const juplendCollateralSupplyAPYs: Record<string, number> = {};
+  const juplendCollateralMints: Array<[string, PublicKey]> = [
+    ["SOL", SOL_MINT],
+    ["cbBTC", CBBTC_MINT],
+  ];
+  await Promise.all(
+    juplendCollateralMints.map(async ([asset, mint]) => {
+      try {
+        const reservePda = PublicKey.findProgramAddressSync(
+          [Buffer.from("reserve"), mint.toBuffer()],
+          JUPLEND_LIQUIDITY_PROGRAM
+        )[0];
+        const info = await connection.getAccountInfo(reservePda);
+        if (info) {
+          const { supplyAPY } = computeJuplendSupplyRate(info.data as Buffer);
+          juplendCollateralSupplyAPYs[asset] = supplyAPY;
+        }
+      } catch (e: any) {
+        console.error(`Error computing JupLend ${asset} supply APY:`, e.message);
+      }
+    })
+  );
+
+  // JupLend rewards boost (vault supplyRate minus base supplyRateLiquidity)
+  const juplendCollateralRewardsAPYs: Record<string, number> = {};
+  try {
+    const vaultsRes = await fetch("https://lite-api.jup.ag/lend/v1/borrow/vaults", {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (vaultsRes.ok) {
+      const vaults: any[] = await vaultsRes.json();
+      const juplendVaultIds: Array<[string, number]> = [
+        ["SOL", JUPLEND_SOL_VAULT_ID],
+        ["cbBTC", JUPLEND_VAULT_ID],
+      ];
+      for (const [asset, vaultId] of juplendVaultIds) {
+        const v = vaults.find((x) => x?.id === vaultId);
+        if (!v) continue;
+        // API rates are 1e2-scaled (e.g. "531" => 5.31%).
+        const rewards = Math.max(0, Number(v.supplyRate) - Number(v.supplyRateLiquidity)) / 100;
+        if (rewards > 0) juplendCollateralRewardsAPYs[asset] = rewards;
+      }
+    }
+  } catch (e: any) {
+    console.error("Error fetching JupLend rewards:", e.message);
+  }
+
+  // JupLend collateral LTVs (per-vault liquidationThreshold from vault_config)
+  const juplendCollateralLtvs: CollateralRatesInfo["juplendCollateralLtvs"] = {};
+  const juplendVaultConfigs: Array<[string, PublicKey]> = [
+    ["cbBTC", deriveJuplendVaultConfigPda(JUPLEND_VAULT_ID)],
+    ["SOL", deriveJuplendVaultConfigPda(JUPLEND_SOL_VAULT_ID)],
+  ];
+  await Promise.all(
+    juplendVaultConfigs.map(async ([asset, addr]) => {
+      try {
+        const info = await connection.getAccountInfo(addr);
+        if (info) {
+          juplendCollateralLtvs[asset] = getJuplendCollateralLtvInfo(info.data as Buffer);
+        }
+      } catch (e: any) {
+        console.error(`Error fetching JupLend ${asset} vault config:`, e.message);
+      }
+    })
+  );
+
+  return {
+    collateralSupplyAPYs,
+    collateralLtvs,
+    juplendCollateralSupplyAPYs,
+    juplendCollateralRewardsAPYs,
+    juplendCollateralLtvs,
+  };
+}

package/src/rates/constants.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared vault-to-reserves mappings and borrow market definitions.
+ * Single source of truth used by /api/rates, /api/supply-rates, and /api/market-data.
+ */
+
+export interface VaultReserveDef {
+  name: string;
+  id: string;       // 'allez' | 'prime' | 'rockawayRWA'
+  vault: string;
+  sharesMint: string;
+  reserves: string[];
+}
+
+export interface BorrowMarketDef {
+  name: string;
+  provider: "kamino" | "juplend";
+  usdcReserve: string;
+  cbbtcReserve?: string;
+}
+
+export const VAULT_RESERVE_MAP: VaultReserveDef[] = [
+  {
+    name: "Allez USDC",
+    id: "allez",
+    vault: "A1USdzqDHmw5oz97AkqAGLxEQZfFjASZFuy4T6Qdvnpo",
+    sharesMint: "BDh5h1uqhdL3pdCcTB1AEc2dyRsorDx9fF8Y72H1XZu8",
+    reserves: [
+      "D6q6wuQSrifJKZYpR1M8R4YawnLDtDsMmWM1NbBmgJ59", // Main Market
+      "Ga4rZytCpq1unD4DbEJ5bkHeUz9g3oh9AAFEi6vSauXp", // Altcoin
+      "9FRZvAsjDJ6WM8BJ2S45h9PoDCLAq8DNY9zZDX7MyGzT", // JLP
+      "9TD2TSv4pENb8VwfbVYg25jvym7HN6iuAR6pFNSrKjqQ", // Market 4
+      "F22tnLsbv66vEU2GZRc7coaqZsr8UcBbyp9V2kqWAiWK", // Market 5
+      "Atj6UREVWa7WxbF2EMKNyfmYUY1U1txughe2gjhcPDCo", // Market 6
+      "9GJ9GBRwCp4pHmWrQ43L5xpc9Vykg7jnfwcFGN8FoHYu", // Market 7
+      "ALnjBHECcdBsSwgVJ6A8pFEZ15qxE5jJQriCXSKT3Bte", // Market 8
+      "4QKFoFDzNFnvfkzVazABbCEfMwd3y1pZqUVzmpnkCphj", // Market 9
+      "AYL4LMc4ZCVyq3Z7XPJGWDM4H9PiWjqXAAuuHBEGVR2Z", // Market 10
+      "CxvpximovDBSPXhPj4VXechMWEV5G2DtuKwa9v9Hswrc", // Market 11
+    ],
+  },
+  {
+    name: "Prime USDC",
+    id: "prime",
+    vault: "HDsayqAsDWy3QvANGqh2yNraqcD8Fnjgh73Mhb3WRS5E",
+    sharesMint: "7D8C5pDFxug58L9zkwK7bCiDg4kD4AygzbcZUmf5usHS",
+    reserves: [
+      "Ga4rZytCpq1unD4DbEJ5bkHeUz9g3oh9AAFEi6vSauXp", // Altcoin
+      "D6q6wuQSrifJKZYpR1M8R4YawnLDtDsMmWM1NbBmgJ59", // Main Market
+      "9FRZvAsjDJ6WM8BJ2S45h9PoDCLAq8DNY9zZDX7MyGzT", // JLP
+    ],
+  },
+  {
+    name: "RockawayRWA USDC",
+    id: "rockawayRWA",
+    vault: "DWSXb18xZApz29vnQpgR2m6MynCT7PznaXt7Ut7M7KaP",
+    sharesMint: "DgHN3q3dSYAchNX7V3D4aYiTWMx8RHTgHbfPiwiqBkE9",
+    reserves: [
+      "6XdN3zXeoYKgfSeZb8h1LpiEkUXRJ3CbimE5FJ35XFBP", // RWA
+      "4QKFoFDzNFnvfkzVazABbCEfMwd3y1pZqUVzmpnkCphj", // Market 9
+      "AYL4LMc4ZCVyq3Z7XPJGWDM4H9PiWjqXAAuuHBEGVR2Z", // Market 10
+      "9GJ9GBRwCp4pHmWrQ43L5xpc9Vykg7jnfwcFGN8FoHYu", // Market 7
+    ],
+  },
+];
+
+export const BORROW_MARKET_DEFS: BorrowMarketDef[] = [
+  {
+    name: "Kamino Main Market",
+    provider: "kamino",
+    usdcReserve: "D6q6wuQSrifJKZYpR1M8R4YawnLDtDsMmWM1NbBmgJ59",
+    cbbtcReserve: "37Jk2zkz23vkAYBT66HM2gaqJuNg2nYLsCreQAVt5MWK",
+  },
+  {
+    name: "Kamino xStocks",
+    provider: "kamino",
+    usdcReserve: "97zoywd8mPZsGTg8q1wdD2Wgkdrs2tqusp1Qqcxbyj7E",
+    cbbtcReserve: "5AWpVYJvNASoUM8toSDQRcVyA9dvoUuFj5qNx9v32bjj",
+  },
+  {
+    name: "JupLend",
+    provider: "juplend",
+    usdcReserve: "94vK29npVbyRHXH63rRcTiSr26SFhrQTzbpNJuhQEDu",
+  },
+];
+
+export const JUPLEND_USDC_RESERVE = "94vK29npVbyRHXH63rRcTiSr26SFhrQTzbpNJuhQEDu";
+export const JUPLEND_VAULT_STATE_ADDR = "HnSMEmypWgJ1a6JNnBycccsBeQQvqNKphgSMquCaFiy9";

package/src/rates/index.ts

@@ -0,0 +1,38 @@
+// Server-leaning rate math shared by the app's API routes, the rebalancer and
+// scripts. Deliberately NOT re-exported from @hobba/core's index: decodeReserve
+// lazy-requires @kamino-finance/klend-sdk (heavy, effectively server-only), so
+// consumers import via the subpath (`@hobba/core/rates`) to keep it out of
+// browser/widget bundles.
+export {
+  decodeReserve,
+  computeKaminoBorrowRate,
+  computeKaminoSupplyRate,
+  computeJuplendBorrowRate,
+  computeJuplendSupplyRate,
+  getCollateralInfo,
+  getCollateralLtvInfo,
+  getJuplendCollateral,
+  getJuplendCollateralLtvInfo,
+  getRecentSlotDurationMs,
+} from "./borrowRates";
+export type { BorrowRateResult, CollateralInfo, CollateralLtvInfo, CurvePoint } from "./borrowRates";
+
+export {
+  computeSupplyRate,
+  computeWeightedVaultAPY,
+} from "./supplyRates";
+export type { SupplyRateResult, VaultAPYResult } from "./supplyRates";
+
+export {
+  VAULT_RESERVE_MAP,
+  BORROW_MARKET_DEFS,
+  JUPLEND_USDC_RESERVE,
+  JUPLEND_VAULT_STATE_ADDR,
+} from "./constants";
+export type { VaultReserveDef, BorrowMarketDef } from "./constants";
+
+export { fetchKaminoVaultAPYs, fetchPerenaVaultAPY } from "./kaminoApi";
+export type { KaminoVaultMetrics } from "./kaminoApi";
+
+export { computeCollateralRatesInfo } from "./collateralInfo";
+export type { CollateralRatesInfo } from "./collateralInfo";

package/src/rates/kaminoApi.ts

@@ -0,0 +1,134 @@
+/**
+ * Fetch vault APYs from Kamino's public API.
+ * This includes base lending yield + farming rewards + incentives,
+ * matching what the Kamino UI displays.
+ */
+
+import { Connection, PublicKey } from "@solana/web3.js";
+import { VAULT_RESERVE_MAP } from "./constants";
+
+const KAMINO_API = "https://api.kamino.finance";
+
+export interface KaminoVaultMetrics {
+  name: string;
+  id: string;
+  vault: string;
+  supplyAPY: number;        // total APY (base + rewards) as percentage
+  baseAPY: number;          // base lending APY as percentage
+  rewardsAPY: number;       // farming + incentives APY as percentage
+  // True = excluded from rebalancer's vault selection (won't switch INTO it,
+  // won't pick as bestVault). Users with existing shares can still switch OUT.
+  isDisabled: boolean;
+}
+
+interface KaminoMetricsResponse {
+  apy?: string | number;
+  apyFarmRewards?: string | number;
+  apyIncentives?: string | number;
+  apyReservesIncentives?: string | number;
+}
+
+export async function fetchKaminoVaultAPYs(): Promise<KaminoVaultMetrics[]> {
+  const results = await Promise.all(
+    VAULT_RESERVE_MAP.map(async (v) => {
+      try {
+        const resp = await fetch(`${KAMINO_API}/kvaults/${v.vault}/metrics`, { cache: 'no-store' });
+        if (!resp.ok) {
+          return fallback(v);
+        }
+        const data: KaminoMetricsResponse = await resp.json();
+
+        const apy = toNum(data.apy);
+        const farmRewards = toNum(data.apyFarmRewards);
+        const incentives = toNum(data.apyIncentives);
+        const reserveIncentives = toNum(data.apyReservesIncentives);
+        const rewardsAPY = farmRewards + incentives + reserveIncentives;
+        // Kamino's API `apy` excludes reserveIncentives; the website includes them
+        const totalAPY = apy + reserveIncentives;
+
+        return {
+          name: v.name,
+          id: v.id,
+          vault: v.vault,
+          supplyAPY: totalAPY * 100,
+          baseAPY: apy * 100,
+          rewardsAPY: rewardsAPY * 100,
+          isDisabled: true,
+        };
+      } catch {
+        return fallback(v);
+      }
+    })
+  );
+
+  return results;
+}
+
+function toNum(val: string | number | undefined): number {
+  if (val === undefined || val === null) return 0;
+  const n = typeof val === "string" ? parseFloat(val) : val;
+  return isNaN(n) ? 0 : n;
+}
+
+function fallback(v: { name: string; id: string; vault: string }): KaminoVaultMetrics {
+  return { name: v.name, id: v.id, vault: v.vault, supplyAPY: 0, baseAPY: 0, rewardsAPY: 0, isDisabled: true };
+}
+
+// --- Perena vault ---
+
+const PERENA_VAULT_STATE_ADDRESS = new PublicKey("sM6P4mh53CnG4faN4Fo3seY7wMSAiHdy8o6gKjwQF7A");
+const PERENA_TOTAL_SHARES_OFFSET = 200;
+const PERENA_PRICE_PER_SHARE_OFFSET = 352;
+
+// Known reference point from the Perena USD* historical price chart:
+// 2026-06-25 02:00 CEST (UTC+2) = 2026-06-25 00:00:00 UTC, price per share 1.0744.
+// (Verified against on-chain state: offset 352 read 1.07609 on 2026-07-01.)
+const PERENA_REF_PRICE = 1.0744;
+const PERENA_REF_TIMESTAMP_MS = Date.UTC(2026, 5, 25, 0, 0, 0);
+
+/**
+ * Fetch Perena vault APY by reading on-chain state.
+ * Share price is a 6-decimal fixed-point u64 (e.g. 1055691 = 1.055691 USDC per star*).
+ * APY is annualized from share price appreciation between a known reference point
+ * and the current on-chain price.
+ */
+export async function fetchPerenaVaultAPY(connection: Connection): Promise<KaminoVaultMetrics> {
+  const id = "perena";
+  const name = "Perena USDC";
+  const vault = PERENA_VAULT_STATE_ADDRESS.toBase58();
+
+  try {
+    const accountInfo = await connection.getAccountInfo(PERENA_VAULT_STATE_ADDRESS);
+    if (!accountInfo || !accountInfo.data) {
+      return { name, id, vault, supplyAPY: 0, baseAPY: 0, rewardsAPY: 0, isDisabled: false };
+    }
+
+    const data = accountInfo.data;
+
+    // Read total shares (u64 LE at offset 200)
+    const _totalShares = data.readBigUInt64LE(PERENA_TOTAL_SHARES_OFFSET);
+
+    // Read price per share (u64 LE at offset 352, 6-decimal fixed point)
+    const rawPrice = data.readBigUInt64LE(PERENA_PRICE_PER_SHARE_OFFSET);
+    const currentPrice = Number(rawPrice) / 1_000_000;
+
+    // Annualize the share-price appreciation since the reference point.
+    const elapsedDays = (Date.now() - PERENA_REF_TIMESTAMP_MS) / (1000 * 60 * 60 * 24);
+    const apy =
+      elapsedDays > 0 && currentPrice > PERENA_REF_PRICE
+        ? ((currentPrice / PERENA_REF_PRICE - 1) * (365 / elapsedDays)) * 100
+        : 0;
+
+    return {
+      name,
+      id,
+      vault,
+      supplyAPY: apy,
+      baseAPY: apy,
+      rewardsAPY: 0,
+      isDisabled: false,
+    };
+  } catch {
+    return { name, id, vault, supplyAPY: 0, baseAPY: 0, rewardsAPY: 0, isDisabled: false };
+  }
+}

package/src/rates/supplyRates.ts

@@ -0,0 +1,102 @@
+/**
+ * Shared supply rate computation functions.
+ * Extracted from /api/supply-rates/route.ts to be reused by /api/market-data and the rebalancer.
+ */
+
+import { decodeReserve, CurvePoint } from "./borrowRates";
+
+const SF_SCALE = BigInt("1152921504606846976"); // 2^60
+const SLOTS_PER_YEAR = 63072000;
+const SLOTS_PER_SECOND = 2;
+const DEFAULT_SLOT_DURATION_MS = 400;
+
+export interface SupplyRateResult {
+  totalDeposited: number;
+  utilization: number;   // percentage (0–100)
+  supplyAPY: number;     // percentage
+}
+
+export interface VaultAPYResult {
+  name: string;
+  supplyAPY: number;     // percentage
+  utilization?: number;  // percentage
+  totalDeposited?: number;
+  numReserves: number;
+}
+
+export function computeSupplyRate(reserve: any, recentSlotDurationMs = DEFAULT_SLOT_DURATION_MS): SupplyRateResult {
+  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 adjustedBorrowRate = (borrowRateBps / 10000) * slotAdjustment;
+  const hostFixedRate = (reserve.config.hostFixedInterestRateBps / 10000) * slotAdjustment;
+  const borrowAPR = adjustedBorrowRate + hostFixedRate;
+
+  const protocolTakeRate = reserve.config.protocolTakeRatePct / 100;
+  const supplyAPR = borrowAPR * utilization * (1 - protocolTakeRate);
+  const supplyAPY = Math.pow(1 + supplyAPR / SLOTS_PER_YEAR, SLOTS_PER_YEAR) - 1;
+
+  const mintDecimals = Number(reserve.liquidity.mintDecimals);
+  const divisor = Math.pow(10, mintDecimals);
+
+  return {
+    totalDeposited: totalSupply / divisor,
+    utilization: utilization * 100,
+    supplyAPY: supplyAPY * 100,
+  };
+}
+
+export function computeWeightedVaultAPY(
+  reserveAddresses: string[],
+  rateMap: Map<string, SupplyRateResult>,
+): VaultAPYResult & { supplyAPY: number } {
+  const reserveRates = reserveAddresses
+    .map((addr) => rateMap.get(addr))
+    .filter((r): r is SupplyRateResult => r != null && r.totalDeposited > 0);
+
+  if (reserveRates.length === 0) {
+    return { name: "", supplyAPY: 0, totalDeposited: 0, numReserves: 0 };
+  }
+
+  const totalWeight = reserveRates.reduce((s, r) => s + r.totalDeposited, 0);
+  const weightedAPY = reserveRates.reduce(
+    (s, r) => s + r.supplyAPY * (r.totalDeposited / totalWeight),
+    0
+  );
+  const avgUtilization = reserveRates.reduce(
+    (s, r) => s + r.utilization * (r.totalDeposited / totalWeight),
+    0
+  );
+
+  return {
+    name: "",
+    supplyAPY: weightedAPY,
+    utilization: avgUtilization,
+    totalDeposited: totalWeight,
+    numReserves: reserveRates.length,
+  };
+}
+
+export { decodeReserve };