@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/lending-platforms/src/data/instructions/kamino.js

@@ -0,0 +1,630 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaminoInstructions = void 0;
+const core_1 = require("@anchor-lang/core");
+const kit_1 = require("@solana/kit");
+const scope_sdk_1 = require("@kamino-finance/scope-sdk");
+const klend_sdk_1 = require("@kamino-finance/klend-sdk");
+const common_1 = require("common");
+const lpInstructionsBase_1 = require("./lpInstructionsBase");
+const token_1 = require("@solana-program/token");
+const farms_sdk_1 = require("@kamino-finance/farms-sdk");
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+/**
+ * Instruction builder for Kamino Lend protocol.
+ * Provides methods to build CPI account metas for lending operations.
+ */
+class KaminoInstructions extends lpInstructionsBase_1.LpInstructionsBase {
+    constructor(rpc, rpcUrl, data, accounts) {
+        super(rpc, rpcUrl, data, accounts);
+        this.programId = klend_sdk_1.PROGRAM_ID;
+        this.lookupTable = (0, kit_1.address)("bzdjSeDDPEdsGpK73oevQ87x4Sm6QRsnzupPLQEaFFN");
+    }
+    clearTransactionCache(txId) {
+        super.clearTransactionCache(txId);
+    }
+    // ================ CPI Data ================
+    getUserAccountCacheInvalidations(userAccount) {
+        return [
+            this.getCacheInvalidation({
+                category: this.data.userAccountCatKey,
+                id: userAccount,
+            }),
+        ];
+    }
+    async getInitUserMetadataCpiData(user, payer, userLookupTable) {
+        const [userMetadataAddress] = await (0, klend_sdk_1.userMetadataPda)(user, this.programId);
+        if (await (0, common_1.accountExists)(this.rpc, userMetadataAddress))
+            return;
+        return this.getCpiData(common_1.CpiTypes.K_INIT_USER_METADATA, [
+            (0, common_1.toCustomAccountMeta)(user, false, undefined, true),
+            (0, common_1.toCustomAccountMeta)(payer, true, undefined, true),
+            (0, common_1.toCustomAccountMeta)(userMetadataAddress, true),
+            this.emptyAccountMeta(),
+            common_1.RENT_SYSVAR_META,
+            common_1.SYSTEM_PROGRAM_META,
+        ], new Uint8Array((0, kit_1.getAddressEncoder)().encode(userLookupTable ?? klend_sdk_1.DEFAULT_PUBLIC_KEY)));
+    }
+    async getInitLendingPositionCpiData(params) {
+        const userInit = await this.getInitUserAccountCpiData(params.pool, params.user, params.payer, params.userAccountId);
+        const obligation = await this.accounts.getUserAccountAddress(params.pool, params.user, params.userAccountId);
+        const farmCpis = [];
+        const farmTargets = [
+            [params.collateralReserve, "collateral"],
+            [params.debtReserve, "debt"],
+        ];
+        for (const [reserve, mode] of farmTargets) {
+            const reserveData = await this.data.fetchReserve(params.pool, reserve);
+            const reserveFarm = mode === "collateral"
+                ? reserveData.rawData.state.farmCollateral
+                : reserveData.rawData.state.farmDebt;
+            if (!reserveFarm || reserveFarm === klend_sdk_1.DEFAULT_PUBLIC_KEY)
+                continue;
+            const farmAccounts = await this.accounts.getFarmAccounts(params.pool, reserve, obligation, mode);
+            if (await (0, common_1.accountExists)(this.rpc, farmAccounts.userFarm.address))
+                continue;
+            farmCpis.push(await this.getInitObligationFarmsForReserveCpiData(params.user, params.payer, obligation, params.pool, reserve, mode));
+        }
+        return this.createSplitOperationCpiData(userInit.prerequisiteCpis, [
+            ...userInit.cpis,
+            ...farmCpis,
+        ]);
+    }
+    async getInitUserAccountCpiData(pool, user, payer, id, userLookupTable) {
+        const market = await this.data.fetchMarket(pool);
+        const obligationPda = await this.accounts.getUserAccountAddress(pool, user, id);
+        const userMetadataAddress = await this.accounts.getUserMetadataAddress(user);
+        const tag = klend_sdk_1.VanillaObligation.tag;
+        const initMetadataCpi = await this.getInitUserMetadataCpiData(user, payer, userLookupTable);
+        const obligationAlreadyInit = await (0, common_1.accountExists)(this.rpc, obligationPda);
+        return this.createSplitOperationCpiData([], [
+            ...(initMetadataCpi ? [initMetadataCpi] : []),
+            ...(obligationAlreadyInit
+                ? []
+                : [
+                    this.getCpiData(common_1.CpiTypes.K_INIT_OBLIGATION, [
+                        (0, common_1.toCustomAccountMeta)(user),
+                        (0, common_1.toCustomAccountMeta)(payer, true),
+                        (0, common_1.toCustomAccountMeta)(obligationPda, true),
+                        (0, common_1.toCustomAccountMeta)(market.address),
+                        (0, common_1.toCustomAccountMeta)(klend_sdk_1.DEFAULT_PUBLIC_KEY),
+                        (0, common_1.toCustomAccountMeta)(klend_sdk_1.DEFAULT_PUBLIC_KEY),
+                        (0, common_1.toCustomAccountMeta)(userMetadataAddress),
+                        common_1.RENT_SYSVAR_META,
+                        common_1.SYSTEM_PROGRAM_META,
+                    ], new Uint8Array([tag, id])),
+                ]),
+        ]);
+    }
+    async getInitObligationFarmsForReserveCpiData(user, payer, obligation, pool, reserve, farmMode) {
+        const farmAccounts = await this.accounts.getFarmAccounts(pool, reserve, obligation, farmMode);
+        return this.getCpiData(common_1.CpiTypes.K_INIT_USER_FARM, [
+            (0, common_1.toCustomAccountMeta)(payer, true),
+            (0, common_1.toCustomAccountMeta)(user),
+            (0, common_1.toCustomAccountMeta)(obligation, true),
+            (0, common_1.toCustomAccountMeta)((await (0, klend_sdk_1.lendingMarketAuthPda)(pool))[0]),
+            (0, common_1.toCustomAccountMeta)(reserve, true),
+            farmAccounts.farm,
+            farmAccounts.userFarm,
+            (0, common_1.toCustomAccountMeta)(pool),
+            (0, common_1.toCustomAccountMeta)(constants_1.KAMINO_FARMS_PROGRAM_ID),
+            common_1.RENT_SYSVAR_META,
+            common_1.SYSTEM_PROGRAM_META,
+        ], new Uint8Array([farmMode === "collateral" ? 0 : 1]));
+    }
+    /**
+     * Returns CPI accounts for refreshing a reserve's state.
+     * Includes the market, reserve, and all configured oracle accounts.
+     */
+    async getRefreshReserveCpiData(pool, reserve) {
+        const reserveData = await this.data.fetchReserve(pool, reserve);
+        const oracleAccounts = reserveData.getOracleAccounts();
+        return this.getCpiData(common_1.CpiTypes.K_REFRESH_RESERVE, [
+            (0, common_1.toCustomAccountMeta)(reserve, true),
+            (0, common_1.toCustomAccountMeta)(pool),
+            ...Object.values(oracleAccounts).map((x) => x === undefined ? this.emptyAccountMeta() : (0, common_1.toCustomAccountMeta)(x)),
+        ], new Uint8Array());
+    }
+    async getRefreshObligationCpiData(txId, pool, obligation) {
+        const obligationData = await this.data.maybeFetchUserPositionInPool(pool, obligation);
+        const cached = this.getTxUserAccountReserves(txId, obligation);
+        // Drop debt reserves the caller has flagged as fully repaid earlier in
+        // the same tx (via `markObligationDebtCleared`). The on-chain obligation
+        // will no longer list them by the time this RefreshObligation runs;
+        // including them here would trip Kamino's account-count check
+        // (`expected_remaining_accounts != actual_remaining_accounts`,
+        // InvalidAccountInput / klend 6006).
+        const cleared = this.getTxObligationClearedDebt(txId, obligation);
+        const collateralReserves = [
+            ...new Set([...(obligationData?.deposits.map((x) => x.reserve) ?? []), ...cached.collateral]),
+        ];
+        // Drop any debt reserves a prior CPI in this tx already cleared via the
+        // repay-all sentinel — at execution time the obligation no longer carries
+        // that borrow, and klend rejects the mismatched accounts count
+        // (`InvalidAccountInput`, error 6006).
+        const debtReserves = [
+            ...new Set([...(obligationData?.borrows.map((x) => x.reserve) ?? []), ...cached.debt]),
+        ].filter((r) => !cleared.has(r));
+        return this.getCpiData(common_1.CpiTypes.K_REFRESH_OBLIGATION, [
+            (0, common_1.toCustomAccountMeta)(pool),
+            (0, common_1.toCustomAccountMeta)(obligation, true),
+            ...collateralReserves.map((x) => (0, common_1.toCustomAccountMeta)(x)),
+            ...debtReserves.map((x) => (0, common_1.toCustomAccountMeta)(x)),
+        ], new Uint8Array());
+    }
+    getRefreshObligationCpiDataFromReserves({ pool, userAccount, collateralReserves, debtReserves, }) {
+        return this.getCpiData(common_1.CpiTypes.K_REFRESH_OBLIGATION, [
+            (0, common_1.toCustomAccountMeta)(pool),
+            (0, common_1.toCustomAccountMeta)(userAccount, true),
+            ...(0, common_1.dedupeOrderedAddresses)(collateralReserves).map((x) => (0, common_1.toCustomAccountMeta)(x)),
+            ...(0, common_1.dedupeOrderedAddresses)(debtReserves).map((x) => (0, common_1.toCustomAccountMeta)(x)),
+        ], new Uint8Array());
+    }
+    async getPrerequisiteCpisForRefresh(targets) {
+        const reserveRefreshes = [];
+        const seenReserveRefreshes = new Set();
+        const obligationRefreshes = new Map();
+        for (const target of targets) {
+            for (const reserve of (0, common_1.dedupeOrderedAddresses)([
+                ...target.collateralReserves,
+                ...target.debtReserves,
+            ])) {
+                const reserveRefreshKey = `${target.pool}:${reserve}`;
+                if (seenReserveRefreshes.has(reserveRefreshKey)) {
+                    continue;
+                }
+                seenReserveRefreshes.add(reserveRefreshKey);
+                reserveRefreshes.push({ pool: target.pool, reserve });
+            }
+            if (target.userAccount === klend_sdk_1.DEFAULT_PUBLIC_KEY) {
+                continue;
+            }
+            const obligationKey = `${target.pool}:${target.userAccount}`;
+            if (obligationRefreshes.has(obligationKey)) {
+                continue;
+            }
+            obligationRefreshes.set(obligationKey, {
+                pool: target.pool,
+                userAccount: target.userAccount,
+                collateralReserves: (0, common_1.dedupeOrderedAddresses)(target.collateralReserves),
+                debtReserves: (0, common_1.dedupeOrderedAddresses)(target.debtReserves),
+            });
+        }
+        const prerequisiteCpis = [];
+        for (const { pool, reserve } of reserveRefreshes) {
+            prerequisiteCpis.push(await this.getRefreshReserveCpiData(pool, reserve));
+        }
+        for (const obligationRefresh of obligationRefreshes.values()) {
+            let obligationData = null;
+            try {
+                obligationData = await this.data.maybeFetchUserPositionInPool(obligationRefresh.pool, obligationRefresh.userAccount);
+            }
+            catch {
+                obligationData = null;
+            }
+            if (!obligationData) {
+                continue;
+            }
+            prerequisiteCpis.push(this.getRefreshObligationCpiDataFromReserves({
+                pool: obligationRefresh.pool,
+                userAccount: obligationRefresh.userAccount,
+                collateralReserves: obligationData.deposits.map((deposit) => deposit.reserve),
+                debtReserves: obligationData.borrows.map((borrow) => borrow.reserve),
+            }));
+        }
+        return prerequisiteCpis;
+    }
+    async getRefreshUserFarmCpiData(signer, pool, reserve, obligation, userFarm, farm, mode) {
+        const details = await this.accounts.reserveInteractionDetails(signer, pool, reserve, obligation);
+        return this.getCpiData(common_1.CpiTypes.K_REFRESH_USER_FARM, [
+            details.signer,
+            details.obligation,
+            details.lendingMarketAuthority,
+            details.reserve,
+            (0, common_1.toCustomAccountMeta)(farm, true),
+            (0, common_1.toCustomAccountMeta)(userFarm, true),
+            details.lendingMarket,
+            details.farmsProgram,
+            common_1.RENT_SYSVAR_META,
+            common_1.SYSTEM_PROGRAM_META,
+        ], new Uint8Array([mode === "collateral" ? 0 : 1]));
+    }
+    /**
+     * Checks if refresh CPIs are needed for the given reserve and obligation.
+     * Also registers all involved reserves in the txReserves cache for getPreInstructions.
+     *
+     * The instruction `reserve` (collateral vs debt) is also listed on the obligation;
+     * `dedupeOrderedAddresses` ensures one RefreshReserve CPI per reserve pubkey.
+     */
+    async getRefreshCpisIfNeeded(txId, pool, reserve, obligation) {
+        const cpis = [];
+        const cached = this.getTxUserAccountReserves(txId, obligation);
+        const refreshReserve = async (reserveAddr) => {
+            cpis.push(await this.getRefreshReserveCpiData(pool, reserveAddr));
+            this.registerTxReserve(txId, pool, reserveAddr);
+        };
+        const obligationData = await this.data.maybeFetchUserPositionInPool(pool, obligation);
+        if (obligationData) {
+            const needsFullObligationRefresh = obligationData.requiresRefresh() || cached.collateral.length > 0 || cached.debt.length > 0;
+            if (needsFullObligationRefresh) {
+                const additional = [
+                    ...obligationData.deposits.map((d) => d.reserve),
+                    ...obligationData.borrows.map((b) => b.reserve),
+                    ...cached.collateral,
+                    ...cached.debt,
+                ];
+                for (const addr of (0, common_1.dedupeOrderedAddresses)([reserve, ...additional])) {
+                    await refreshReserve(addr);
+                }
+                cpis.push(await this.getRefreshObligationCpiData(txId, pool, obligation));
+            }
+            else {
+                await refreshReserve(reserve);
+            }
+        }
+        else {
+            const additional = [...new Set([...cached.collateral, ...cached.debt])];
+            for (const addr of (0, common_1.dedupeOrderedAddresses)([reserve, ...additional])) {
+                await refreshReserve(addr);
+            }
+            cpis.push(await this.getRefreshObligationCpiData(txId, pool, obligation));
+        }
+        return cpis;
+    }
+    async getPreInstructions(txId) {
+        const reserveEntries = this.txReserves.get(txId);
+        if (!reserveEntries)
+            return [];
+        const SCOPE_CHAIN_END = 65535;
+        // Collect scope feed -> token indices, then merge feeds that share the
+        // same Scope Configuration into a single RefreshPriceList instruction.
+        // Scope's on-chain handler rejects a RefreshPriceList that is preceded by
+        // non-Scope instructions, so emitting multiple ixs only works when they
+        // are consecutive with nothing in between — grouping by config avoids the
+        // problem entirely.
+        const scopeFeeds = new Map();
+        if (reserveEntries) {
+            for (const [reserve, { pool }] of reserveEntries) {
+                const reserveData = await this.data.fetchReserve(pool, reserve);
+                if (!reserveData.requiresRefresh())
+                    continue;
+                const scopeFeed = reserveData.getOracleAccounts().scope;
+                if (!scopeFeed)
+                    continue;
+                if (!scopeFeeds.has(scopeFeed)) {
+                    scopeFeeds.set(scopeFeed, new Set());
+                }
+                const tokens = scopeFeeds.get(scopeFeed);
+                const { priceChain, twapChain } = reserveData.rawData.state.config.tokenInfo.scopeConfiguration;
+                for (const chain of [priceChain, twapChain]) {
+                    for (const index of chain) {
+                        if (index === SCOPE_CHAIN_END)
+                            break;
+                        tokens.add(index);
+                    }
+                }
+            }
+        }
+        // Resolve each feed's config, then merge token indices by config address.
+        // Scope's on-chain handler rejects a RefreshPriceList that is preceded by
+        // a RefreshPriceList from a different Configuration account, so we can only
+        // emit one instruction per transaction. On deployed environments crankers
+        // keep prices fresh, so skipping additional configs is safe.
+        const configTokens = new Map();
+        for (const [feed, chainTokens] of scopeFeeds) {
+            const configAddr = await this.data.fetchScopeConfigAddress(feed);
+            if (!configTokens.has(configAddr)) {
+                configTokens.set(configAddr, new Set());
+            }
+            const merged = configTokens.get(configAddr);
+            for (const t of chainTokens)
+                merged.add(t);
+        }
+        const scope = new scope_sdk_1.Scope("mainnet-beta", this.rpc);
+        const isLocalnet = this.rpcUrl === common_1.LOCALNET_URL;
+        // Take only the first config to avoid the cross-config Scope rejection.
+        const [firstEntry] = configTokens;
+        if (!firstEntry)
+            return [];
+        const [configAddr, chainTokens] = firstEntry;
+        let tokens;
+        if (isLocalnet) {
+            // On localnet there are no crankers keeping Scope prices fresh, so we
+            // must resolve the full dependency graph (CappedFloored sources, etc.)
+            // and refresh in topological order.
+            const mappings = await scope.getOracleMappings({ config: (0, kit_1.address)(configAddr) });
+            const allTokens = new Set();
+            for (const token of chainTokens) {
+                (0, utils_1.collectTokenDependencies)(token, mappings, allTokens);
+            }
+            tokens = [...allTokens];
+        }
+        else {
+            tokens = [...chainTokens];
+        }
+        const ix = await scope.refreshPriceListIx({ config: (0, kit_1.address)(configAddr) }, tokens);
+        return ix ? [ix] : [];
+    }
+    async getClaimIncentiveCpiData(user, payer, pool, reserve, obligation, farm, userFarm, mint) {
+        const tokenProgram = common_1.mints.get(mint)?.tokenProgram ?? token_1.TOKEN_PROGRAM_ADDRESS;
+        const reserveData = await this.data.fetchReserve(pool, reserve);
+        const [farmState] = await this.data.fetchFarms([farm]);
+        const rewardIndex = farmState.rewardInfos.findIndex((r) => r.token.mint === mint);
+        if (rewardIndex === -1) {
+            throw new Error(`Reward mint ${mint} not found on farm ${farm}`);
+        }
+        const rewardInfo = farmState.rewardInfos[rewardIndex];
+        const treasuryVault = await (0, farms_sdk_1.getTreasuryVaultPDA)(constants_1.KAMINO_FARMS_PROGRAM_ID, farmState.globalConfig, mint);
+        const scopePrices = farmState.scopePrices === klend_sdk_1.DEFAULT_PUBLIC_KEY
+            ? constants_1.KAMINO_FARMS_PROGRAM_ID
+            : farmState.scopePrices;
+        const mode = reserveData.rawData.state.farmCollateral === farm
+            ? "collateral"
+            : reserveData.rawData.state.farmDebt === farm
+                ? "debt"
+                : undefined;
+        const refreshIx = mode
+            ? await this.getRefreshUserFarmCpiData(user, pool, reserve, obligation, userFarm, farm, mode)
+            : undefined;
+        // Kfarms HarvestReward requires `owner` (account[0]) to equal
+        // `UserState.owner`, which for both klend obligation farms and direct/extra
+        // farms is the lyc-token PDA — `user` here. The CPI dispatcher signs for it
+        // via `invoke_signed` with the token PDA seeds. Passing the manager fails
+        // with HarvestingNotPermissionlessPayerMismatch (0x17b2).
+        return [
+            ...(refreshIx ? [refreshIx] : []),
+            this.getCpiData(common_1.CpiTypes.K_HARVEST_REWARD, [
+                (0, common_1.toCustomAccountMeta)(user, true),
+                (0, common_1.toCustomAccountMeta)(userFarm, true),
+                (0, common_1.toCustomAccountMeta)(farm, true),
+                (0, common_1.toCustomAccountMeta)(farmState.globalConfig),
+                (0, common_1.toCustomAccountMeta)(mint),
+                (0, common_1.toCustomAccountMeta)(await (0, common_1.getAtaAddress)(mint, user, tokenProgram), true, {
+                    owner: user,
+                    mint,
+                    tokenProgram,
+                }),
+                (0, common_1.toCustomAccountMeta)(rewardInfo.rewardsVault, true),
+                (0, common_1.toCustomAccountMeta)(treasuryVault, true),
+                (0, common_1.toCustomAccountMeta)(farmState.farmVaultsAuthority),
+                (0, common_1.toCustomAccountMeta)(scopePrices),
+                (0, common_1.toCustomAccountMeta)(tokenProgram),
+            ], (0, common_1.numToU64Bytes)(rewardIndex), constants_1.KAMINO_FARMS_PROGRAM_ID),
+        ];
+    }
+    async getRequestElevationGroupCpiData(elevationGroup, user, obligation, pool, txId) {
+        // Kamino's request_elevation_group handler validates the trailing
+        // remaining accounts against the obligation's *current* deposit + borrow
+        // reserves — the same `expected_remaining_accounts != actual_remaining_accounts`
+        // count check that RefreshObligation enforces (see
+        // `getRefreshObligationCpiData`); a mismatch throws InvalidAccountInput
+        // (klend 6006). Passing only the three fixed accounts (as we used to)
+        // works for an empty obligation but fails the moment it holds a deposit
+        // — e.g. the flash-rebalance destination, which has the just-moved
+        // collateral deposited before this elevation request runs.
+        //
+        // Mirror the refresh path: append the obligation's collateral then debt
+        // reserves, combining on-chain state with reserves registered earlier in
+        // this same tx (the destination deposit isn't reflected on-chain yet at
+        // build time). Kamino marks these WRITABLE.
+        const obligationData = await this.data.maybeFetchUserPositionInPool(pool, obligation);
+        const cached = this.getTxUserAccountReserves(txId, obligation);
+        const cleared = this.getTxObligationClearedDebt(txId, obligation);
+        const collateralReserves = [
+            ...new Set([...(obligationData?.deposits.map((x) => x.reserve) ?? []), ...cached.collateral]),
+        ];
+        const debtReserves = [
+            ...new Set([...(obligationData?.borrows.map((x) => x.reserve) ?? []), ...cached.debt]),
+        ].filter((r) => !cleared.has(r));
+        return this.getCpiData(common_1.CpiTypes.K_REQUEST_ELEVATION_GROUP, [
+            (0, common_1.toCustomAccountMeta)(user),
+            (0, common_1.toCustomAccountMeta)(obligation, true),
+            (0, common_1.toCustomAccountMeta)(pool),
+            ...collateralReserves.map((x) => (0, common_1.toCustomAccountMeta)(x, true)),
+            ...debtReserves.map((x) => (0, common_1.toCustomAccountMeta)(x, true)),
+        ], new Uint8Array([elevationGroup]));
+    }
+    async getInitAndDepositCpiData(params, userAccountId) {
+        const initCpis = [];
+        if (!(await (0, common_1.accountExists)(this.rpc, params.userAccount))) {
+            initCpis.push(...(await this.getInitUserAccountCpiData(params.pool, params.user, params.payer, userAccountId)).allCpis, await this.getRefreshObligationCpiData(params.txId, params.pool, params.userAccount));
+        }
+        const reserveData = await this.data.fetchReserve(params.pool, params.reserve);
+        const farmCollateral = reserveData.rawData.state.farmCollateral;
+        if (farmCollateral && farmCollateral !== klend_sdk_1.DEFAULT_PUBLIC_KEY) {
+            const farmAccounts = await this.accounts.getFarmAccounts(params.pool, params.reserve, params.userAccount, "collateral");
+            if (!(await (0, common_1.accountExists)(this.rpc, farmAccounts.userFarm.address))) {
+                initCpis.push(await this.getInitObligationFarmsForReserveCpiData(params.user, params.payer, params.userAccount, params.pool, params.reserve, "collateral"));
+            }
+        }
+        const depositCpis = await this.getDepositCpiData(params);
+        return this.createSplitOperationCpiData([...initCpis, ...depositCpis.prerequisiteCpis], depositCpis.cpis);
+    }
+    async getInitBorrowPositionCpiData(params, collReserve) {
+        const initCpis = [];
+        const reserveData = await this.data.fetchReserve(params.pool, params.reserve);
+        const farmDebt = reserveData.rawData.state.farmDebt;
+        if (farmDebt && farmDebt !== klend_sdk_1.DEFAULT_PUBLIC_KEY) {
+            const farmAccounts = await this.accounts.getFarmAccounts(params.pool, params.reserve, params.userAccount, "debt");
+            if (!(await (0, common_1.accountExists)(this.rpc, farmAccounts.userFarm.address))) {
+                initCpis.push(await this.getInitObligationFarmsForReserveCpiData(params.user, params.payer, params.userAccount, params.pool, params.reserve, "debt"));
+            }
+        }
+        const debtReserveData = await this.data.fetchReserve(params.pool, params.reserve);
+        const market = await this.data.fetchMarket(params.pool);
+        const requestedBorrowBaseUnits = params.baseUnitAmount && params.baseUnitAmount !== "all"
+            ? params.baseUnitAmount
+            : typeof params.uiAmount === "number"
+                ? new core_1.BN(Math.floor(params.uiAmount * Math.pow(10, debtReserveData.mint.mintDecimals)))
+                : undefined;
+        const collReserveData = await this.data.fetchReserve(params.pool, collReserve);
+        const availableElevationGroups = collReserveData.config.emodes?.filter((x) => x.debtReserve === params.reserve);
+        if (availableElevationGroups?.length) {
+            // Greedily prefer the highest-LTV e-mode group, but only enter one that
+            // actually has borrow capacity for this debt+collateral pair right now.
+            // Kamino rejects entry into a group whose debt cap is exhausted or
+            // disabled (ElevationGroupBorrowLimitExceeded, klend 6101); the cap lives
+            // on the collateral reserve, indexed per group. `getLiquidityAvailable…`
+            // folds the emode cap together with the reserve's global / utilization /
+            // daily caps and returns 0 for a maxed/zeroed group. When none qualify we
+            // fall back to no e-mode (group 0) — LYC sizing uses the base (non-emode)
+            // LTV, so the borrow always fits there.
+            const sortedGroups = [...availableElevationGroups]
+                .filter((g) => g.id !== undefined)
+                .sort((a, b) => b.ltvPct - a.ltvPct);
+            let selectedGroup;
+            for (const group of sortedGroups) {
+                const [available] = debtReserveData.rawData.getLiquidityAvailableForDebtReserveGivenCaps(market, [group.id], [collReserve]);
+                const hasCapacity = requestedBorrowBaseUnits
+                    ? available.gte(requestedBorrowBaseUnits.toString())
+                    : available.gt(0);
+                if (hasCapacity) {
+                    selectedGroup = group.id;
+                    break;
+                }
+            }
+            if (selectedGroup !== undefined) {
+                // RequestElevationGroup requires the obligation to be refreshed in the
+                // current slot (klend ObligationStale / 6017). A preceding CPI in this
+                // group — e.g. the destination collateral deposit in a flash rebalance —
+                // dirties the obligation, so refresh it (and its reserves) immediately
+                // before the elevation request. Refreshing against `collReserve` scopes
+                // the RefreshObligation to the obligation's current deposits; the borrow
+                // below emits its own refresh afterward, re-freshening the obligation
+                // that RequestElevationGroup itself leaves stale.
+                initCpis.push(...(await this.getRefreshCpisIfNeeded(params.txId, params.pool, collReserve, params.userAccount)));
+                initCpis.push(await this.getRequestElevationGroupCpiData(selectedGroup, params.user, params.userAccount, params.pool, params.txId));
+            }
+        }
+        const borrowCpis = await this.getBorrowCpiData(params);
+        return this.createSplitOperationCpiData([...initCpis, ...borrowCpis.prerequisiteCpis], borrowCpis.cpis);
+    }
+    async getDepositCpiData(params) {
+        const refreshCpis = await this.getRefreshCpisIfNeeded(params.txId, params.pool, params.reserve, params.userAccount);
+        const details = await this.accounts.reserveInteractionDetails(params.user, params.pool, params.reserve, params.userAccount, typeof params.uiAmount === "number" ? params.uiAmount : undefined, params.baseUnitAmount instanceof core_1.BN ? params.baseUnitAmount : undefined);
+        const farms = await this.accounts.getFarmAccounts(params.pool, params.reserve, params.userAccount, "collateral");
+        this.registerTxReserve(params.txId, params.pool, params.reserve, params.userAccount, "collateral");
+        return this.createSplitOperationCpiData(refreshCpis, [
+            this.getCpiData(common_1.CpiTypes.K_DEPOSIT, [
+                details.signer,
+                details.obligation,
+                details.lendingMarket,
+                details.lendingMarketAuthority,
+                details.reserve,
+                details.reserveLiquidityMint,
+                details.reserveLiquiditySupply,
+                details.reserveCollateralMint,
+                details.reserveCollateralSupply,
+                details.userLiquidityTa,
+                this.emptyAccountMeta(),
+                details.collateralMintTokenProgram,
+                details.liquidityMintTokenProgram,
+                common_1.IX_SYSVAR_META,
+                farms.userFarm,
+                farms.farm,
+                details.farmsProgram,
+            ], details.baseUnitAmount ? (0, common_1.numToU64Bytes)(details.baseUnitAmount) : undefined, undefined, this.getUserAccountCacheInvalidations(params.userAccount)),
+        ]);
+    }
+    async getWithdrawCpiData(params) {
+        const refreshCpis = await this.getRefreshCpisIfNeeded(params.txId, params.pool, params.reserve, params.userAccount);
+        const withdrawAll = params.uiAmount === "all" || params.baseUnitAmount === "all";
+        const details = await this.accounts.reserveInteractionDetails(params.user, params.pool, params.reserve, params.userAccount, typeof params.uiAmount === "number" ? params.uiAmount : undefined, params.baseUnitAmount instanceof core_1.BN ? params.baseUnitAmount : undefined);
+        const farms = await this.accounts.getFarmAccounts(params.pool, params.reserve, params.userAccount, "collateral");
+        let collateralBytes;
+        if (withdrawAll) {
+            // Kamino's `WithdrawObligationCollateralAndRedeemReserveCollateralV2`
+            // treats `collateral_amount = u64::MAX` as "withdraw the obligation's
+            // entire deposit on this reserve" — clears dust regardless of off-chain
+            // cToken/liquidity rate drift.
+            collateralBytes = (0, common_1.numToU64Bytes)(common_1.U64_MAX_BN);
+        }
+        else if (details.baseUnitAmount) {
+            const reserveData = await this.data.fetchReserve(params.pool, params.reserve);
+            // +1 cToken so the on-chain redemption always realizes at least the
+            // requested liquidity amount despite the floor in the exchange rate
+            // conversion and minor rate drift between fetch and execution.
+            const collateralAmount = (0, utils_1.liquidityToCollateral)(reserveData, details.baseUnitAmount.toNumber()) + 1;
+            collateralBytes = (0, common_1.numToU64Bytes)(collateralAmount);
+        }
+        this.registerTxReserve(params.txId, params.pool, params.reserve, params.userAccount, "collateral");
+        return this.createSplitOperationCpiData(refreshCpis, [
+            this.getCpiData(common_1.CpiTypes.K_WITHDRAW, [
+                details.signer,
+                details.obligation,
+                details.lendingMarket,
+                details.lendingMarketAuthority,
+                details.reserve,
+                details.reserveLiquidityMint,
+                details.reserveCollateralSupply,
+                details.reserveCollateralMint,
+                details.reserveLiquiditySupply,
+                details.userLiquidityTa,
+                this.emptyAccountMeta(),
+                details.collateralMintTokenProgram,
+                details.liquidityMintTokenProgram,
+                common_1.IX_SYSVAR_META,
+                farms.userFarm,
+                farms.farm,
+                details.farmsProgram,
+            ], collateralBytes, undefined, this.getUserAccountCacheInvalidations(params.userAccount)),
+        ]);
+    }
+    async getBorrowCpiData(params) {
+        const refreshCpis = await this.getRefreshCpisIfNeeded(params.txId, params.pool, params.reserve, params.userAccount);
+        const details = await this.accounts.reserveInteractionDetails(params.user, params.pool, params.reserve, params.userAccount, typeof params.uiAmount === "number" ? params.uiAmount : undefined);
+        const farms = await this.accounts.getFarmAccounts(params.pool, params.reserve, params.userAccount, "debt");
+        this.registerTxReserve(params.txId, params.pool, params.reserve, params.userAccount, "debt");
+        return this.createSplitOperationCpiData(refreshCpis, [
+            this.getCpiData(common_1.CpiTypes.K_BORROW, [
+                details.signer,
+                details.obligation,
+                details.lendingMarket,
+                details.lendingMarketAuthority,
+                details.reserve,
+                details.reserveLiquidityMint,
+                details.reserveLiquiditySupply,
+                details.reserveFeeVault,
+                details.userLiquidityTa,
+                this.emptyAccountMeta(),
+                details.liquidityMintTokenProgram,
+                common_1.IX_SYSVAR_META,
+                farms.userFarm,
+                farms.farm,
+                details.farmsProgram,
+            ], details.baseUnitAmount ? (0, common_1.numToU64Bytes)(details.baseUnitAmount) : undefined, undefined, this.getUserAccountCacheInvalidations(params.userAccount)),
+        ]);
+    }
+    async getRepayCpiData(params) {
+        this.registerTxReserve(params.txId, params.pool, params.reserve, params.userAccount, "debt");
+        const refreshCpis = await this.getRefreshCpisIfNeeded(params.txId, params.pool, params.reserve, params.userAccount);
+        const details = await this.accounts.reserveInteractionDetails(params.user, params.pool, params.reserve, params.userAccount, typeof params.uiAmount === "number" ? params.uiAmount : undefined);
+        const farms = await this.accounts.getFarmAccounts(params.pool, params.reserve, params.userAccount, "debt");
+        const repayAmountBytes = params.full
+            ? (0, common_1.numToU64Bytes)(common_1.U64_MAX_BN)
+            : params.baseUnitAmount
+                ? (0, common_1.numToU64Bytes)(params.baseUnitAmount)
+                : details.baseUnitAmount
+                    ? (0, common_1.numToU64Bytes)(details.baseUnitAmount)
+                    : undefined;
+        return this.createSplitOperationCpiData(refreshCpis, [
+            this.getCpiData(common_1.CpiTypes.K_REPAY, [
+                details.signer,
+                details.obligation,
+                details.lendingMarket,
+                details.reserve,
+                details.reserveLiquidityMint,
+                details.reserveLiquiditySupply,
+                details.userLiquidityTa,
+                details.liquidityMintTokenProgram,
+                common_1.IX_SYSVAR_META,
+                farms.userFarm,
+                farms.farm,
+                details.lendingMarketAuthority,
+                details.farmsProgram,
+            ], repayAmountBytes, undefined, this.getUserAccountCacheInvalidations(params.userAccount)),
+        ]);
+    }
+}
+exports.KaminoInstructions = KaminoInstructions;