@hobba-io/core 0.1.0

package/src/limits.ts

@@ -0,0 +1,222 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { getAssociatedTokenAddress } from "@solana/spl-token";
+import { SOL_MINT, USDC_MINT } from "./constants";
+import { collateralDecimals, collateralLabel } from "./amountUtils";
+import { getPosition, type Lender } from "./position";
+
+/** Protocol input rules, shared by the app, the widget and /api/widget/config. */
+export const LIMITS_CONFIG = {
+  /** Users can borrow up to this % of collateral value. */
+  maxUserLtvPct: 50,
+  /** Minimum deposits in UI units, first-deposit vs top-up. */
+  minDepositUi: {
+    SOL: { first: 1, topUp: 0.1 },
+    cbBTC: { first: 0.001, topUp: 0.0001 },
+  } as Record<string, { first: number; topUp: number }>,
+  /** SOL held back from "Max" for rents + fees (lamports). */
+  solReserveLamports: { first: 50_000_000, topUp: 5_000_000 },
+  /** JupLend deposit rounding shave, base units per collateral. */
+  juplendDepositBufferBase: { SOL: 3_000_000, cbBTC: 1 } as Record<string, number>,
+  /**
+   * JupLend max-repay dust shave, micro-USDC. JupLend's operate rejects a
+   * repay that leaves 0 < debt < its min-debt floor (error 6025
+   * VAULT_USER_DEBT_TOO_LOW): a 0.002 USDC residual was observed failing on
+   * staging while ~0.01 passed, so leave 0.02 to clear the floor plus the
+   * interest accrued between quote and execution.
+   */
+  juplendRepayShaveMicro: 20_000,
+  /**
+   * klend balance-for-accrued-debt drift divisor applied to max withdraw
+   * (observed refresh-time BFAD drift up to ~0.43% on SOL).
+   */
+  kaminoWithdrawDriftFactor: 1.006,
+  /**
+   * JupLend max-withdraw margin. Hobba's 50% user-LTV cap is client-side
+   * policy (JupLend's on-chain ceiling is its 75-80% liquidation LTV), so
+   * only a hair of headroom is needed for interest accrued between quote
+   * and execution — lands ~49.99% instead of stranding 0.6% of the
+   * withdrawable amount like the klend factor would.
+   */
+  juplendWithdrawDriftFactor: 1.0005,
+  /**
+   * Collateral reserve for the post-unwind residual on max withdraw when the
+   * operator has capital deployed. prepare_withdraw redeems vault shares to
+   * repay the operator debt as collateral leaves, but redemption rounding,
+   * vault fees and the repay dust leave a small residual — withdrawing ALL
+   * collateral against it is infinite LTV and the lender rejects the tx
+   * (observed: JupLend 6011 VAULT_POSITION_ABOVE_CF). Reserve enough
+   * collateral to hold the residual at ≤ 50% LTV: residual is estimated as
+   * max(floorUsd, fracOfOperatorDebt × operator debt).
+   */
+  unwindResidualReserve: { floorUsd: 0.1, fracOfOperatorDebt: 0.002 },
+  /** Fallback liquidation LTVs (%) when /api/rates is unavailable. */
+  fallbackLiquidationLtvPct: {
+    kamino: { SOL: 75, cbBTC: 80 },
+    juplend: { SOL: 75, cbBTC: 80 },
+  } as Record<Lender, Record<string, number>>,
+};
+
+export interface HobbaLimits {
+  lender: Lender;
+  /** micro-USDC — respects the 50% max user LTV. */
+  maxBorrowUsdc: string;
+  /** collateral base units — keeps LTV ≤ 50%, drift-adjusted. */
+  maxWithdraw: string;
+  /** micro-USDC — min(wallet USDC, debt), minus the JupLend dust shave. */
+  maxRepayUsdc: string;
+  /** collateral base units — first-deposit vs top-up aware. */
+  minDeposit: string;
+  /** lamports held back from Max when depositing SOL. */
+  solReserve: string;
+  /** JupLend rounding shave in collateral base units; "0" on Kamino. */
+  depositBuffer: string;
+  maxUserLtvPct: number;
+  /** % — per active lender + collateral. */
+  liquidationLtvPct: number;
+}
+
+async function fetchCollateralPriceUsd(base: string, label: string): Promise<number> {
+  const route = label === "SOL" ? "sol-price" : "btc-price";
+  const res = await fetch(`${base}/api/${route}`);
+  if (!res.ok) throw new Error(`${route} fetch failed: ${res.status}`);
+  const data = await res.json();
+  const price = Number(data.price);
+  if (!Number.isFinite(price) || price <= 0) throw new Error(`${route} returned no price`);
+  return price;
+}
+
+async function fetchLiquidationLtvPct(
+  base: string,
+  lender: Lender,
+  label: string,
+): Promise<number> {
+  try {
+    const res = await fetch(`${base}/api/rates`);
+    if (!res.ok) throw new Error(String(res.status));
+    const data = await res.json();
+    const table = lender === "juplend" ? data.juplendCollateralLtvs : data.collateralLtvs;
+    const pct = Number(table?.[label]?.liquidationThresholdPct);
+    if (Number.isFinite(pct) && pct > 0) return pct;
+  } catch {
+    /* fall through to constants */
+  }
+  return LIMITS_CONFIG.fallbackLiquidationLtvPct[lender][label] ?? 80;
+}
+
+async function fetchTokenBalanceBase(
+  connection: Connection,
+  owner: PublicKey,
+  mint: PublicKey,
+): Promise<number> {
+  try {
+    const ata = await getAssociatedTokenAddress(mint, owner);
+    const bal = await connection.getTokenAccountBalance(ata);
+    return Number(bal.value.amount);
+  } catch {
+    return 0;
+  }
+}
+
+export interface GetLimitsParams {
+  connection: Connection;
+  owner: PublicKey;
+  collateralMint: PublicKey;
+  apiBaseUrl?: string;
+}
+
+/**
+ * Single quote for input bounds so integrator math can't drift from protocol
+ * rules (SOL rent reserves, JupLend rounding shaves, klend accrual drift).
+ * Mirrors the app's CalculatorSection / ActionModal / max-withdraw logic.
+ */
+export async function getLimits(params: GetLimitsParams): Promise<HobbaLimits> {
+  const { connection, owner, collateralMint } = params;
+  const base = (params.apiBaseUrl ?? "").replace(/\/+$/, "");
+  const label = collateralLabel(collateralMint);
+  const decimals = collateralDecimals(collateralMint);
+  const isSol = collateralMint.equals(SOL_MINT);
+
+  const position = await getPosition({ connection, owner, collateralMint, apiBaseUrl: base });
+  const [price, liquidationLtvPct] = await Promise.all([
+    fetchCollateralPriceUsd(base, label),
+    fetchLiquidationLtvPct(base, position.lender, label),
+  ]);
+
+  const collateralBase = Number(position.collateral);
+  const userDebtMicro = Number(position.userDebtUsdc);
+  const collateralUsd = (collateralBase / 10 ** decimals) * price;
+  const maxLtv = LIMITS_CONFIG.maxUserLtvPct / 100;
+
+  // Max borrow: 50% of collateral value minus current user debt.
+  const maxBorrowMicro = Math.max(0, Math.floor(collateralUsd * maxLtv * 1e6 - userDebtMicro));
+
+  // Max withdraw: keep post-withdraw LTV ≤ 50%. With debt, shave a per-lender
+  // drift margin so the quote survives until submission: klend needs real
+  // headroom for refresh-time BFAD drift, JupLend only accrual dust. When the
+  // operator has capital deployed, additionally reserve collateral for the
+  // post-unwind residual (see LIMITS_CONFIG.unwindResidualReserve) so a max
+  // withdraw can't strand residual debt against ~zero collateral.
+  const operatorDebtUsd = Number(position.depositedToVault) / 1e6;
+  const unwindResidualUsd =
+    operatorDebtUsd > 0
+      ? Math.max(
+          LIMITS_CONFIG.unwindResidualReserve.floorUsd,
+          operatorDebtUsd * LIMITS_CONFIG.unwindResidualReserve.fracOfOperatorDebt,
+        )
+      : 0;
+  const effectiveDebtUsd = userDebtMicro / 1e6 + unwindResidualUsd;
+  let maxWithdrawBase: number;
+  if (effectiveDebtUsd > 0 && price > 0) {
+    const driftFactor =
+      position.lender === "juplend"
+        ? LIMITS_CONFIG.juplendWithdrawDriftFactor
+        : LIMITS_CONFIG.kaminoWithdrawDriftFactor;
+    const minCollateralUsd = effectiveDebtUsd / maxLtv;
+    const maxWithdrawUsd = Math.max(0, collateralUsd - minCollateralUsd);
+    maxWithdrawBase = Math.floor(
+      ((maxWithdrawUsd / price) * 10 ** decimals) / driftFactor,
+    );
+    maxWithdrawBase = Math.min(maxWithdrawBase, collateralBase);
+  } else {
+    maxWithdrawBase = collateralBase;
+  }
+
+  // Max repay: wallet USDC capped at debt; JupLend leaves rounding dust.
+  const walletUsdcMicro = await fetchTokenBalanceBase(connection, owner, USDC_MINT);
+  let maxRepayMicro: number;
+  if (position.lender === "juplend") {
+    // Cap at debt - shave so the residual clears JupLend's min-debt floor
+    // (VAULT_USER_DEBT_TOO_LOW) whether the wallet or the debt is the binding
+    // limit; the extra micro off the wallet cap guards balance rounding.
+    const targetMicro = Math.max(0, userDebtMicro - LIMITS_CONFIG.juplendRepayShaveMicro);
+    maxRepayMicro = Math.max(0, Math.min(walletUsdcMicro - 1, targetMicro));
+  } else {
+    maxRepayMicro = Math.min(walletUsdcMicro, userDebtMicro);
+  }
+
+  const minDepositUi = position.exists
+    ? LIMITS_CONFIG.minDepositUi[label]?.topUp
+    : LIMITS_CONFIG.minDepositUi[label]?.first;
+  const minDepositBase = Math.round((minDepositUi ?? 0) * 10 ** decimals);
+
+  const solReserveLamports = isSol
+    ? position.exists
+      ? LIMITS_CONFIG.solReserveLamports.topUp
+      : LIMITS_CONFIG.solReserveLamports.first
+    : 0;
+
+  const depositBufferBase =
+    position.lender === "juplend" ? (LIMITS_CONFIG.juplendDepositBufferBase[label] ?? 0) : 0;
+
+  return {
+    lender: position.lender,
+    maxBorrowUsdc: String(maxBorrowMicro),
+    maxWithdraw: String(maxWithdrawBase),
+    maxRepayUsdc: String(maxRepayMicro),
+    minDeposit: String(minDepositBase),
+    solReserve: String(solReserveLamports),
+    depositBuffer: String(depositBufferBase),
+    maxUserLtvPct: LIMITS_CONFIG.maxUserLtvPct,
+    liquidationLtvPct,
+  };
+}

package/src/marketConfig.ts

@@ -0,0 +1,139 @@
+import { PublicKey } from "@solana/web3.js";
+import {
+  MAIN_MARKET,
+  XSTOCKS_MARKET,
+  CBBTC_MINT,
+  SOL_MINT,
+  CBBTC_RESERVE,
+  CBBTC_LIQUIDITY_SUPPLY,
+  CBBTC_COLLATERAL_MINT,
+  CBBTC_COLLATERAL_SUPPLY,
+  CBBTC_RESERVE_FARM_COLLATERAL,
+  SOL_RESERVE,
+  SOL_LIQUIDITY_SUPPLY,
+  SOL_COLLATERAL_MINT,
+  SOL_COLLATERAL_SUPPLY,
+  SOL_RESERVE_FARM_COLLATERAL,
+  USDC_RESERVE,
+  USDC_LIQUIDITY_SUPPLY,
+  USDC_FEE_VAULT,
+  SCOPE_PRICES,
+  XSTOCKS_CBBTC_RESERVE,
+  XSTOCKS_USDC_RESERVE,
+  XSTOCKS_CBBTC_LIQUIDITY_SUPPLY,
+  XSTOCKS_CBBTC_COLLATERAL_MINT,
+  XSTOCKS_CBBTC_COLLATERAL_SUPPLY,
+  XSTOCKS_USDC_LIQUIDITY_SUPPLY,
+  XSTOCKS_USDC_FEE_VAULT,
+  XSTOCKS_USDC_RESERVE_FARM_DEBT,
+} from "./constants";
+import { deriveMarketAuthority } from "./pdas";
+
+export interface KaminoMarketConfig {
+  collateralMint: PublicKey;
+  market: PublicKey;
+  marketAuthority: PublicKey;
+  collateralReserve: PublicKey;
+  collateralLiquiditySupply: PublicKey;
+  collateralCTokenMint: PublicKey;
+  collateralCTokenSupply: PublicKey;
+  collateralFarmState: PublicKey | null;
+  usdcReserve: PublicKey;
+  usdcLiquiditySupply: PublicKey;
+  usdcFeeVault: PublicKey;
+  usdcReserveFarmDebt: PublicKey | null;
+  scopePrices: PublicKey;
+}
+
+const [mainMarketAuthority] = deriveMarketAuthority(MAIN_MARKET);
+
+export const MAIN_MARKET_CONFIG: KaminoMarketConfig = {
+  collateralMint: CBBTC_MINT,
+  market: MAIN_MARKET,
+  marketAuthority: mainMarketAuthority,
+  collateralReserve: CBBTC_RESERVE,
+  collateralLiquiditySupply: CBBTC_LIQUIDITY_SUPPLY,
+  collateralCTokenMint: CBBTC_COLLATERAL_MINT,
+  collateralCTokenSupply: CBBTC_COLLATERAL_SUPPLY,
+  collateralFarmState: CBBTC_RESERVE_FARM_COLLATERAL,
+  usdcReserve: USDC_RESERVE,
+  usdcLiquiditySupply: USDC_LIQUIDITY_SUPPLY,
+  usdcFeeVault: USDC_FEE_VAULT,
+  usdcReserveFarmDebt: null,
+  scopePrices: SCOPE_PRICES,
+};
+
+export const SOL_MAIN_MARKET_CONFIG: KaminoMarketConfig = {
+  collateralMint: SOL_MINT,
+  market: MAIN_MARKET,
+  marketAuthority: mainMarketAuthority,
+  collateralReserve: SOL_RESERVE,
+  collateralLiquiditySupply: SOL_LIQUIDITY_SUPPLY,
+  collateralCTokenMint: SOL_COLLATERAL_MINT,
+  collateralCTokenSupply: SOL_COLLATERAL_SUPPLY,
+  collateralFarmState: SOL_RESERVE_FARM_COLLATERAL,
+  usdcReserve: USDC_RESERVE,
+  usdcLiquiditySupply: USDC_LIQUIDITY_SUPPLY,
+  usdcFeeVault: USDC_FEE_VAULT,
+  usdcReserveFarmDebt: null,
+  scopePrices: SCOPE_PRICES,
+};
+
+const [xstocksMarketAuthority] = deriveMarketAuthority(XSTOCKS_MARKET);
+
+export const XSTOCKS_MARKET_CONFIG: KaminoMarketConfig = {
+  collateralMint: CBBTC_MINT,
+  market: XSTOCKS_MARKET,
+  marketAuthority: xstocksMarketAuthority,
+  collateralReserve: XSTOCKS_CBBTC_RESERVE,
+  collateralLiquiditySupply: XSTOCKS_CBBTC_LIQUIDITY_SUPPLY,
+  collateralCTokenMint: XSTOCKS_CBBTC_COLLATERAL_MINT,
+  collateralCTokenSupply: XSTOCKS_CBBTC_COLLATERAL_SUPPLY,
+  collateralFarmState: null,
+  usdcReserve: XSTOCKS_USDC_RESERVE,
+  usdcLiquiditySupply: XSTOCKS_USDC_LIQUIDITY_SUPPLY,
+  usdcFeeVault: XSTOCKS_USDC_FEE_VAULT,
+  usdcReserveFarmDebt: XSTOCKS_USDC_RESERVE_FARM_DEBT,
+  scopePrices: SCOPE_PRICES,
+};
+
+export async function resolveXStocksConfig(): Promise<KaminoMarketConfig> {
+  return XSTOCKS_MARKET_CONFIG;
+}
+
+/**
+ * Resolve market config for a given market address.
+ * Main Market uses hardcoded addresses; XStocks fetches from mainnet.
+ */
+export async function resolveMarketConfig(
+  market: PublicKey
+): Promise<KaminoMarketConfig | null> {
+  if (market.equals(MAIN_MARKET)) return MAIN_MARKET_CONFIG;
+  if (market.equals(XSTOCKS_MARKET)) return resolveXStocksConfig();
+  return null;
+}
+
+/**
+ * Resolve market config for a given collateral mint on Main Market.
+ */
+export function resolveMainMarketConfigByMint(
+  collateralMint: PublicKey
+): KaminoMarketConfig {
+  if (collateralMint.equals(SOL_MINT)) return SOL_MAIN_MARKET_CONFIG;
+  return MAIN_MARKET_CONFIG;
+}
+
+/**
+ * Resolve the best Kamino market config based on the rates API response.
+ * Returns the config for whichever Kamino market has the lowest borrow APY.
+ */
+export async function resolveBestKaminoConfig(
+  bestMarketName: string | null
+): Promise<KaminoMarketConfig> {
+  if (bestMarketName === "Kamino xStocks") {
+    const xstocks = await resolveXStocksConfig();
+    if (xstocks) return xstocks;
+  }
+  // Default to Main Market
+  return MAIN_MARKET_CONFIG;
+}

package/src/oracle/scopePrice.ts

@@ -0,0 +1,31 @@
+/**
+ * Kamino Scope oracle price decoding, shared by /api/btc-price and
+ * /api/sol-price (and any script needing a Scope-chain USD price).
+ * Server-leaning (decodeReserve lazy-requires klend-sdk) — import via the
+ * subpath `@hobba/core/oracle/scopePrice`, not core's index.
+ */
+import { decodeReserve } from "../rates/borrowRates";
+
+// Scope oracle layout: 8 disc + 32 oracleMappings + 512×56 prices
+export const SCOPE_PRICES_OFFSET = 40; // 8 + 32
+export const SCOPE_ENTRY_SIZE = 56;    // DatedPrice: 8 value + 8 exp + ...
+
+/** Scope price-chain token indices configured on a klend reserve. */
+export function getReservePriceChain(reserveData: Buffer): number[] {
+  const reserve = decodeReserve(reserveData);
+  return reserve.config.tokenInfo.scopeConfiguration.priceChain.map((x: any) => Number(x));
+}
+
+/** Walk the price chain through the Scope prices account, multiplying hops. */
+export function readScopePrice(scopeData: Buffer, priceChain: number[]): number {
+  let price = 1.0;
+  for (const tokenIndex of priceChain) {
+    if (tokenIndex === 65535) break;
+    const entryOffset = SCOPE_PRICES_OFFSET + tokenIndex * SCOPE_ENTRY_SIZE;
+    if (entryOffset + 16 > scopeData.length) break;
+    const value = Number(scopeData.readBigUInt64LE(entryOffset));
+    const exp = Number(scopeData.readBigUInt64LE(entryOffset + 8));
+    price *= value * Math.pow(10, -exp);
+  }
+  return price;
+}

package/src/pdas.ts

@@ -0,0 +1,226 @@
+import { PublicKey } from "@solana/web3.js";
+import { getAssociatedTokenAddress } from "@solana/spl-token";
+import BN from "bn.js";
+import {
+  PROGRAM_ID,
+  KAMINO_LENDING_PROGRAM_ID,
+  KVAULT_PROGRAM_ID,
+  FARMS_PROGRAM,
+  JUPLEND_PROGRAM,
+  METAPLEX_PROGRAM,
+  USDC_MINT,
+  ALLEZ_USDC_SHARES_MINT,
+  USDC_PRIME_SHARES_MINT,
+  ROCKAWAY_RWA_SHARES_MINT,
+  STAR_USDC_MINT,
+  JUPLEND_MAX_TICK,
+} from "./constants";
+
+export function deriveUserStatePda(owner: PublicKey, collateralMint: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("user_state"), owner.toBuffer(), collateralMint.toBuffer()],
+    PROGRAM_ID
+  );
+}
+
+export function deriveAllowlistEntryPda(owner: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("allowlist"), owner.toBuffer()],
+    PROGRAM_ID
+  );
+}
+
+export function deriveProgramConfigPda(): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("program_config")],
+    PROGRAM_ID
+  );
+}
+
+export function deriveDepositConfigPda(collateralMint: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("deposit_config"), collateralMint.toBuffer()],
+    PROGRAM_ID
+  );
+}
+
+export function deriveOriginConfigPda(origin: number): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("origin_config"), Buffer.from([origin])],
+    PROGRAM_ID
+  );
+}
+
+export function deriveUserOriginPda(owner: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("user_origin"), owner.toBuffer()],
+    PROGRAM_ID
+  );
+}
+
+export function deriveObligationPda(
+  userStatePda: PublicKey,
+  market: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from([0]),
+      Buffer.from([0]),
+      userStatePda.toBuffer(),
+      market.toBuffer(),
+      PublicKey.default.toBuffer(),
+      PublicKey.default.toBuffer(),
+    ],
+    KAMINO_LENDING_PROGRAM_ID
+  );
+}
+
+export function deriveUserMetadataPda(userStatePda: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("user_meta"), userStatePda.toBuffer()],
+    KAMINO_LENDING_PROGRAM_ID
+  );
+}
+
+export function deriveMarketAuthority(market: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("lma"), market.toBuffer()],
+    KAMINO_LENDING_PROGRAM_ID
+  );
+}
+
+export function deriveFarmUserStatePda(
+  farmState: PublicKey,
+  obligation: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("user"), farmState.toBuffer(), obligation.toBuffer()],
+    FARMS_PROGRAM
+  );
+}
+
+export function deriveKvaultEventAuthority(): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("__event_authority")],
+    KVAULT_PROGRAM_ID
+  );
+}
+
+export function deriveKvaultGlobalConfig(): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("global_config")],
+    KVAULT_PROGRAM_ID
+  );
+}
+
+// JupLend PDAs
+export function deriveJuplendPositionPda(
+  vaultId: number,
+  positionId: number
+): [PublicKey, number] {
+  const vaultIdBytes = Buffer.alloc(2);
+  vaultIdBytes.writeUInt16LE(vaultId);
+  const positionIdBytes = Buffer.alloc(4);
+  positionIdBytes.writeUInt32LE(positionId);
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("position"), vaultIdBytes, positionIdBytes],
+    JUPLEND_PROGRAM
+  );
+}
+
+export function deriveJuplendPositionMintPda(
+  vaultId: number,
+  positionId: number
+): [PublicKey, number] {
+  const vaultIdBytes = Buffer.alloc(2);
+  vaultIdBytes.writeUInt16LE(vaultId);
+  const positionIdBytes = Buffer.alloc(4);
+  positionIdBytes.writeUInt32LE(positionId);
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("position_mint"), vaultIdBytes, positionIdBytes],
+    JUPLEND_PROGRAM
+  );
+}
+
+export function deriveJuplendTickPda(vaultId: number, tick: number): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("tick"),
+      new BN(vaultId).toArrayLike(Buffer, "le", 2),
+      new BN(tick + JUPLEND_MAX_TICK).toArrayLike(Buffer, "le", 4),
+    ],
+    JUPLEND_PROGRAM
+  );
+  return pda;
+}
+
+export function deriveJuplendTickIdLiquidationPda(
+  vaultId: number,
+  tick: number,
+  totalIds: number = 0
+): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("tick_id_liquidation"),
+      new BN(vaultId).toArrayLike(Buffer, "le", 2),
+      new BN(tick + JUPLEND_MAX_TICK).toArrayLike(Buffer, "le", 4),
+      new BN(Math.floor((totalIds + 2) / 3)).toArrayLike(Buffer, "le", 4),
+    ],
+    JUPLEND_PROGRAM
+  );
+  return pda;
+}
+
+export function derivePositionMetadataPda(positionMint: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("metadata"), METAPLEX_PROGRAM.toBuffer(), positionMint.toBuffer()],
+    METAPLEX_PROGRAM
+  );
+}
+
+// Derive all PDA token accounts for a user
+export async function deriveUserTokenAccounts(
+  owner: PublicKey,
+  userStatePda: PublicKey,
+  collateralMint: PublicKey
+) {
+  const [userCollateralAta, pdaCollateralAta, userUsdcAta, pdaUsdcAta, pdaSharesAta, pdaPrimeSharesAta, pdaRockawaySharesAta, pdaPerenaSharesAta] =
+    await Promise.all([
+      getAssociatedTokenAddress(collateralMint, owner),
+      getAssociatedTokenAddress(collateralMint, userStatePda, true),
+      getAssociatedTokenAddress(USDC_MINT, owner),
+      getAssociatedTokenAddress(USDC_MINT, userStatePda, true),
+      getAssociatedTokenAddress(ALLEZ_USDC_SHARES_MINT, userStatePda, true),
+      getAssociatedTokenAddress(USDC_PRIME_SHARES_MINT, userStatePda, true),
+      getAssociatedTokenAddress(ROCKAWAY_RWA_SHARES_MINT, userStatePda, true),
+      getAssociatedTokenAddress(STAR_USDC_MINT, userStatePda, true),
+    ]);
+
+  return {
+    userCollateralAta,
+    pdaCollateralAta,
+    userUsdcAta,
+    pdaUsdcAta,
+    pdaSharesAta,
+    pdaPrimeSharesAta,
+    pdaRockawaySharesAta,
+    pdaPerenaSharesAta,
+  };
+}
+
+// Derive farm PDAs for any market, given its farm addresses
+export function deriveFarmPdas(
+  obligationPda: PublicKey,
+  collateralFarmState: PublicKey | null,
+  usdcReserveFarmDebt: PublicKey | null
+) {
+  const obligationFarmUserStatePda = collateralFarmState
+    ? deriveFarmUserStatePda(collateralFarmState, obligationPda)[0]
+    : KAMINO_LENDING_PROGRAM_ID;
+
+  const obligationFarmDebtUserStatePda = usdcReserveFarmDebt
+    ? deriveFarmUserStatePda(usdcReserveFarmDebt, obligationPda)[0]
+    : KAMINO_LENDING_PROGRAM_ID;
+
+  return { obligationFarmUserStatePda, obligationFarmDebtUserStatePda };
+}