@hobba-io/core 0.1.0

package/src/juplend/tickUtils.ts

@@ -0,0 +1,163 @@
+import {
+  Connection,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import {
+  JUPLEND_PROGRAM,
+  JUPLEND_VAULT_ID,
+  deriveJuplendVaultConfigPda,
+} from "../constants";
+import {
+  deriveJuplendTickPda,
+  deriveJuplendTickIdLiquidationPda,
+} from "../pdas";
+
+// InitTick discriminator: [22, 13, 62, 141, 73, 89, 178, 29]
+const INIT_TICK_DISC = Buffer.from([22, 13, 62, 141, 73, 89, 178, 29]);
+// InitTickIdLiquidation discriminator: [221, 173, 234, 108, 69, 217, 237, 101]
+const INIT_TICK_ID_LIQ_DISC = Buffer.from([221, 173, 234, 108, 69, 217, 237, 101]);
+
+export function buildInitTickIx(
+  vaultId: number,
+  tick: number,
+  payer: PublicKey
+): TransactionInstruction {
+  const tickPda = deriveJuplendTickPda(vaultId, tick);
+  const vaultConfig = deriveJuplendVaultConfigPda(vaultId);
+  const data = Buffer.alloc(14);
+  data.set(INIT_TICK_DISC, 0);
+  data.writeUInt16LE(vaultId, 8);
+  data.writeInt32LE(tick, 10);
+  return new TransactionInstruction({
+    programId: JUPLEND_PROGRAM,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: vaultConfig, isSigner: false, isWritable: false },
+      { pubkey: tickPda, isSigner: false, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ],
+    data,
+  });
+}
+
+export function buildInitTickIdLiquidationIx(
+  vaultId: number,
+  tick: number,
+  totalIds: number,
+  payer: PublicKey
+): TransactionInstruction {
+  const tickPda = deriveJuplendTickPda(vaultId, tick);
+  const tickIdPda = deriveJuplendTickIdLiquidationPda(vaultId, tick, totalIds);
+  const data = Buffer.alloc(18);
+  data.set(INIT_TICK_ID_LIQ_DISC, 0);
+  data.writeUInt16LE(vaultId, 8);
+  data.writeInt32LE(tick, 10);
+  data.writeUInt32LE(totalIds, 14);
+  // initTickIdLiquidation: [signer, tickData (existing), tickIdLiquidation (new), systemProgram]
+  // Slot 1 is tickData (NOT vaultConfig — initTick is the sibling that uses
+  // vaultConfig). Matches the production /api/juplend-operate builder.
+  return new TransactionInstruction({
+    programId: JUPLEND_PROGRAM,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: tickPda, isSigner: false, isWritable: false },
+      { pubkey: tickIdPda, isSigner: false, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ],
+    data,
+  });
+}
+
+/**
+ * Reverse-derive a tick value from its PDA. Searches outward from `startTick`
+ * (usually the position's current tick, < 50 iterations) before falling back
+ * to the full ±16383 range.
+ */
+export function tickValueFromPda(
+  pda: PublicKey,
+  vaultId: number,
+  startTick: number = 0,
+  maxTick: number = 16383,
+): number | null {
+  for (let delta = 0; delta <= 1000; delta++) {
+    for (const tick of delta === 0 ? [startTick] : [startTick + delta, startTick - delta]) {
+      if (tick < -maxTick || tick > maxTick) continue;
+      if (deriveJuplendTickPda(vaultId, tick).equals(pda)) return tick;
+    }
+  }
+  // Fallback: full range (should rarely hit this)
+  for (let tick = -maxTick; tick <= maxTick; tick++) {
+    if (deriveJuplendTickPda(vaultId, tick).equals(pda)) return tick;
+  }
+  return null;
+}
+
+export interface TickAccounts {
+  currentTickPda: PublicKey;
+  finalTickPda: PublicKey;
+  currentTickIdPda: PublicKey;
+  finalTickIdPda: PublicKey;
+  initIxs: TransactionInstruction[];
+}
+
+// Derive tick + tickId PDAs for current and final ticks, check existence, return init instructions
+export async function resolveTickAccounts(
+  connection: Connection,
+  payer: PublicKey,
+  currentTick: number,
+  finalTick: number,
+  vaultId: number = JUPLEND_VAULT_ID
+): Promise<TickAccounts> {
+  const currentTickPda = deriveJuplendTickPda(vaultId, currentTick);
+  const currentTickIdPda = deriveJuplendTickIdLiquidationPda(vaultId, currentTick);
+  const finalTickPda = deriveJuplendTickPda(vaultId, finalTick);
+  const finalTickIdPda = deriveJuplendTickIdLiquidationPda(vaultId, finalTick);
+
+  const initIxs: TransactionInstruction[] = [];
+  const checked = new Set<string>();
+
+  for (const { tickPda, tickIdPda, tick } of [
+    { tickPda: currentTickPda, tickIdPda: currentTickIdPda, tick: currentTick },
+    { tickPda: finalTickPda, tickIdPda: finalTickIdPda, tick: finalTick },
+  ]) {
+    const key = tickPda.toBase58();
+    if (checked.has(key)) continue;
+    checked.add(key);
+
+    const [tickInfo, tickIdInfo] = await Promise.all([
+      connection.getAccountInfo(tickPda).catch(() => null),
+      connection.getAccountInfo(tickIdPda).catch(() => null),
+    ]);
+
+    if (!tickInfo) {
+      initIxs.push(buildInitTickIx(vaultId, tick, payer));
+    }
+    if (!tickIdInfo) {
+      initIxs.push(buildInitTickIdLiquidationIx(vaultId, tick, 0, payer));
+    }
+  }
+
+  return { currentTickPda, finalTickPda, currentTickIdPda, finalTickIdPda, initIxs };
+}
+
+// Parse expected tick from VaultTickMismatch error
+export function parseTickMismatch(errorMsg: string): number | null {
+  const match = errorMsg.match(/Tick mismatch: expected (-?\d+) but got (-?\d+)/);
+  return match ? parseInt(match[1]) : null;
+}
+
+export function isTickError(errorMsg: string): boolean {
+  return (
+    errorMsg.includes("VaultTickMismatch") ||
+    errorMsg.includes("Tick mismatch") ||
+    errorMsg.includes("VaultInvalidTick") ||
+    errorMsg.includes("VAULT_INVALID_TICK") ||
+    errorMsg.includes("VaultTickHasDebtNotFound") ||
+    errorMsg.includes("VAULT_TICK_HAS_DEBT_NOT_FOUND") ||
+    errorMsg.includes("0x1792") || // VaultTickMismatch
+    errorMsg.includes("0x179a") || // VaultInvalidTick
+    errorMsg.includes("0x1791")    // VaultTickHasDebtNotFound
+  );
+}

package/src/juplend/vaultConfigParser.ts

@@ -0,0 +1,45 @@
+/**
+ * JupLend VaultConfig byte-layout knowledge, centralized. Browser-safe.
+ * (The LTV/liquidation-threshold fields at the head of the same struct are
+ * decoded by rates/borrowRates.getJuplendCollateralLtvInfo.)
+ */
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+
+/**
+ * VaultConfig is bytemuck-packed; `oracle` lives 26 bytes after the 8-byte
+ * Anchor discriminator (sum of the preceding 9× u16 / i16 fields).
+ */
+export const JUPLEND_VAULT_CONFIG_ORACLE_OFFSET = 8 + 2 * 9;
+
+/** Oracle pubkey configured on a JupLend vault_config account. */
+export function parseVaultConfigOracle(vaultConfigData: Buffer): PublicKey {
+  if (vaultConfigData.length < JUPLEND_VAULT_CONFIG_ORACLE_OFFSET + 32) {
+    throw new Error("vault_config account too short");
+  }
+  return new PublicKey(
+    vaultConfigData.subarray(
+      JUPLEND_VAULT_CONFIG_ORACLE_OFFSET,
+      JUPLEND_VAULT_CONFIG_ORACLE_OFFSET + 32,
+    ),
+  );
+}
+
+/** Supply token decimals per vault (determines exchange rate divisor). */
+export const SUPPLY_DECIMALS_BY_VAULT: Record<number, number> = {
+  1: 9,  // SOL (wSOL) — 9 decimals
+  11: 8, // cbBTC — 8 decimals
+};
+
+/**
+ * Convert JupLend shares to native token base units. Exchange prices are
+ * scaled by 10^12; the divisor folds in the token-decimal difference vs SOL:
+ *   SOL   (9 decimals): 10^(12 + 0) = 10^12
+ *   cbBTC (8 decimals): 10^(12 + 1) = 10^13
+ *   USDC  (6 decimals): 10^(12 + 3) = 10^15
+ */
+export function sharesToBaseUnits(shares: BN, exchangePrice: BN, tokenDecimals: number): BN {
+  if (!exchangePrice.gt(new BN(0))) return new BN(0);
+  const divisor = new BN(10).pow(new BN(12 + (9 - tokenDecimals)));
+  return shares.mul(exchangePrice).div(divisor);
+}

package/src/kamino/accountResolvers.ts

@@ -0,0 +1,299 @@
+import { PublicKey, SystemProgram, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RENT_PUBKEY, AccountMeta } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync } from "@solana/spl-token";
+import {
+  KAMINO_LENDING_PROGRAM_ID,
+  FARMS_PROGRAM,
+  ATA_PROGRAM_ID,
+  USDC_MINT,
+  SCOPE_PRICES,
+} from "../constants";
+import { deriveDepositConfigPda, deriveOriginConfigPda, deriveProgramConfigPda, deriveUserOriginPda } from "../pdas";
+import { KaminoMarketConfig } from "../marketConfig";
+
+interface UserPdas {
+  userStatePda: PublicKey;
+  allowlistEntryPda: PublicKey;
+  obligationPda: PublicKey;
+  userMetadataPda: PublicKey;
+  obligationFarmUserStatePda: PublicKey;
+  obligationFarmDebtUserStatePda: PublicKey;
+  userCollateralAta: PublicKey;
+  userUsdcAta: PublicKey;
+  pdaCollateralAta: PublicKey;
+  pdaUsdcAta: PublicKey;
+  pdaSharesAta: PublicKey;
+}
+
+const [programConfigPda] = deriveProgramConfigPda();
+
+export function getInitializeUserAccounts(owner: PublicKey, pdas: UserPdas, mc: KaminoMarketConfig, origin: number = 0) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    collateralMint: mc.collateralMint,
+    systemProgram: SystemProgram.programId,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    depositConfig: deriveDepositConfigPda(mc.collateralMint)[0],
+    // Per-wallet origin registration; created on the wallet's first init,
+    // later inits keep the stored origin (the origin arg is then ignored).
+    userOrigin: deriveUserOriginPda(owner)[0],
+    // Seeded by the `origin` instruction arg — always pass explicitly rather
+    // than relying on Anchor's IDL auto-resolution.
+    originConfig: deriveOriginConfigPda(origin)[0],
+  };
+}
+
+/// Returns 7 Kamino initialize_user lender accounts as AccountMeta[] for remaining_accounts.
+export function getKaminoInitializeUserLenderAccounts(
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+): AccountMeta[] {
+  return [
+    { pubkey: pdas.obligationPda, isSigner: false, isWritable: true },
+    { pubkey: mc.market, isSigner: false, isWritable: false },
+    { pubkey: PublicKey.default, isSigner: false, isWritable: false }, // seed1
+    { pubkey: PublicKey.default, isSigner: false, isWritable: false }, // seed2
+    { pubkey: pdas.userMetadataPda, isSigner: false, isWritable: true },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+  ];
+}
+
+export function getDepositAccounts(owner: PublicKey, pdas: UserPdas, mc: KaminoMarketConfig) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    userSourceLiquidity: pdas.userCollateralAta,
+    pdaSourceLiquidity: pdas.pdaCollateralAta,
+    supplyTokenMint: mc.collateralMint,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    associatedTokenProgram: ATA_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    collateralMint: mc.collateralMint,
+  };
+}
+
+/// Returns 15 Kamino deposit lender accounts as AccountMeta[] for remaining_accounts.
+export function getKaminoDepositLenderAccounts(
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+): AccountMeta[] {
+  const hasFarms = !!mc.collateralFarmState;
+  return [
+    { pubkey: pdas.obligationPda, isSigner: false, isWritable: true },
+    { pubkey: mc.market, isSigner: false, isWritable: false },
+    { pubkey: mc.marketAuthority, isSigner: false, isWritable: false },
+    { pubkey: mc.collateralReserve, isSigner: false, isWritable: true },
+    { pubkey: mc.collateralLiquiditySupply, isSigner: false, isWritable: true },
+    { pubkey: mc.collateralCTokenMint, isSigner: false, isWritable: true },
+    { pubkey: mc.collateralCTokenSupply, isSigner: false, isWritable: true },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }, // placeholder_user_destination_collateral
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, // collateral_token_program
+    { pubkey: pdas.obligationFarmUserStatePda, isSigner: false, isWritable: hasFarms },
+    { pubkey: mc.collateralFarmState ?? KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: hasFarms },
+    { pubkey: FARMS_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+  ];
+}
+
+export function getBorrowAccounts(
+  owner: PublicKey,
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+  hasVaultShares: boolean,
+  vaultAccounts?: {
+    vault: PublicKey;
+    sharesMint: PublicKey;
+    sharesAta: PublicKey;
+  }
+) {
+  const va = vaultAccounts;
+  // Canonical ATA of the placeholder shares mint (the wallet pubkey), so the
+  // program's pda_shares_ata == ATA(user_state, shares_mint) check holds when no vault is used.
+  const placeholderSharesAta = getAssociatedTokenAddressSync(owner, pdas.userStatePda, true);
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    collateralMint: mc.collateralMint,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    userUsdcAta: pdas.userUsdcAta,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    systemProgram: SystemProgram.programId,
+    vault: hasVaultShares && va ? va.vault : owner,
+    sharesMint: hasVaultShares && va ? va.sharesMint : owner,
+    pdaSharesAta: hasVaultShares && va ? va.sharesAta : placeholderSharesAta,
+    sharesTokenProgram: hasVaultShares ? TOKEN_PROGRAM_ID : SystemProgram.programId,
+    usdcMint: USDC_MINT,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+  };
+}
+
+/// Returns 15 Kamino lender accounts as AccountMeta[] for remaining_accounts.
+export function getKaminoBorrowLenderAccounts(
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+  hasVaultShares: boolean,
+): AccountMeta[] {
+  const hasFarms = !!mc.usdcReserveFarmDebt;
+  return [
+    { pubkey: pdas.obligationPda, isSigner: false, isWritable: true },
+    { pubkey: mc.market, isSigner: false, isWritable: false },
+    { pubkey: mc.marketAuthority, isSigner: false, isWritable: false },
+    { pubkey: mc.usdcReserve, isSigner: false, isWritable: true },
+    { pubkey: mc.usdcLiquiditySupply, isSigner: false, isWritable: true },
+    { pubkey: mc.usdcFeeVault, isSigner: false, isWritable: true },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false }, // referrer_token_state
+    { pubkey: pdas.obligationFarmDebtUserStatePda, isSigner: false, isWritable: hasFarms },
+    { pubkey: mc.usdcReserveFarmDebt ?? KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: hasFarms },
+    { pubkey: FARMS_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+    { pubkey: hasVaultShares ? SCOPE_PRICES : SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: mc.collateralReserve, isSigner: false, isWritable: true },
+    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false }, // kamino_program
+  ];
+}
+
+export function getRepayAccounts(owner: PublicKey, pdas: UserPdas, mc: KaminoMarketConfig) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    userUsdcAta: pdas.userUsdcAta,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    collateralMint: mc.collateralMint,
+  };
+}
+
+/// Returns 11 Kamino repay lender accounts as AccountMeta[] for remaining_accounts.
+export function getKaminoRepayLenderAccounts(
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+): AccountMeta[] {
+  const hasFarms = !!mc.usdcReserveFarmDebt;
+  return [
+    { pubkey: pdas.obligationPda, isSigner: false, isWritable: true },
+    { pubkey: mc.market, isSigner: false, isWritable: false },
+    { pubkey: mc.marketAuthority, isSigner: false, isWritable: false },
+    { pubkey: mc.usdcReserve, isSigner: false, isWritable: true },
+    { pubkey: USDC_MINT, isSigner: false, isWritable: false },
+    { pubkey: mc.usdcLiquiditySupply, isSigner: false, isWritable: true },
+    { pubkey: pdas.obligationFarmDebtUserStatePda, isSigner: false, isWritable: hasFarms },
+    { pubkey: mc.usdcReserveFarmDebt ?? KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: hasFarms },
+    { pubkey: FARMS_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+  ];
+}
+
+export function getWithdrawAccounts(owner: PublicKey, pdas: UserPdas, mc: KaminoMarketConfig) {
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    pdaDestinationAta: pdas.pdaCollateralAta,
+    userDestinationAta: pdas.userCollateralAta,
+    tokenProgram: TOKEN_PROGRAM_ID,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    collateralMint: mc.collateralMint,
+  };
+}
+
+/// Returns 15 Kamino withdraw lender accounts as AccountMeta[] for remaining_accounts.
+export function getKaminoWithdrawLenderAccounts(
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+): AccountMeta[] {
+  const hasFarms = !!mc.collateralFarmState;
+  return [
+    { pubkey: pdas.obligationPda, isSigner: false, isWritable: true },
+    { pubkey: mc.market, isSigner: false, isWritable: false },
+    { pubkey: mc.marketAuthority, isSigner: false, isWritable: false },
+    { pubkey: mc.collateralReserve, isSigner: false, isWritable: true },
+    { pubkey: mc.collateralMint, isSigner: false, isWritable: false },
+    { pubkey: mc.collateralCTokenSupply, isSigner: false, isWritable: true },
+    { pubkey: mc.collateralCTokenMint, isSigner: false, isWritable: true },
+    { pubkey: mc.collateralLiquiditySupply, isSigner: false, isWritable: true },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }, // placeholder_user_destination_collateral
+    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }, // collateral_token_program
+    { pubkey: pdas.obligationFarmUserStatePda, isSigner: false, isWritable: hasFarms },
+    { pubkey: mc.collateralFarmState ?? KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: hasFarms },
+    { pubkey: FARMS_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+  ];
+}
+
+export function getPrepareWithdrawAccounts(
+  owner: PublicKey,
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+  vaultAccounts: {
+    vault: PublicKey;
+    sharesMint: PublicKey;
+    sharesAta: PublicKey;
+  }
+) {
+  const va = vaultAccounts;
+  return {
+    owner,
+    userState: pdas.userStatePda,
+    collateralMint: mc.collateralMint,
+    programConfig: programConfigPda,
+    allowlistEntry: pdas.allowlistEntryPda,
+    pdaUsdcAta: pdas.pdaUsdcAta,
+    vault: va.vault,
+    sharesMint: va.sharesMint,
+    pdaSharesAta: va.sharesAta,
+    sharesTokenProgram: TOKEN_PROGRAM_ID,
+    usdcMint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ID,
+  };
+}
+
+/// Returns 12 Kamino prepare_withdraw lender accounts as AccountMeta[] for remaining_accounts.
+export function getKaminoPrepareWithdrawLenderAccounts(
+  pdas: UserPdas,
+  mc: KaminoMarketConfig,
+): AccountMeta[] {
+  const hasFarms = !!mc.usdcReserveFarmDebt;
+  return [
+    { pubkey: pdas.obligationPda, isSigner: false, isWritable: true },
+    { pubkey: mc.market, isSigner: false, isWritable: false },
+    { pubkey: mc.marketAuthority, isSigner: false, isWritable: false },
+    { pubkey: mc.usdcReserve, isSigner: false, isWritable: true },
+    { pubkey: mc.usdcLiquiditySupply, isSigner: false, isWritable: true },
+    { pubkey: pdas.obligationFarmDebtUserStatePda, isSigner: false, isWritable: hasFarms },
+    { pubkey: mc.usdcReserveFarmDebt ?? KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: hasFarms },
+    { pubkey: FARMS_PROGRAM, isSigner: false, isWritable: false },
+    { pubkey: SCOPE_PRICES, isSigner: false, isWritable: false },
+    { pubkey: SYSVAR_INSTRUCTIONS_PUBKEY, isSigner: false, isWritable: false },
+    { pubkey: mc.collateralReserve, isSigner: false, isWritable: true },
+    { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false }, // kamino_program
+  ];
+}
+
+// Fix farm accounts to be writable when they are real addresses
+export function fixFarmWritable(
+  ixKeys: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[],
+  farmUserState: PublicKey,
+  farmState: PublicKey | null
+) {
+  for (const key of ixKeys) {
+    if (
+      key.pubkey.equals(farmUserState) ||
+      (farmState && key.pubkey.equals(farmState))
+    ) {
+      key.isWritable = true;
+    }
+  }
+}
+

package/src/kamino/obligationParser.ts

@@ -0,0 +1,123 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import { BORROWS_OFFSET, BORROW_ENTRY_SIZE, BORROWED_AMOUNT_SF_OFFSET } from "../constants";
+
+const FRACTION_SCALE = new BN(2).pow(new BN(60));
+
+// Deposits in obligation: offset 96, each entry 136 bytes, depositedAmount at +32 (u64 LE)
+// Layout: 8 disc + 8 tag + 16 lastUpdate + 32 lendingMarket + 32 owner = 96
+// Entry: 32 depositReserve + 8 depositedAmount + 16 marketValueSf + 8 borrowedAgainst + 72 padding = 136
+const DEPOSITS_OFFSET = 96;
+const DEPOSIT_ENTRY_SIZE = 136;
+const DEPOSITED_AMOUNT_OFFSET = 32;
+
+export function parseObligationDebt(data: Buffer): number {
+  let totalBorrowed = new BN(0);
+
+  for (let i = 0; i < 5; i++) {
+    const entryOffset = BORROWS_OFFSET + i * BORROW_ENTRY_SIZE;
+    if (entryOffset + 32 > data.length) break;
+
+    const reserveKey = new PublicKey(data.slice(entryOffset, entryOffset + 32));
+    if (reserveKey.equals(PublicKey.default)) continue;
+
+    const sfOffset = entryOffset + BORROWED_AMOUNT_SF_OFFSET;
+    if (sfOffset + 16 > data.length) continue;
+
+    const borrowedAmountSf = new BN(data.slice(sfOffset, sfOffset + 16), "le");
+    const borrowedAmount = borrowedAmountSf.div(FRACTION_SCALE);
+    totalBorrowed = totalBorrowed.add(borrowedAmount);
+  }
+
+  return totalBorrowed.toNumber();
+}
+
+export function parseObligationCTokens(data: Buffer): number {
+  let totalCTokens = new BN(0);
+
+  for (let i = 0; i < 8; i++) {
+    const entryOffset = DEPOSITS_OFFSET + i * DEPOSIT_ENTRY_SIZE;
+    if (entryOffset + 32 > data.length) break;
+
+    const reserveKey = new PublicKey(data.slice(entryOffset, entryOffset + 32));
+    if (reserveKey.equals(PublicKey.default)) continue;
+
+    const amtOffset = entryOffset + DEPOSITED_AMOUNT_OFFSET;
+    if (amtOffset + 8 > data.length) continue;
+    const depositedAmount = new BN(data.slice(amtOffset, amtOffset + 8), "le");
+    totalCTokens = totalCTokens.add(depositedAmount);
+  }
+
+  return totalCTokens.toNumber();
+}
+
+// Reserve layout offsets (traced from klend-sdk borsh struct definitions).
+// 8 disc + 8 version + 16 lastUpdate + 32 lendingMarket + 32 farmCollateral + 32 farmDebt = 128
+// ReserveLiquidity at 128: 32 mint + 32 supplyVault + 32 feeVault = 96 bytes before availableAmount
+const RESERVE_AVAILABLE_AMOUNT_OFFSET = 224;      // u64 LE  (128 + 96)
+const RESERVE_BORROWED_AMOUNT_SF_OFFSET = 232;    // u128 LE (128 + 96 + 8)
+// ReserveCollateral starts at 2560 (128 + 1232 liquidity + 1200 liquidityPadding)
+// mintPubkey: 32 bytes, then mintTotalSupply
+const RESERVE_CTOKENS_TOTAL_SUPPLY_OFFSET = 2592; // u64 LE  (2560 + 32)
+
+/**
+ * Convert cToken amount to underlying token amount using reserve exchange rate.
+ * underlying = cTokens * (available + borrowed_sf / 2^60) / cTokenSupply
+ */
+export function cTokensToUnderlying(cTokens: number, reserveData: Buffer): number {
+  const availableAmount = new BN(
+    reserveData.slice(RESERVE_AVAILABLE_AMOUNT_OFFSET, RESERVE_AVAILABLE_AMOUNT_OFFSET + 8),
+    "le"
+  );
+  const borrowedAmountSf = new BN(
+    reserveData.slice(RESERVE_BORROWED_AMOUNT_SF_OFFSET, RESERVE_BORROWED_AMOUNT_SF_OFFSET + 16),
+    "le"
+  );
+  const cTokenSupply = new BN(
+    reserveData.slice(RESERVE_CTOKENS_TOTAL_SUPPLY_OFFSET, RESERVE_CTOKENS_TOTAL_SUPPLY_OFFSET + 8),
+    "le"
+  );
+
+  if (cTokenSupply.isZero()) return 0;
+
+  // totalLiquidity_sf = available * 2^60 + borrowed_sf
+  const totalLiquiditySf = availableAmount.mul(FRACTION_SCALE).add(borrowedAmountSf);
+  // underlying_sf = cTokens * totalLiquidity_sf / cTokenSupply
+  const cTokensBN = new BN(cTokens);
+  const underlyingSf = cTokensBN.mul(totalLiquiditySf).div(cTokenSupply);
+  // underlying = underlying_sf / 2^60
+  const underlying = underlyingSf.div(FRACTION_SCALE);
+
+  return underlying.toNumber();
+}
+
+/**
+ * Convert underlying token amount to cToken amount using reserve exchange rate.
+ * cTokens = underlying * cTokenSupply / totalLiquidity
+ */
+export function underlyingToCTokens(underlying: number, reserveData: Buffer): number {
+  const availableAmount = new BN(
+    reserveData.slice(RESERVE_AVAILABLE_AMOUNT_OFFSET, RESERVE_AVAILABLE_AMOUNT_OFFSET + 8),
+    "le"
+  );
+  const borrowedAmountSf = new BN(
+    reserveData.slice(RESERVE_BORROWED_AMOUNT_SF_OFFSET, RESERVE_BORROWED_AMOUNT_SF_OFFSET + 16),
+    "le"
+  );
+  const cTokenSupply = new BN(
+    reserveData.slice(RESERVE_CTOKENS_TOTAL_SUPPLY_OFFSET, RESERVE_CTOKENS_TOTAL_SUPPLY_OFFSET + 8),
+    "le"
+  );
+
+  if (cTokenSupply.isZero()) return 0;
+
+  // totalLiquidity_sf = available * 2^60 + borrowed_sf
+  const totalLiquiditySf = availableAmount.mul(FRACTION_SCALE).add(borrowedAmountSf);
+  if (totalLiquiditySf.isZero()) return 0;
+
+  // cTokens_sf = underlying * cTokenSupply * 2^60 / totalLiquidity_sf
+  const underlyingBN = new BN(underlying);
+  const cTokensSf = underlyingBN.mul(cTokenSupply).mul(FRACTION_SCALE).div(totalLiquiditySf);
+
+  return cTokensSf.toNumber();
+}

package/src/kamino/refreshInstructions.ts

@@ -0,0 +1,45 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import {
+  KAMINO_LENDING_PROGRAM_ID,
+  REFRESH_RESERVE_DISCRIMINATOR,
+  REFRESH_OBLIGATION_DISCRIMINATOR,
+} from "../constants";
+
+export function buildRefreshReserveIx(
+  reserve: PublicKey,
+  lendingMarket: PublicKey,
+  scopePrices: PublicKey
+): TransactionInstruction {
+  return new TransactionInstruction({
+    programId: KAMINO_LENDING_PROGRAM_ID,
+    keys: [
+      { pubkey: reserve, isSigner: false, isWritable: true },
+      { pubkey: lendingMarket, isSigner: false, isWritable: false },
+      { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: KAMINO_LENDING_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: scopePrices, isSigner: false, isWritable: false },
+    ],
+    data: REFRESH_RESERVE_DISCRIMINATOR,
+  });
+}
+
+export function buildRefreshObligationIx(
+  lendingMarket: PublicKey,
+  obligation: PublicKey,
+  reserves: PublicKey[] = []
+): TransactionInstruction {
+  const keys = [
+    { pubkey: lendingMarket, isSigner: false, isWritable: false },
+    { pubkey: obligation, isSigner: false, isWritable: true },
+  ];
+  // Reserves must be writable for CPI
+  for (const reserve of reserves) {
+    keys.push({ pubkey: reserve, isSigner: false, isWritable: true });
+  }
+  return new TransactionInstruction({
+    programId: KAMINO_LENDING_PROGRAM_ID,
+    keys,
+    data: REFRESH_OBLIGATION_DISCRIMINATOR,
+  });
+}