@hobba-io/core 0.1.0

package/src/executeDepositBorrow.ts

@@ -0,0 +1,677 @@
+import {
+  Connection,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+} from "@solana/web3.js";
+import {
+  createAssociatedTokenAccountInstruction,
+  getAssociatedTokenAddress,
+  createSyncNativeInstruction,
+  NATIVE_MINT,
+} from "@solana/spl-token";
+import type { Program } from "@coral-xyz/anchor";
+import BN from "bn.js";
+import {
+  CBBTC_MINT,
+  SOL_MINT,
+  USDC_MINT,
+  JUPLEND_POS_TICK_CURRENT,
+  JUPLEND_POS_TICK_FINAL,
+  JUPLEND_POS_TICK_ID_CURRENT,
+  JUPLEND_POS_TICK_ID_FINAL,
+  LENDING_PROVIDER_JUPLEND,
+  DEFAULT_LENDING_PROVIDER,
+  resolveJuplendVaultId,
+  deriveJuplendVaultConfigPda,
+  deriveJuplendVaultStatePda,
+} from "./constants";
+import {
+  deriveUserStatePda,
+  deriveAllowlistEntryPda,
+  deriveUserTokenAccounts,
+  deriveObligationPda,
+  deriveUserMetadataPda,
+  deriveFarmPdas,
+  deriveJuplendPositionPda,
+  deriveJuplendPositionMintPda,
+  derivePositionMetadataPda,
+} from "./pdas";
+import {
+  getInitializeUserAccounts,
+  getKaminoInitializeUserLenderAccounts,
+  getDepositAccounts,
+  getKaminoDepositLenderAccounts,
+  getBorrowAccounts,
+  getKaminoBorrowLenderAccounts,
+  fixFarmWritable,
+} from "./kamino/accountResolvers";
+import {
+  buildRefreshReserveIx,
+  buildRefreshObligationIx,
+} from "./kamino/refreshInstructions";
+import { resolveMainMarketConfigByMint } from "./marketConfig";
+import { resolveKaminoMarketConfig } from "./position";
+import { parseUserStateData } from "./userState";
+import { fetchMarketLut } from "./txHelpers";
+import {
+  getCreateJuplendPositionAccounts,
+  getInitializeUserJuplendAccounts,
+  getJuplendInitializeUserLenderAccounts,
+} from "./juplend/positionInit";
+import {
+  getJuplendDepositAccounts,
+  getJuplendDepositLenderAccounts,
+  getJuplendBorrowAccounts,
+  getJuplendBorrowLenderAccounts,
+  getJuplendDepositBorrowAccounts,
+  getJuplendDepositBorrowLenderAccounts,
+} from "./juplend/accountResolvers";
+import { buildFallbackOperateRemaining } from "./juplend/operateRemaining";
+import {
+  fetchOperateContext,
+  deserializeRemaining,
+  deserializeOtherIxs,
+  type SdkOperateResponse,
+} from "./juplend/sdkApi";
+import { sendLegacyTx, sendVersionedTx } from "./transactionBuilder";
+import { buildHobbaProgram } from "./program";
+import { collateralLabel } from "./amountUtils";
+import type { HobbaSigner } from "./wallet";
+
+export interface ExecuteDepositBorrowParams {
+  /** RPC connection used for reads, simulation, and submission. */
+  connection: Connection;
+  /** Wallet able to sign legacy + versioned transactions (publicKey required). */
+  signer: HobbaSigner;
+  /** Collateral mint — cbBTC or SOL. */
+  collateralMint: PublicKey;
+  /** Deposit amount in collateral base units (cbBTC: 1e8, SOL: 1e9). */
+  depositAmount: BN;
+  /** Borrow amount in USDC base units (1e6). */
+  borrowAmount: BN;
+  /**
+   * Base URL for the Hobba backend that serves `/api/juplend-operate` and
+   * `/api/lut`. Defaults to "" (same-origin relative), which is what the app uses.
+   * The widget passes the partner-configured `apiBaseUrl`.
+   */
+  apiBaseUrl?: string;
+  /** Progress callback for UI status text. */
+  onStep?: (step: string) => void;
+  /** Optional pre-built Anchor program; built from the IDL + connection if omitted. */
+  program?: Program;
+  /**
+   * Origin the user signs up through (0 = hobba). Recorded immutably on the
+   * user's on-chain state at initialization; the origin's OriginConfig PDA
+   * must already be registered by the deployer. Only used for new users.
+   */
+  origin?: number;
+}
+
+export interface ExecuteDepositBorrowResult {
+  depositSig: string;
+  borrowSig: string;
+  /** Lender the flow ran against (Kamino runs as a single combined tx). */
+  lender: "juplend" | "kamino";
+}
+
+// Build wSOL wrapping instructions if needed (collateral === SOL).
+async function buildWrapSolIxs(
+  owner: PublicKey,
+  wsolAta: PublicKey,
+  lamports: BN,
+  safeGetAccountInfo: (addr: PublicKey) => Promise<any>,
+): Promise<TransactionInstruction[]> {
+  const ixs: TransactionInstruction[] = [];
+  const ataInfo = await safeGetAccountInfo(wsolAta);
+  if (!ataInfo) {
+    ixs.push(createAssociatedTokenAccountInstruction(owner, wsolAta, owner, NATIVE_MINT));
+  }
+  // Transfer SOL to wSOL ATA then sync
+  ixs.push(
+    SystemProgram.transfer({
+      fromPubkey: owner,
+      toPubkey: wsolAta,
+      lamports: BigInt(lamports.toString()),
+    }),
+    createSyncNativeInstruction(wsolAta),
+  );
+  return ixs;
+}
+
+/**
+ * Run the full JupLend deposit + borrow flow (the default Hobba lending provider).
+ *
+ * Lifted verbatim from the app's `DepositBorrowForm.handleJuplendFlow` so the app
+ * and the embeddable widget share one implementation. Sequence:
+ *   TX1 (new users only): create JupLend position + initialize user + ATAs (legacy)
+ *   TX2: deposit collateral (versioned, LUT, tick-rebuild recovery)
+ *   TX3: borrow USDC      (versioned, LUT, tick-rebuild recovery)
+ */
+export async function executeDepositBorrow(
+  params: ExecuteDepositBorrowParams,
+): Promise<ExecuteDepositBorrowResult> {
+  const {
+    connection,
+    signer,
+    collateralMint: selectedMint,
+    depositAmount,
+    borrowAmount,
+    apiBaseUrl = "",
+    onStep,
+    origin = 0,
+  } = params;
+
+  if (!signer.publicKey || !signer.signTransaction) {
+    throw new Error("Wallet not connected");
+  }
+  const owner = signer.publicKey;
+  const program = params.program ?? buildHobbaProgram(connection, owner);
+  const base = apiBaseUrl.replace(/\/+$/, "");
+  const setStep = (s: string) => onStep?.(s);
+  const label = collateralLabel(selectedMint);
+  const isSol = selectedMint.equals(SOL_MINT);
+
+  const safeGetAccountInfo = async (addr: PublicKey) => {
+    try {
+      return await connection.getAccountInfo(addr);
+    } catch {
+      return null;
+    }
+  };
+
+  const [userStatePda] = deriveUserStatePda(owner, selectedMint);
+  const [allowlistEntryPda] = deriveAllowlistEntryPda(owner);
+  const tokens = await deriveUserTokenAccounts(owner, userStatePda, selectedMint);
+
+  const userStateInfo = await safeGetAccountInfo(userStatePda);
+
+  // Lender routing: existing users follow their UserState's provider byte;
+  // new users (no UserState yet) get the default lender (JupLend).
+  const isJuplendLender =
+    userStateInfo && userStateInfo.data.length > 105
+      ? userStateInfo.data[105] === LENDING_PROVIDER_JUPLEND
+      : DEFAULT_LENDING_PROVIDER === LENDING_PROVIDER_JUPLEND;
+
+  if (!isJuplendLender) {
+    const sig = await executeKaminoDepositBorrow({
+      connection,
+      signer,
+      program,
+      selectedMint,
+      depositAmount,
+      borrowAmount,
+      base,
+      setStep,
+      owner,
+      userStatePda,
+      allowlistEntryPda,
+      tokens,
+      userStateInfo,
+      safeGetAccountInfo,
+      isSol,
+      origin,
+    });
+    return { depositSig: sig, borrowSig: sig, lender: "kamino" };
+  }
+
+  // Resolve vault ID, config, and state for selected collateral
+  const juplendVaultId = resolveJuplendVaultId(selectedMint);
+  const juplendVaultConfig = deriveJuplendVaultConfigPda(juplendVaultId);
+  const juplendVaultState = deriveJuplendVaultStatePda(juplendVaultId);
+
+  if (!userStateInfo) {
+    // TX1: Create JupLend position + Initialize user + ATAs
+    setStep("Initializing position...");
+
+    // Read next_position_id from vault state (offset 115, u32 LE)
+    const vaultStateInfo = await connection.getAccountInfo(juplendVaultState);
+    if (!vaultStateInfo) throw new Error("JupLend vault state not found");
+    const nextPositionId = vaultStateInfo.data.readUInt32LE(115);
+
+    const [positionPda] = deriveJuplendPositionPda(juplendVaultId, nextPositionId);
+    const [positionMintPda] = deriveJuplendPositionMintPda(juplendVaultId, nextPositionId);
+    const positionTokenAccount = await getAssociatedTokenAddress(positionMintPda, userStatePda, true);
+    const [positionMetadata] = derivePositionMetadataPda(positionMintPda);
+
+    // ATA creation
+    const ataIxs: TransactionInstruction[] = [];
+    const [pdaCollateralAtaInfo, pdaUsdcAtaInfo, userUsdcAtaInfo] = await Promise.all([
+      safeGetAccountInfo(tokens.pdaCollateralAta),
+      safeGetAccountInfo(tokens.pdaUsdcAta),
+      safeGetAccountInfo(tokens.userUsdcAta),
+    ]);
+    if (!pdaCollateralAtaInfo) {
+      ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaCollateralAta, userStatePda, selectedMint));
+    }
+    if (!pdaUsdcAtaInfo) {
+      ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaUsdcAta, userStatePda, USDC_MINT));
+    }
+    if (!userUsdcAtaInfo) {
+      ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.userUsdcAta, owner, USDC_MINT));
+    }
+
+    const createPositionIx = await program.methods
+      .createJuplendPosition(juplendVaultId, nextPositionId)
+      .accounts(getCreateJuplendPositionAccounts(
+        owner, userStatePda, positionPda, positionMintPda, positionTokenAccount, positionMetadata, allowlistEntryPda, selectedMint, juplendVaultState,
+      ))
+      .instruction();
+
+    const juplendInitLender = getJuplendInitializeUserLenderAccounts(positionPda, juplendVaultConfig);
+    const initIx = await program.methods
+      .initializeUser(1, origin)
+      .accounts(getInitializeUserJuplendAccounts(
+        owner, userStatePda, allowlistEntryPda, selectedMint, origin,
+      ))
+      .remainingAccounts(juplendInitLender)
+      .instruction();
+
+    await sendLegacyTx(connection, [...ataIxs, createPositionIx, initIx], signer, 400_000);
+  }
+
+  // Read position address from userState (obligation field stores position for JupLend)
+  const updatedUserState = await connection.getAccountInfo(userStatePda);
+  if (!updatedUserState) throw new Error("User state not found after init");
+  const positionAddress = new PublicKey(updatedUserState.data.slice(41, 73));
+
+  // Read position for tick + derive position token account
+  const positionInfo = await connection.getAccountInfo(positionAddress);
+  if (!positionInfo) throw new Error("Position account not found");
+
+  const vaultId = positionInfo.data.readUInt16LE(8);
+  const positionId = positionInfo.data.readUInt32LE(10);
+  const [positionMintPda] = deriveJuplendPositionMintPda(vaultId, positionId);
+  const positionTokenAccount = await getAssociatedTokenAddress(positionMintPda, userStatePda, true);
+
+  const juplendPdas = {
+    userStatePda,
+    allowlistEntryPda,
+    obligationPda: positionAddress,
+    userMetadataPda: userStatePda,
+    userCollateralAta: tokens.userCollateralAta,
+    userUsdcAta: tokens.userUsdcAta,
+    pdaCollateralAta: tokens.pdaCollateralAta,
+    pdaUsdcAta: tokens.pdaUsdcAta,
+  };
+
+  // Fetch JupLend LUT
+  const lutResp = await fetch(`${base}/api/lut?market=juplend`);
+  const lutData = await lutResp.json();
+  if (!lutData.address) throw new Error("JupLend LUT not found. Run stream-vault-oracles.ts first.");
+  const juplendLut = new PublicKey(lutData.address);
+
+  const wantsDeposit = depositAmount.gtn(0);
+  const wantsBorrow = borrowAmount.gtn(0);
+  if (!wantsDeposit && !wantsBorrow) {
+    throw new Error("Nothing to execute: deposit and borrow amounts are both zero");
+  }
+
+  // wSOL wrapping for deposit
+  // Wrap amount + 1 because juplend_deposit transfers amount + 1 (JupLend rounding)
+  let wrapIxs: TransactionInstruction[] = [];
+  if (isSol && wantsDeposit) {
+    wrapIxs = await buildWrapSolIxs(owner, tokens.userCollateralAta, depositAmount.addn(1), safeGetAccountInfo);
+  }
+
+  // ---- Combined path: both sides in ONE versioned tx via juplend_deposit_borrow ----
+  // Single operate CPI: ~150 bytes smaller and one wallet popup instead of two.
+  // If the operate-context API is unavailable we fall back to the split TX2+TX3 flow
+  // below — the hardcoded cbBTC fallback list is only valid for the deposit-only
+  // shape (its final tick ignores debt), so the combined ix never runs on fallback
+  // accounts.
+  if (wantsDeposit && wantsBorrow) {
+    setStep(`Depositing ${label} & borrowing USDC...`);
+
+    // Static prefix: wrap + ATA creates. Independent of the SDK context, computed
+    // once and reused by the tick-error rebuild. TX1 already created these ATAs for
+    // brand-new users; the existence checks self-heal older positions.
+    const staticPrefix: TransactionInstruction[] = [...wrapIxs];
+    const [pdaColInfo, pdaUsdcInfo, userUsdcInfo] = await Promise.all([
+      safeGetAccountInfo(tokens.pdaCollateralAta),
+      safeGetAccountInfo(tokens.pdaUsdcAta),
+      safeGetAccountInfo(tokens.userUsdcAta),
+    ]);
+    if (!pdaColInfo) {
+      staticPrefix.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaCollateralAta, userStatePda, selectedMint));
+    }
+    if (!pdaUsdcInfo) {
+      staticPrefix.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaUsdcAta, userStatePda, USDC_MINT));
+    }
+    if (!userUsdcInfo) {
+      staticPrefix.push(createAssociatedTokenAccountInstruction(owner, tokens.userUsdcAta, owner, USDC_MINT));
+    }
+
+    const fetchCombinedCtx = () => fetchOperateContext({
+      vaultId, positionId,
+      colAmount: depositAmount.toString(),
+      debtAmount: borrowAmount.toString(),
+      signerPda: userStatePda.toBase58(),
+    }, base);
+
+    // SDK-dependent suffix, rebuilt from a fresh operate context on tick errors.
+    const buildCombinedSuffix = async (ctx: SdkOperateResponse): Promise<TransactionInstruction[]> => {
+      const otherIxs = deserializeOtherIxs(ctx, userStatePda, owner);
+      const combRemaining = deserializeRemaining(ctx);
+      // vault_config (operate index 0) and position (index 5) are named accounts
+      // on this handler (the program splices them back into the operate list);
+      // strip them from the remaining list and pass them as named accounts.
+      const combOperateRest = combRemaining.filter((_, i) => i !== 0 && i !== 5);
+      const combinedIx = await program.methods
+        .juplendDepositBorrow(depositAmount, borrowAmount)
+        .accounts(getJuplendDepositBorrowAccounts(
+          owner, juplendPdas, selectedMint, juplendVaultConfig, positionAddress,
+        ))
+        .remainingAccounts([...getJuplendDepositBorrowLenderAccounts(), ...combOperateRest])
+        .instruction();
+      return [...otherIxs, combinedIx];
+    };
+
+    let combinedCtx: SdkOperateResponse | null = null;
+    try {
+      combinedCtx = await fetchCombinedCtx();
+    } catch (sdkErr: any) {
+      console.warn("[deposit-borrow] combined operate context unavailable, falling back to split flow:", sdkErr.message);
+    }
+
+    if (combinedCtx) {
+      const suffix = await buildCombinedSuffix(combinedCtx);
+      const sig = await sendVersionedTx(
+        connection, [...staticPrefix, ...suffix], signer, [juplendLut], 1_400_000, false,
+        async () => {
+          const fresh = await fetchCombinedCtx().catch(() => null);
+          if (!fresh) return null;
+          return [...staticPrefix, ...(await buildCombinedSuffix(fresh))];
+        },
+      );
+      return { depositSig: sig, borrowSig: sig, lender: "juplend" };
+    }
+    // Operate context unavailable — continue into the split flow.
+  }
+
+  let depositSig: string | null = null;
+  let borrowSig: string | null = null;
+
+  if (wantsDeposit) {
+    // TX2: Deposit — try SDK first, fallback to hardcoded remaining for cbBTC only
+    setStep(`Depositing ${label}...`);
+
+    let depositRemaining: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[];
+    let depositOtherIxs: TransactionInstruction[] = [];
+
+    try {
+      const sdkDepositResult = await fetchOperateContext({
+        vaultId, positionId,
+        colAmount: depositAmount.toString(),
+        debtAmount: "0",
+        signerPda: userStatePda.toBase58(),
+      }, base);
+      depositRemaining = deserializeRemaining(sdkDepositResult);
+      depositOtherIxs = deserializeOtherIxs(sdkDepositResult, userStatePda, owner);
+    } catch (sdkErr: any) {
+      console.warn("[deposit] SDK failed:", sdkErr.message);
+      if (!selectedMint.equals(CBBTC_MINT)) {
+        throw new Error(`SDK API failed for deposit on vault ${vaultId}: ${sdkErr.message}`);
+      }
+      // cbBTC fallback with hardcoded remaining
+      depositRemaining = buildFallbackOperateRemaining(
+        positionAddress, positionTokenAccount,
+        JUPLEND_POS_TICK_CURRENT, JUPLEND_POS_TICK_FINAL,
+        JUPLEND_POS_TICK_ID_CURRENT, JUPLEND_POS_TICK_ID_FINAL,
+      ).remaining;
+    }
+
+    const juplendDepositLender = getJuplendDepositLenderAccounts(juplendPdas);
+    const depositIx = await program.methods.deposit(depositAmount)
+      .accounts(getJuplendDepositAccounts(owner, juplendPdas, selectedMint))
+      .remainingAccounts([...juplendDepositLender, ...depositRemaining]).instruction();
+
+    // Pre-sign rebuilder: refetch SDK and rebuild deposit ix on VaultInvalidTick
+    const rebuildDepositOnTickError = async (): Promise<TransactionInstruction[] | null> => {
+      const fresh = await fetchOperateContext({
+        vaultId, positionId,
+        colAmount: depositAmount.toString(), debtAmount: "0",
+        signerPda: userStatePda.toBase58(),
+      }, base).catch(() => null);
+      if (!fresh) return null;
+      const freshRemaining = deserializeRemaining(fresh);
+      const freshOtherIxs = deserializeOtherIxs(fresh, userStatePda, owner);
+      const freshIx = await program.methods.deposit(depositAmount)
+        .accounts(getJuplendDepositAccounts(owner, juplendPdas, selectedMint))
+        .remainingAccounts([...juplendDepositLender, ...freshRemaining]).instruction();
+      return [...wrapIxs, ...freshOtherIxs, freshIx];
+    };
+
+    depositSig = await sendVersionedTx(
+      connection, [...wrapIxs, ...depositOtherIxs, depositIx], signer, [juplendLut], 600_000, false, rebuildDepositOnTickError,
+    );
+  }
+
+  if (wantsBorrow) {
+    // TX3: Borrow with SDK-computed remaining (SDK computes correct final tick for debt)
+    setStep("Borrowing USDC...");
+
+    const sdkResult = await fetchOperateContext({
+      vaultId,
+      positionId,
+      colAmount: "0",
+      debtAmount: borrowAmount.toString(),
+      signerPda: userStatePda.toBase58(),
+    }, base);
+
+    const borrowRemaining = deserializeRemaining(sdkResult);
+    const otherIxs = deserializeOtherIxs(sdkResult, userStatePda, owner);
+
+    const juplendLender = getJuplendBorrowLenderAccounts(juplendPdas);
+    const borrowIx = await program.methods.borrow(borrowAmount, 0)
+      .accounts(getJuplendBorrowAccounts(owner, juplendPdas, selectedMint))
+      .remainingAccounts([...juplendLender, ...borrowRemaining]).instruction();
+
+    const rebuildBorrowOnTickError = async (): Promise<TransactionInstruction[] | null> => {
+      const fresh = await fetchOperateContext({
+        vaultId, positionId,
+        colAmount: "0", debtAmount: borrowAmount.toString(),
+        signerPda: userStatePda.toBase58(),
+      }, base).catch(() => null);
+      if (!fresh) return null;
+      const freshRemaining = deserializeRemaining(fresh);
+      const freshOtherIxs = deserializeOtherIxs(fresh, userStatePda, owner);
+      const freshIx = await program.methods.borrow(borrowAmount, 0)
+        .accounts(getJuplendBorrowAccounts(owner, juplendPdas, selectedMint))
+        .remainingAccounts([...juplendLender, ...freshRemaining]).instruction();
+      return [...freshOtherIxs, freshIx];
+    };
+
+    borrowSig = await sendVersionedTx(
+      connection, [...otherIxs, borrowIx], signer, [juplendLut], 800_000, false, rebuildBorrowOnTickError,
+    );
+  }
+
+  return {
+    depositSig: (depositSig ?? borrowSig)!,
+    borrowSig: (borrowSig ?? depositSig)!,
+    lender: "juplend",
+  };
+}
+
+// --- Kamino deposit & borrow (lifted from app page.tsx handleDepositBorrow) ---
+// Single versioned tx: [ATA creates] → [initializeUser] → [wrap SOL] →
+// refresh_reserve(col) → refresh_reserve(usdc)? → refresh_obligation? →
+// deposit → refresh_reserve(col) → refresh_obligation → borrow.
+async function executeKaminoDepositBorrow(args: {
+  connection: Connection;
+  signer: HobbaSigner;
+  program: Program;
+  selectedMint: PublicKey;
+  depositAmount: BN;
+  borrowAmount: BN;
+  base: string;
+  setStep: (s: string) => void;
+  owner: PublicKey;
+  userStatePda: PublicKey;
+  allowlistEntryPda: PublicKey;
+  tokens: Awaited<ReturnType<typeof deriveUserTokenAccounts>>;
+  userStateInfo: Awaited<ReturnType<Connection["getAccountInfo"]>>;
+  safeGetAccountInfo: (addr: PublicKey) => Promise<any>;
+  isSol: boolean;
+  origin: number;
+}): Promise<string> {
+  const {
+    connection,
+    signer,
+    program,
+    selectedMint,
+    depositAmount,
+    borrowAmount,
+    base,
+    setStep,
+    owner,
+    userStatePda,
+    allowlistEntryPda,
+    tokens,
+    userStateInfo,
+    safeGetAccountInfo,
+    isSol,
+    origin,
+  } = args;
+
+  setStep("Processing deposit & borrow...");
+
+  const effectiveUserState = userStateInfo
+    ? parseUserStateData(userStateInfo.data as Buffer)
+    : null;
+  const mc = effectiveUserState
+    ? resolveKaminoMarketConfig(effectiveUserState.lendingMarket, selectedMint)
+    : resolveMainMarketConfigByMint(selectedMint);
+
+  const obligPda =
+    effectiveUserState?.obligation ?? deriveObligationPda(userStatePda, mc.market)[0];
+  const [userMetadataPda] = deriveUserMetadataPda(userStatePda);
+  const { obligationFarmUserStatePda, obligationFarmDebtUserStatePda } = deriveFarmPdas(
+    obligPda,
+    mc.collateralFarmState,
+    mc.usdcReserveFarmDebt,
+  );
+  const pdas = {
+    userStatePda,
+    allowlistEntryPda,
+    obligationPda: obligPda,
+    userMetadataPda,
+    obligationFarmUserStatePda,
+    obligationFarmDebtUserStatePda,
+    ...tokens,
+  };
+
+  const needsInit = !userStateInfo;
+
+  const obligInfo = await connection.getAccountInfo(obligPda);
+  const obligationExists = obligInfo !== null && obligInfo.data.length > 0;
+  const refreshReserves: PublicKey[] = [];
+  if (obligInfo && obligInfo.data.length > 1208) {
+    const depositReserveKey = new PublicKey(obligInfo.data.slice(96, 128));
+    if (!depositReserveKey.equals(PublicKey.default)) refreshReserves.push(mc.collateralReserve);
+    const borrowReserveKey = new PublicKey(obligInfo.data.slice(1208, 1240));
+    if (!borrowReserveKey.equals(PublicKey.default)) refreshReserves.push(mc.usdcReserve);
+  }
+
+  const allIxs: TransactionInstruction[] = [];
+
+  const [pdaColInfo, pdaUsdcInfo, userUsdcInfo] = await Promise.all([
+    safeGetAccountInfo(tokens.pdaCollateralAta),
+    safeGetAccountInfo(tokens.pdaUsdcAta),
+    safeGetAccountInfo(tokens.userUsdcAta),
+  ]);
+  if (!pdaColInfo)
+    allIxs.push(
+      createAssociatedTokenAccountInstruction(owner, tokens.pdaCollateralAta, userStatePda, selectedMint),
+    );
+  if (!pdaUsdcInfo)
+    allIxs.push(
+      createAssociatedTokenAccountInstruction(owner, tokens.pdaUsdcAta, userStatePda, USDC_MINT),
+    );
+  if (!userUsdcInfo)
+    allIxs.push(
+      createAssociatedTokenAccountInstruction(owner, tokens.userUsdcAta, owner, USDC_MINT),
+    );
+
+  if (needsInit) {
+    const initIx = await program.methods
+      .initializeUser(0, origin)
+      .accounts(getInitializeUserAccounts(owner, pdas, mc, origin))
+      .remainingAccounts(getKaminoInitializeUserLenderAccounts(pdas, mc))
+      .instruction();
+    allIxs.push(initIx);
+  }
+
+  const wantsDeposit = depositAmount.gtn(0);
+  const wantsBorrow = borrowAmount.gtn(0);
+
+  if (isSol && wantsDeposit) {
+    const wrapIxs = await buildWrapSolIxs(owner, tokens.userCollateralAta, depositAmount, safeGetAccountInfo);
+    allIxs.push(...wrapIxs);
+  }
+
+  // Combined deposit+borrow layout (fits the 1232-byte versioned-tx cap):
+  //   refresh_reserve(col)
+  //   refresh_reserve(usdc)      — only when borrowing (or existing USDC debt)
+  //   refresh_obligation         — only if obligation already existed with entries
+  //   deposit                    — if any
+  //   refresh_reserve(col) + refresh_obligation — only if also borrowing
+  //   borrow                     — if any
+  if (wantsDeposit || wantsBorrow) {
+    allIxs.push(buildRefreshReserveIx(mc.collateralReserve, mc.market, mc.scopePrices));
+    // refresh_obligation reads every reserve listed in the obligation and rejects
+    // stale ones, so a deposit-only tx on an obligation with prior debt must
+    // still refresh USDC.
+    const obligationHasUsdcBorrow = refreshReserves.includes(mc.usdcReserve);
+    if (wantsBorrow || obligationHasUsdcBorrow) {
+      allIxs.push(buildRefreshReserveIx(mc.usdcReserve, mc.market, mc.scopePrices));
+    }
+    if (!needsInit && obligationExists && refreshReserves.length > 0) {
+      allIxs.push(buildRefreshObligationIx(mc.market, obligPda, refreshReserves));
+    }
+  }
+
+  if (wantsDeposit) {
+    const depIx = await program.methods
+      .deposit(depositAmount)
+      .accounts(getDepositAccounts(owner, pdas, mc))
+      .remainingAccounts(getKaminoDepositLenderAccounts(pdas, mc))
+      .instruction();
+    if (mc.collateralFarmState)
+      fixFarmWritable(depIx.keys, obligationFarmUserStatePda, mc.collateralFarmState);
+    allIxs.push(depIx);
+  }
+
+  if (wantsBorrow) {
+    // Deposit marks the collateral reserve stale (even within the same slot),
+    // so it must be re-refreshed before refresh_obligation accepts it.
+    if (wantsDeposit) {
+      allIxs.push(buildRefreshReserveIx(mc.collateralReserve, mc.market, mc.scopePrices));
+    }
+    // Refresh obligation AFTER deposit (so borrow's health check sees the new
+    // collateral). Include USDC reserve only if the obligation already had a borrow.
+    const preBorrowReserves = refreshReserves.includes(mc.usdcReserve)
+      ? refreshReserves
+      : [mc.collateralReserve];
+    allIxs.push(buildRefreshObligationIx(mc.market, obligPda, preBorrowReserves));
+
+    const borIx = await program.methods
+      .borrow(borrowAmount, 0)
+      .accounts(getBorrowAccounts(owner, pdas, mc, false))
+      .remainingAccounts(getKaminoBorrowLenderAccounts(pdas, mc, false))
+      .instruction();
+    if (mc.usdcReserveFarmDebt)
+      fixFarmWritable(borIx.keys, obligationFarmDebtUserStatePda, mc.usdcReserveFarmDebt);
+    allIxs.push(borIx);
+  }
+
+  const marketLut = await fetchMarketLut(base, "main");
+  return await sendVersionedTx(
+    connection,
+    allIxs,
+    signer,
+    marketLut ? [marketLut] : [],
+    1_400_000,
+  );
+}