@hobba-io/core 0.1.0

package/dist/executeAction.js

@@ -0,0 +1,606 @@
+import { PublicKey } from "@solana/web3.js";
+import { createAssociatedTokenAccountInstruction, createCloseAccountInstruction, getAssociatedTokenAddress, NATIVE_MINT, TOKEN_PROGRAM_ID, } from "@solana/spl-token";
+import BN from "bn.js";
+import { CBBTC_MINT, SOL_MINT, USDC_MINT, JUPLEND_ORACLE, JUPLEND_PROGRAM, LENDING_PROVIDER_JUPLEND, } from "./constants";
+import { deriveUserStatePda, deriveAllowlistEntryPda, deriveObligationPda, deriveFarmPdas, deriveUserTokenAccounts, deriveJuplendPositionMintPda, deriveJuplendTickPda, deriveJuplendTickIdLiquidationPda, } from "./pdas";
+import { getDepositAccounts, getKaminoDepositLenderAccounts, getBorrowAccounts, getKaminoBorrowLenderAccounts, getRepayAccounts, getKaminoRepayLenderAccounts, getWithdrawAccounts, getKaminoWithdrawLenderAccounts, getPrepareWithdrawAccounts, getKaminoPrepareWithdrawLenderAccounts, } from "./kamino/accountResolvers";
+import { buildRefreshReserveIx, buildRefreshObligationIx, } from "./kamino/refreshInstructions";
+import { underlyingToCTokens } from "./kamino/obligationParser";
+import { getJuplendDepositAccounts, getJuplendDepositLenderAccounts, getJuplendBorrowAccounts, getJuplendBorrowLenderAccounts, getJuplendRepayAccounts, getJuplendRepayLenderAccounts, getJuplendPrepareWithdrawAccounts, getJuplendWithdrawAccounts, getJuplendWithdrawLenderAccounts, } from "./juplend/accountResolvers";
+import { buildFallbackOperateRemaining } from "./juplend/operateRemaining";
+import { isTickError, parseTickMismatch, resolveTickAccounts, buildInitTickIx, } from "./juplend/tickUtils";
+import { fetchOperateContext, deserializeRemaining, deserializeOtherIxs, } from "./juplend/sdkApi";
+import { MAIN_MARKET_CONFIG } from "./marketConfig";
+import { getVaultInfo, resolveWithdrawFixed, getKvaultWithdrawRemaining, getPerenaWithdrawAccountsWithMarginfi, } from "./vault/vaultAccounts";
+import { sendLegacyTx, sendVersionedTx } from "./transactionBuilder";
+import { buildHobbaProgram } from "./program";
+import { resolveKaminoMarketConfig } from "./position";
+import { fetchUserState } from "./userState";
+import { buildWrapSolIxs, fetchMarketLut, getSharesAtaForVault, makeSafeGetAccountInfo, resolveVaultLuts, } from "./txHelpers";
+/**
+ * Manage an existing Hobba position: deposit / borrow / repay / withdraw.
+ *
+ * Lender routing happens inside: the (owner, collateral) UserState decides
+ * whether the JupLend or Kamino flow runs — integrators never pick a lender.
+ * Both flows are lifted verbatim from the app's page.tsx handleJuplendAction /
+ * handleKaminoAction so app and headless integrators share one implementation.
+ */
+export async function executeAction(params) {
+    const { connection, signer, collateralMint, action, amount } = params;
+    if (!signer.publicKey || !signer.signTransaction) {
+        throw new Error("Wallet not connected");
+    }
+    const owner = signer.publicKey;
+    const base = (params.apiBaseUrl ?? "").replace(/\/+$/, "");
+    const setStep = (s) => params.onStep?.(s);
+    const program = params.program ?? buildHobbaProgram(connection, owner);
+    const userState = await fetchUserState(connection, owner, collateralMint);
+    if (!userState) {
+        throw new Error("No Hobba position for this collateral — use executeDepositBorrow first");
+    }
+    const [usPda] = deriveUserStatePda(owner, collateralMint);
+    const [allowlistPda] = deriveAllowlistEntryPda(owner);
+    const tokens = await deriveUserTokenAccounts(owner, usPda, collateralMint);
+    const safeGetAccountInfo = makeSafeGetAccountInfo(connection);
+    setStep(`Processing ${action}...`);
+    if (userState.lendingProvider === LENDING_PROVIDER_JUPLEND) {
+        const signature = await juplendAction({ connection, signer, program, collateralMint, action, amount, base, userState }, owner, usPda, allowlistPda, tokens, safeGetAccountInfo);
+        return { lender: "juplend", signature };
+    }
+    const mc = resolveKaminoMarketConfig(userState.lendingMarket, collateralMint);
+    const signature = await kaminoAction({ connection, signer, program, collateralMint, action, amount, base, userState }, owner, usPda, allowlistPda, tokens, mc, safeGetAccountInfo);
+    return { lender: "kamino", signature };
+}
+// --- JupLend action flow (lifted from app page.tsx handleJuplendAction) ---
+async function juplendAction(ctx, owner, usPda, allowlistPda, tokens, safeGetAccountInfo) {
+    const { connection, signer, program, collateralMint, action, amount, base, userState } = ctx;
+    const isSol = collateralMint.equals(SOL_MINT);
+    const positionAddress = userState.obligation;
+    const positionInfo = await connection.getAccountInfo(positionAddress);
+    if (!positionInfo)
+        throw new Error("JupLend position not found");
+    const vaultId = positionInfo.data.readUInt16LE(8);
+    const positionId = positionInfo.data.readUInt32LE(10);
+    const [positionMintPda] = deriveJuplendPositionMintPda(vaultId, positionId);
+    const positionTokenAccount = await getAssociatedTokenAddress(positionMintPda, usPda, true);
+    const juplendPdas = {
+        userStatePda: usPda,
+        allowlistEntryPda: allowlistPda,
+        obligationPda: positionAddress,
+        userMetadataPda: usPda,
+        userCollateralAta: tokens.userCollateralAta,
+        userUsdcAta: tokens.userUsdcAta,
+        pdaCollateralAta: tokens.pdaCollateralAta,
+        pdaUsdcAta: tokens.pdaUsdcAta,
+    };
+    const juplendLut = await fetchMarketLut(base, "juplend");
+    if (!juplendLut)
+        throw new Error("JupLend LUT not found.");
+    const ataIxs = [];
+    if (action === "deposit") {
+        const pdaColInfo = await safeGetAccountInfo(tokens.pdaCollateralAta);
+        if (!pdaColInfo)
+            ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaCollateralAta, usPda, collateralMint));
+    }
+    else if (action === "borrow") {
+        const pdaUsdcInfo = await safeGetAccountInfo(tokens.pdaUsdcAta);
+        if (!pdaUsdcInfo)
+            ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaUsdcAta, usPda, USDC_MINT));
+        const userUsdcInfo = await safeGetAccountInfo(tokens.userUsdcAta);
+        if (!userUsdcInfo)
+            ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.userUsdcAta, owner, USDC_MINT));
+        const vaultType = userState.currentVaultType;
+        if (vaultType !== "none") {
+            const sharesAta = getSharesAtaForVault(vaultType, tokens);
+            let hasVaultShares = false;
+            try {
+                const sharesBal = await connection.getTokenAccountBalance(sharesAta);
+                hasVaultShares = BigInt(sharesBal.value.amount) > BigInt(0);
+            }
+            catch {
+                /* no shares */
+            }
+            if (hasVaultShares) {
+                const vi = getVaultInfo(vaultType);
+                let vaultRemaining;
+                if (vi.provider === "perena") {
+                    vaultRemaining = getPerenaWithdrawAccountsWithMarginfi(usPda, tokens.pdaUsdcAta, sharesAta);
+                }
+                else {
+                    const withdrawFixed = await resolveWithdrawFixed(connection, vi.vault);
+                    vaultRemaining = getKvaultWithdrawRemaining(vi, withdrawFixed);
+                }
+                const juplendLender = getJuplendBorrowLenderAccounts(juplendPdas);
+                const borrowIx = await program.methods
+                    .borrow(amount, vaultRemaining.length)
+                    .accounts(getJuplendBorrowAccounts(owner, juplendPdas, collateralMint, true, {
+                    vault: vi.vault,
+                    sharesMint: vi.sharesMint,
+                    sharesAta,
+                }))
+                    .remainingAccounts([...vaultRemaining, ...juplendLender])
+                    .instruction();
+                const vaultLuts = await resolveVaultLuts(base, vi);
+                return await sendVersionedTx(connection, [...ataIxs, borrowIx], signer, vaultLuts, 1400000);
+            }
+        }
+    }
+    let wrapIxs = [];
+    if (isSol && action === "deposit") {
+        wrapIxs = await buildWrapSolIxs(owner, tokens.userCollateralAta, amount.addn(1), safeGetAccountInfo);
+    }
+    const withdrawAtaIxs = [];
+    const unwrapIxs = [];
+    if (isSol && action === "withdraw") {
+        const ataInfo = await safeGetAccountInfo(tokens.userCollateralAta);
+        if (!ataInfo)
+            withdrawAtaIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.userCollateralAta, owner, NATIVE_MINT));
+        unwrapIxs.push(createCloseAccountInstruction(tokens.userCollateralAta, owner, owner, [], TOKEN_PROGRAM_ID));
+    }
+    const colAmount = action === "deposit" ? amount.toString() : action === "withdraw" ? "-" + amount.toString() : "0";
+    const debtAmount = action === "borrow" ? amount.toString() : action === "repay" ? "-" + amount.toString() : "0";
+    let sdkResult = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            sdkResult = await fetchOperateContext({ vaultId, positionId, colAmount, debtAmount, signerPda: usPda.toBase58() }, base);
+            break;
+        }
+        catch (apiErr) {
+            console.warn("[action] SDK API failed (attempt", attempt + 1, "):", apiErr.message);
+            if (attempt === 0)
+                await new Promise((r) => setTimeout(r, 500));
+        }
+    }
+    if (!sdkResult && !collateralMint.equals(CBBTC_MINT)) {
+        throw new Error(`SDK API failed for ${action} on vault ${vaultId}. SOL vault requires SDK for remaining accounts.`);
+    }
+    const buildIx = async (rem) => {
+        if (action === "deposit") {
+            const juplendDepositLender = getJuplendDepositLenderAccounts(juplendPdas);
+            return program.methods
+                .deposit(amount)
+                .accounts(getJuplendDepositAccounts(owner, juplendPdas, collateralMint))
+                .remainingAccounts([...juplendDepositLender, ...rem])
+                .instruction();
+        }
+        else if (action === "borrow") {
+            const juplendLender = getJuplendBorrowLenderAccounts(juplendPdas);
+            return program.methods
+                .borrow(amount, 0)
+                .accounts(getJuplendBorrowAccounts(owner, juplendPdas, collateralMint))
+                .remainingAccounts([...juplendLender, ...rem])
+                .instruction();
+        }
+        else if (action === "repay") {
+            const juplendRepayLender = getJuplendRepayLenderAccounts(juplendPdas);
+            return program.methods
+                .repay(amount)
+                .accounts(getJuplendRepayAccounts(owner, juplendPdas, collateralMint))
+                .remainingAccounts([...juplendRepayLender, ...rem])
+                .instruction();
+        }
+        else {
+            const juplendWithdrawLender = getJuplendWithdrawLenderAccounts(juplendPdas);
+            return program.methods
+                .withdraw(amount)
+                .accounts(getJuplendWithdrawAccounts(owner, juplendPdas, collateralMint))
+                .remainingAccounts([...juplendWithdrawLender, ...rem])
+                .instruction();
+        }
+    };
+    // Check vault shares for prepareWithdraw (withdraw only)
+    let withdrawHasVaultShares = false;
+    let withdrawVaultInfo = null;
+    if (action === "withdraw") {
+        const vaultType = userState.currentVaultType;
+        if (vaultType !== "none") {
+            const sharesAta = getSharesAtaForVault(vaultType, tokens);
+            try {
+                const sharesBal = await connection.getTokenAccountBalance(sharesAta);
+                withdrawHasVaultShares = BigInt(sharesBal.value.amount) > BigInt(0);
+            }
+            catch {
+                // ATA doesn't exist = no shares
+            }
+            if (withdrawHasVaultShares) {
+                const vi = getVaultInfo(vaultType);
+                const vaAccounts = { vault: vi.vault, sharesMint: vi.sharesMint, sharesAta };
+                let vaultRemaining;
+                if (vi.provider === "perena") {
+                    vaultRemaining = getPerenaWithdrawAccountsWithMarginfi(usPda, tokens.pdaUsdcAta, sharesAta);
+                }
+                else {
+                    const withdrawFixed = await resolveWithdrawFixed(connection, vi.vault);
+                    vaultRemaining = getKvaultWithdrawRemaining(vi, withdrawFixed);
+                }
+                withdrawVaultInfo = { vi, vaAccounts, vaultRemaining };
+            }
+        }
+    }
+    // prepareWithdraw for JupLend withdraw with vault shares. Lender remaining (6):
+    // [position, vault_state(mut), vault_config, supply_token_reserves_liquidity,
+    // borrow_token_reserves_liquidity, juplend_program] — pulled from the same
+    // operate account list the withdraw CPI uses (indices 0, 1, 12, 13).
+    const buildPrepareWithdrawIx = async (withdrawAmt, operateRemaining) => {
+        if (!withdrawVaultInfo)
+            throw new Error("No vault info for prepareWithdraw");
+        const { vaAccounts, vaultRemaining } = withdrawVaultInfo;
+        const juplendPrepLender = [
+            { pubkey: positionAddress, isSigner: false, isWritable: false },
+            { pubkey: operateRemaining[1].pubkey, isSigner: false, isWritable: true }, // vault_state
+            { pubkey: operateRemaining[0].pubkey, isSigner: false, isWritable: false }, // vault_config
+            { pubkey: operateRemaining[12].pubkey, isSigner: false, isWritable: false }, // supply reserves liquidity
+            { pubkey: operateRemaining[13].pubkey, isSigner: false, isWritable: false }, // borrow reserves liquidity
+            { pubkey: JUPLEND_PROGRAM, isSigner: false, isWritable: false },
+        ];
+        return program.methods
+            .prepareWithdraw(vaultRemaining.length, withdrawAmt)
+            .accounts(getJuplendPrepareWithdrawAccounts(owner, juplendPdas, collateralMint, vaAccounts))
+            .remainingAccounts([...vaultRemaining, ...juplendPrepLender])
+            .instruction();
+    };
+    if (sdkResult) {
+        const sdkRemaining = deserializeRemaining(sdkResult);
+        const otherIxs = deserializeOtherIxs(sdkResult, usPda, owner);
+        if (withdrawHasVaultShares && withdrawVaultInfo) {
+            // Single TX: prepareWithdraw (vault unwind) + withdraw (combined repay +
+            // collateral withdrawal). SDK call needs proportional debt for tick prediction.
+            const withdrawAmt = amount;
+            let proportionalDebt = new BN(0);
+            try {
+                const posResp = await fetch(`${base}/api/juplend-position?address=${positionAddress.toBase58()}`);
+                const posData = await posResp.json();
+                const totalCollateral = new BN(posData.collateral);
+                const totalDebt = new BN(posData.debt);
+                if (totalCollateral.gt(new BN(0))) {
+                    proportionalDebt = withdrawAmt.gte(totalCollateral)
+                        ? totalDebt
+                        : totalDebt.mul(withdrawAmt).div(totalCollateral);
+                }
+            }
+            catch (e) {
+                console.warn("[withdraw] Failed to fetch position data for LTV calc:", e.message);
+            }
+            const combinedSdk = await fetchOperateContext({
+                vaultId,
+                positionId,
+                colAmount: "-" + withdrawAmt.toString(),
+                debtAmount: "-" + proportionalDebt.toString(),
+                signerPda: usPda.toBase58(),
+            }, base);
+            const wdRemaining = deserializeRemaining(combinedSdk);
+            const combinedOtherIxs = deserializeOtherIxs(combinedSdk, usPda, owner);
+            // Override SDK's currentTick with the actual on-chain tick if they differ
+            const onChainTick = positionInfo.data.readInt32LE(47);
+            const sdkCurrentTick = combinedSdk.currentTickValue;
+            if (sdkCurrentTick != null && sdkCurrentTick !== onChainTick) {
+                wdRemaining[7] = {
+                    pubkey: deriveJuplendTickPda(vaultId, onChainTick),
+                    isSigner: false,
+                    isWritable: true,
+                };
+            }
+            const prepIx = await buildPrepareWithdrawIx(withdrawAmt, wdRemaining);
+            const juplendWithdrawLender = getJuplendWithdrawLenderAccounts(juplendPdas);
+            const buildWdIx = () => program.methods
+                .withdraw(withdrawAmt)
+                .accounts(getJuplendWithdrawAccounts(owner, juplendPdas, collateralMint))
+                .remainingAccounts([...juplendWithdrawLender, ...wdRemaining])
+                .instruction();
+            const luts = await resolveVaultLuts(base, withdrawVaultInfo.vi, [juplendLut]);
+            // Pre-sign rebuilder: refetch combinedSdk, recompute remaining + other ixs.
+            const rebuildOnTickError = async () => {
+                const fresh = await fetchOperateContext({
+                    vaultId,
+                    positionId,
+                    colAmount: "-" + withdrawAmt.toString(),
+                    debtAmount: "-" + proportionalDebt.toString(),
+                    signerPda: usPda.toBase58(),
+                }, base).catch(() => null);
+                if (!fresh)
+                    return null;
+                const freshWdRemaining = deserializeRemaining(fresh);
+                const freshOnChainTick = positionInfo.data.readInt32LE(47);
+                if (fresh.currentTickValue != null && fresh.currentTickValue !== freshOnChainTick) {
+                    freshWdRemaining[7] = {
+                        pubkey: deriveJuplendTickPda(vaultId, freshOnChainTick),
+                        isSigner: false,
+                        isWritable: true,
+                    };
+                }
+                const freshOtherIxs = deserializeOtherIxs(fresh, usPda, owner);
+                const freshWdIx = await program.methods
+                    .withdraw(withdrawAmt)
+                    .accounts(getJuplendWithdrawAccounts(owner, juplendPdas, collateralMint))
+                    .remainingAccounts([...juplendWithdrawLender, ...freshWdRemaining])
+                    .instruction();
+                return [...ataIxs, ...withdrawAtaIxs, ...freshOtherIxs, prepIx, freshWdIx, ...unwrapIxs];
+            };
+            // Single TX with tick correction retry (post-sign fallback for parseable mismatch)
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    const wdIx = await buildWdIx();
+                    return await sendVersionedTx(connection, [...ataIxs, ...withdrawAtaIxs, ...combinedOtherIxs, prepIx, wdIx, ...unwrapIxs], signer, luts, 1400000, false, rebuildOnTickError);
+                }
+                catch (err) {
+                    if (!isTickError(err.message))
+                        throw err;
+                    const correctTick = parseTickMismatch(err.message);
+                    if (correctTick !== null && attempt < 2) {
+                        const correctedTickPda = deriveJuplendTickPda(vaultId, correctTick);
+                        const tickInfo = await connection.getAccountInfo(correctedTickPda).catch(() => null);
+                        if (!tickInfo) {
+                            combinedOtherIxs.push(buildInitTickIx(vaultId, correctTick, owner));
+                        }
+                        wdRemaining[8] = { pubkey: correctedTickPda, isSigner: false, isWritable: true };
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+            throw new Error("Withdraw failed after tick correction attempts");
+        }
+        // Simple withdraw (no vault shares) — and the deposit/borrow/repay actions
+        const ix = await buildIx(sdkRemaining);
+        const luts = [juplendLut];
+        const rebuildOnTickError = async () => {
+            const fresh = await fetchOperateContext({ vaultId, positionId, colAmount, debtAmount, signerPda: usPda.toBase58() }, base).catch(() => null);
+            if (!fresh)
+                return null;
+            const freshRemaining = deserializeRemaining(fresh);
+            const freshOtherIxs = deserializeOtherIxs(fresh, usPda, owner);
+            const freshIx = await buildIx(freshRemaining);
+            return [...ataIxs, ...withdrawAtaIxs, ...wrapIxs, ...freshOtherIxs, freshIx, ...unwrapIxs];
+        };
+        try {
+            return await sendVersionedTx(connection, [...ataIxs, ...withdrawAtaIxs, ...wrapIxs, ...otherIxs, ix, ...unwrapIxs], signer, luts, 800000, false, rebuildOnTickError);
+        }
+        catch (txErr) {
+            // Belt-and-suspenders: post-sign retry for the parseable tick mismatch case
+            if (isTickError(txErr.message)) {
+                const correctTick = parseTickMismatch(txErr.message);
+                if (correctTick !== null) {
+                    sdkRemaining[8] = {
+                        pubkey: deriveJuplendTickPda(vaultId, correctTick),
+                        isSigner: false,
+                        isWritable: true,
+                    };
+                    sdkRemaining[10] = {
+                        pubkey: deriveJuplendTickIdLiquidationPda(vaultId, correctTick),
+                        isSigner: false,
+                        isWritable: true,
+                    };
+                    const retryIx = await buildIx(sdkRemaining);
+                    return await sendVersionedTx(connection, [...ataIxs, ...withdrawAtaIxs, ...wrapIxs, ...otherIxs, retryIx, ...unwrapIxs], signer, luts, 800000);
+                }
+            }
+            throw txErr;
+        }
+    }
+    // SDK unavailable — cbBTC fallback with hardcoded remaining accounts
+    const positionTick = positionInfo.data.length >= 83 ? positionInfo.data.readInt32LE(47) : -16383;
+    if (action === "borrow" || action === "repay") {
+        const oracleInfo = await connection.getAccountInfo(JUPLEND_ORACLE);
+        if (!oracleInfo)
+            throw new Error("JupLend oracle account not found on-chain.");
+    }
+    const currentTickPda = deriveJuplendTickPda(vaultId, positionTick);
+    const currentTickIdPda = deriveJuplendTickIdLiquidationPda(vaultId, positionTick);
+    let finalTickPda = currentTickPda;
+    let finalTickIdPda = currentTickIdPda;
+    const tickAccounts = await resolveTickAccounts(connection, owner, positionTick, positionTick, vaultId);
+    const buildRemaining = () => buildFallbackOperateRemaining(positionAddress, positionTokenAccount, currentTickPda, finalTickPda, currentTickIdPda, finalTickIdPda).remaining;
+    const fallbackRemaining = buildRemaining();
+    const ix = await buildIx(fallbackRemaining);
+    const fallbackPrepIxs = [];
+    if (withdrawHasVaultShares && withdrawVaultInfo) {
+        fallbackPrepIxs.push(await buildPrepareWithdrawIx(amount, fallbackRemaining));
+    }
+    const fallbackLuts = withdrawVaultInfo
+        ? await resolveVaultLuts(base, withdrawVaultInfo.vi, [juplendLut])
+        : [juplendLut];
+    const fallbackCU = withdrawHasVaultShares ? 1400000 : 600000;
+    try {
+        return await sendVersionedTx(connection, [...ataIxs, ...withdrawAtaIxs, ...wrapIxs, ...tickAccounts.initIxs, ...fallbackPrepIxs, ix, ...unwrapIxs], signer, fallbackLuts, fallbackCU);
+    }
+    catch (err) {
+        if (isTickError(err.message)) {
+            const correctFinalTick = parseTickMismatch(err.message);
+            if (correctFinalTick !== null) {
+                finalTickPda = deriveJuplendTickPda(vaultId, correctFinalTick);
+                finalTickIdPda = deriveJuplendTickIdLiquidationPda(vaultId, correctFinalTick);
+                const retryTickAccounts = await resolveTickAccounts(connection, owner, positionTick, correctFinalTick, vaultId);
+                const retryRemaining = buildRemaining();
+                const retryIx = await buildIx(retryRemaining);
+                const retryPrepIxs = [];
+                if (withdrawHasVaultShares && withdrawVaultInfo) {
+                    retryPrepIxs.push(await buildPrepareWithdrawIx(amount, retryRemaining));
+                }
+                return await sendVersionedTx(connection, [...ataIxs, ...withdrawAtaIxs, ...wrapIxs, ...retryTickAccounts.initIxs, ...retryPrepIxs, retryIx, ...unwrapIxs], signer, fallbackLuts, fallbackCU);
+            }
+        }
+        throw err;
+    }
+}
+// --- Kamino action flow (lifted from app page.tsx handleKaminoAction) ---
+async function kaminoAction(ctx, owner, usPda, allowlistPda, tokens, mc, safeGetAccountInfo) {
+    const { connection, signer, program, collateralMint, action, amount, base, userState } = ctx;
+    const isSol = collateralMint.equals(SOL_MINT);
+    // Use the obligation stored in userState (set during init) rather than re-deriving
+    const obligPda = userState.obligation;
+    const [derivedObligPda] = deriveObligationPda(usPda, mc.market);
+    if (!obligPda.equals(derivedObligPda)) {
+        console.warn("[action] Stored obligation", obligPda.toBase58(), "differs from derived", derivedObligPda.toBase58(), "— using stored");
+    }
+    const { obligationFarmUserStatePda, obligationFarmDebtUserStatePda } = deriveFarmPdas(obligPda, mc.collateralFarmState, mc.usdcReserveFarmDebt);
+    const pdas = {
+        userStatePda: usPda,
+        allowlistEntryPda: allowlistPda,
+        obligationPda: obligPda,
+        userMetadataPda: usPda,
+        obligationFarmUserStatePda,
+        obligationFarmDebtUserStatePda,
+        ...tokens,
+    };
+    const refreshCollateralIx = buildRefreshReserveIx(mc.collateralReserve, mc.market, mc.scopePrices);
+    const refreshUsdcIx = buildRefreshReserveIx(mc.usdcReserve, mc.market, mc.scopePrices);
+    const refreshReserves = [];
+    const obligInfo = await connection.getAccountInfo(obligPda);
+    const obligationExists = obligInfo !== null && obligInfo.data.length > 0;
+    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);
+    }
+    // Only build refreshObligation if the obligation exists on-chain
+    const refreshObligIxs = obligationExists
+        ? [buildRefreshObligationIx(mc.market, obligPda, refreshReserves)]
+        : [];
+    const lutParam = mc.market.equals(MAIN_MARKET_CONFIG.market) ? "main" : "xstocks";
+    const marketLut = await fetchMarketLut(base, lutParam);
+    if (action === "deposit") {
+        let wrapIxs = [];
+        if (isSol) {
+            wrapIxs = await buildWrapSolIxs(owner, tokens.userCollateralAta, amount, safeGetAccountInfo);
+        }
+        const kaminoDepositLender = getKaminoDepositLenderAccounts(pdas, mc);
+        const ix = await program.methods
+            .deposit(amount)
+            .accounts(getDepositAccounts(owner, pdas, mc))
+            .remainingAccounts(kaminoDepositLender)
+            .instruction();
+        return await sendLegacyTx(connection, [...wrapIxs, refreshCollateralIx, refreshUsdcIx, ...refreshObligIxs, ix], signer);
+    }
+    else if (action === "borrow") {
+        const ataIxs = [];
+        const pdaUsdcInfo = await safeGetAccountInfo(tokens.pdaUsdcAta);
+        if (!pdaUsdcInfo)
+            ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.pdaUsdcAta, usPda, USDC_MINT));
+        const userUsdcInfo = await safeGetAccountInfo(tokens.userUsdcAta);
+        if (!userUsdcInfo)
+            ataIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.userUsdcAta, owner, USDC_MINT));
+        let hasVaultShares = false;
+        const vaultType = userState.currentVaultType;
+        if (vaultType !== "none") {
+            const sharesAtaToCheck = getSharesAtaForVault(vaultType, tokens);
+            try {
+                const sharesBal = await connection.getTokenAccountBalance(sharesAtaToCheck);
+                hasVaultShares = BigInt(sharesBal.value.amount) > BigInt(0);
+            }
+            catch {
+                /* no shares */
+            }
+        }
+        if (hasVaultShares) {
+            const vi = getVaultInfo(vaultType);
+            const sharesAta = getSharesAtaForVault(vaultType, tokens);
+            let vaultRemaining;
+            if (vi.provider === "perena") {
+                vaultRemaining = getPerenaWithdrawAccountsWithMarginfi(usPda, tokens.pdaUsdcAta, sharesAta);
+            }
+            else {
+                const withdrawFixed = await resolveWithdrawFixed(connection, vi.vault);
+                vaultRemaining = getKvaultWithdrawRemaining(vi, withdrawFixed);
+            }
+            const kaminoLender = getKaminoBorrowLenderAccounts(pdas, mc, true);
+            const ix = await program.methods
+                .borrow(amount, vaultRemaining.length)
+                .accounts(getBorrowAccounts(owner, pdas, mc, true, {
+                vault: vi.vault,
+                sharesMint: vi.sharesMint,
+                sharesAta,
+            }))
+                .remainingAccounts([...vaultRemaining, ...kaminoLender])
+                .instruction();
+            const vaultLuts = await resolveVaultLuts(base, vi, marketLut ? [marketLut] : []);
+            return await sendVersionedTx(connection, [...ataIxs, refreshCollateralIx, refreshUsdcIx, ...refreshObligIxs, ix], signer, vaultLuts, 1400000);
+        }
+        else {
+            const kaminoLender = getKaminoBorrowLenderAccounts(pdas, mc, false);
+            const ix = await program.methods
+                .borrow(amount, 0)
+                .accounts(getBorrowAccounts(owner, pdas, mc, false))
+                .remainingAccounts([...kaminoLender])
+                .instruction();
+            return await sendLegacyTx(connection, [...ataIxs, refreshCollateralIx, refreshUsdcIx, ...refreshObligIxs, ix], signer);
+        }
+    }
+    else if (action === "repay") {
+        const kaminoRepayLender = getKaminoRepayLenderAccounts(pdas, mc);
+        const ix = await program.methods
+            .repay(amount)
+            .accounts(getRepayAccounts(owner, pdas, mc))
+            .remainingAccounts([...kaminoRepayLender])
+            .instruction();
+        return await sendLegacyTx(connection, [refreshCollateralIx, refreshUsdcIx, ...refreshObligIxs, ix], signer);
+    }
+    else {
+        const underlyingAmount = amount;
+        const reserveInfo = await connection.getAccountInfo(mc.collateralReserve);
+        const withdrawAmount = reserveInfo
+            ? new BN(underlyingToCTokens(underlyingAmount.toNumber(), reserveInfo.data))
+            : underlyingAmount;
+        const withdrawAtaIxs = [];
+        if (isSol) {
+            const ataInfo = await safeGetAccountInfo(tokens.userCollateralAta);
+            if (!ataInfo)
+                withdrawAtaIxs.push(createAssociatedTokenAccountInstruction(owner, tokens.userCollateralAta, owner, NATIVE_MINT));
+        }
+        let hasVaultShares = false;
+        const vaultType = userState.currentVaultType;
+        if (vaultType !== "none") {
+            const sharesAtaToCheck = getSharesAtaForVault(vaultType, tokens);
+            try {
+                const sharesBal = await connection.getTokenAccountBalance(sharesAtaToCheck);
+                hasVaultShares = BigInt(sharesBal.value.amount) > BigInt(0);
+            }
+            catch {
+                /* no shares */
+            }
+        }
+        // For SOL: close wSOL ATA to unwrap back to native SOL
+        const unwrapIxs = isSol
+            ? [createCloseAccountInstruction(tokens.userCollateralAta, owner, owner, [], TOKEN_PROGRAM_ID)]
+            : [];
+        if (hasVaultShares) {
+            const vi = getVaultInfo(vaultType);
+            const sharesAta = getSharesAtaForVault(vaultType, tokens);
+            const vaAccounts = { vault: vi.vault, sharesMint: vi.sharesMint, sharesAta };
+            let vaultRemaining;
+            if (vi.provider === "perena") {
+                vaultRemaining = getPerenaWithdrawAccountsWithMarginfi(usPda, tokens.pdaUsdcAta, sharesAta);
+            }
+            else {
+                const withdrawFixed = await resolveWithdrawFixed(connection, vi.vault);
+                vaultRemaining = getKvaultWithdrawRemaining(vi, withdrawFixed);
+            }
+            const kaminoPrepLender = getKaminoPrepareWithdrawLenderAccounts(pdas, mc);
+            const prepareIx = await program.methods
+                .prepareWithdraw(vaultRemaining.length, underlyingAmount)
+                .accounts(getPrepareWithdrawAccounts(owner, pdas, mc, vaAccounts))
+                .remainingAccounts([...vaultRemaining, ...kaminoPrepLender])
+                .instruction();
+            const kaminoWithdrawLender = getKaminoWithdrawLenderAccounts(pdas, mc);
+            const withdrawIx = await program.methods
+                .withdraw(withdrawAmount)
+                .accounts(getWithdrawAccounts(owner, pdas, mc))
+                .remainingAccounts(kaminoWithdrawLender)
+                .instruction();
+            const vaultLutsW = await resolveVaultLuts(base, vi, marketLut ? [marketLut] : []);
+            return await sendVersionedTx(connection, [...withdrawAtaIxs, prepareIx, withdrawIx, ...unwrapIxs], signer, vaultLutsW, 1400000);
+        }
+        else {
+            const kaminoWithdrawLender = getKaminoWithdrawLenderAccounts(pdas, mc);
+            const ix = await program.methods
+                .withdraw(withdrawAmount)
+                .accounts(getWithdrawAccounts(owner, pdas, mc))
+                .remainingAccounts(kaminoWithdrawLender)
+                .instruction();
+            return await sendLegacyTx(connection, [...withdrawAtaIxs, refreshCollateralIx, refreshUsdcIx, ...refreshObligIxs, ix, ...unwrapIxs], signer);
+        }
+    }
+}
+//# sourceMappingURL=executeAction.js.map