@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/lending-platforms/src/services/leverage/leverageService.js

@@ -0,0 +1,437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeverageService = exports.FlashRebalanceSwapCostExceededError = void 0;
+const core_1 = require("@anchor-lang/core");
+const common_1 = require("common");
+const jupiter_helpers_1 = require("jupiter-helpers");
+const lendingPositionManager_1 = require("../lendingPosition/lendingPositionManager");
+const reservesManager_1 = require("../reservesManager");
+const DECREASE_LEVERAGE_SWAP_BUFFER_BPS = 5;
+const DECREASE_LEVERAGE_SWAP_SLIPPAGE_BPS = 40;
+const DECREASE_LEVERAGE_SWAP_MAX_ACCOUNTS = 30;
+const FLASH_REBALANCE_SWAP_MAX_ACCOUNTS = 25;
+/**
+ * Thrown by {@link LeverageService.buildFlashRebalance} when the quoted
+ * destination-debt → source-debt swap breaches a caller-set bound. The quote's
+ * total below-par gap is split into two components, each bounded separately:
+ *
+ * - `executionCostBps` — quote rate vs the oracle-fair cross rate: route fees
+ *   + price impact. Permanently lost value.
+ * - `marketBasisBps` — oracle-fair cross rate vs 1:1: genuine USD price
+ *   difference between the two stables. Charged to the token's carry-vs-debt
+ *   difference by the $1-pinned books at conversion time, but reverses on
+ *   unwind if the basis persists.
+ *
+ * `reason` names which bound was breached; both measured components are
+ * always populated for logging/telemetry.
+ */
+class FlashRebalanceSwapCostExceededError extends Error {
+    constructor(reason, executionCostBps, marketBasisBps, limitBps, inputAmount, outputAmount) {
+        super(`LeverageService.buildFlashRebalance: swap ${reason} exceeds ${limitBps} bps ` +
+            `(execution cost ${executionCostBps.toFixed(2)} bps, market basis ${marketBasisBps.toFixed(2)} bps, ` +
+            `in=${inputAmount} out=${outputAmount})`);
+        this.reason = reason;
+        this.executionCostBps = executionCostBps;
+        this.marketBasisBps = marketBasisBps;
+        this.limitBps = limitBps;
+        this.inputAmount = inputAmount;
+        this.outputAmount = outputAmount;
+        this.name = "FlashRebalanceSwapCostExceededError";
+    }
+}
+exports.FlashRebalanceSwapCostExceededError = FlashRebalanceSwapCostExceededError;
+/**
+ * Stateless service that sizes and builds lending-protocol CPIs for leverage
+ * changes on a collateral/debt reserve pair.
+ *
+ * Inputs are generic lending-platform types (reserves, LP client, position
+ * identifiers). No program-specific types.
+ *
+ * - **Increase leverage** → calculates borrow amount to reach target, builds
+ *   borrow CPIs.
+ * - **Decrease leverage** → calculates repay amount to reach target, builds
+ *   repay CPIs, and assembles swap + repay CPI groups when the debt token must
+ *   be obtained via swap.
+ */
+class LeverageService {
+    /**
+     * Calculate the borrow amount needed to reach the target utilization rate,
+     * then build the borrow CPIs.
+     */
+    static async buildIncreaseLeverage(ctx, params) {
+        const reserves = new reservesManager_1.ReservesManager(ctx.supplyReserve, ctx.debtReserve, ctx.environment);
+        const mode = params.mode ?? "debtOnly";
+        const debtAdjustmentUsd = await reserves.calcDebtAdjustmentUsd(params.currentSupplyUiAmount, params.currentDebtUiAmount, params.targetUtilizationRateBps, { positionChangeMode: mode });
+        const prices = await reserves.prices();
+        const borrowUiAmount = Math.abs(debtAdjustmentUsd / prices.debt.realtimePrice);
+        const borrowBaseUnits = (0, common_1.fromUiAmount)(borrowUiAmount, ctx.debtReserve.mint.mintDecimals);
+        const { prerequisiteCpis, cpis, postSuccessCacheInvalidations } = await ctx.lendingIx.getBorrowCpiBundle({
+            user: ctx.user,
+            payer: ctx.payer,
+            pool: ctx.pool,
+            reserve: ctx.debtReserve.address,
+            userAccount: ctx.userAccount,
+            uiAmount: borrowUiAmount,
+            txId: ctx.txId,
+        });
+        const preInstructions = await ctx.lendingIx.getPreInstructions(ctx.txId);
+        return {
+            borrowUiAmount,
+            borrowBaseUnits,
+            prerequisiteCpis,
+            borrowCpis: cpis,
+            preInstructions,
+            postSuccessCacheInvalidations,
+        };
+    }
+    /**
+     * Calculate the repay amount needed to reach the target utilization rate,
+     * build the repay CPIs, and assemble CPI groups with an optional swap
+     * prepended when the caller's debt-token balance is insufficient.
+     *
+     * The returned `repayUiAmount` is always non-negative. When the position is
+     * already at or below the target, the amount is zero and the CPI list is
+     * sized for a zero repay.
+     */
+    static async buildDecreaseLeverage(ctx, params) {
+        const reserves = new reservesManager_1.ReservesManager(ctx.supplyReserve, ctx.debtReserve, ctx.environment);
+        const mode = params.mode ?? "debtOnly";
+        const debtAdjustmentUsd = await reserves.calcDebtAdjustmentUsd(params.currentSupplyUiAmount, params.currentDebtUiAmount, params.targetUtilizationRateBps, { positionChangeMode: mode });
+        const prices = await reserves.prices();
+        const debtDecimals = ctx.debtReserve.mint.mintDecimals;
+        const repayUiAmount = Math.abs(debtAdjustmentUsd / prices.debt.realtimePrice);
+        const calculatedRepayBaseUnits = (0, common_1.fromUiAmount)(repayUiAmount, debtDecimals);
+        const repayBaseUnits = params.repayBaseUnitsOverride ?? calculatedRepayBaseUnits;
+        // The repay CPI is always built without an embedded amount. On-chain, the
+        // handler sources the final amount from `params.repay_amount` (manager /
+        // non-swap path) or from the post-swap balance delta (swap path), then
+        // forwards it to the repay CPI via `invoke_amount_cpi` (Skip sentinel).
+        // Embedding the amount here would leak build-time estimates into a slot
+        // that must reflect runtime state.
+        //
+        // Full deleverages pass `repayBaseUnitsOverride` so the Kamino CPI and SPL
+        // transfer both use refreshed obligation debt instead of stale accounting.
+        const { prerequisiteCpis, cpis } = await ctx.lendingIx.getRepayCpiData({
+            user: ctx.user,
+            payer: ctx.payer,
+            pool: ctx.pool,
+            reserve: ctx.debtReserve.address,
+            userAccount: ctx.userAccount,
+            txId: ctx.txId,
+            ...(params.repayBaseUnitsOverride ? { baseUnitAmount: repayBaseUnits } : {}),
+        });
+        const preInstructions = await ctx.lendingIx.getPreInstructions(ctx.txId);
+        const swapRequired = params.swapContext !== undefined;
+        const assembledCpis = await this.assembleDecreaseLeverageCpis(repayBaseUnits, cpis, params.swapContext);
+        return {
+            repayUiAmount,
+            repayBaseUnits,
+            prerequisiteCpis,
+            repayCpis: cpis,
+            cpiDataGroups: assembledCpis.cpiDataGroups,
+            swapRequired,
+            preInstructions: [...preInstructions, ...assembledCpis.preInstructions],
+        };
+    }
+    /**
+     * Assemble repay CPI groups, prepending a swap group whenever the bank is
+     * configured to source the debt mint via a swap. The on-chain handler
+     * decides whether to actually invoke the swap (via `perform_swap`) based on
+     * runtime balances; building it unconditionally keeps the tx resilient when
+     * the bank's debt-token balance changes between build and send.
+     */
+    static async assembleDecreaseLeverageCpis(repayBaseUnits, repayCpis, swapContext) {
+        if (!swapContext) {
+            return { cpiDataGroups: [repayCpis], preInstructions: [] };
+        }
+        // Quote the swap for the full repay amount rather than
+        // `repay - debtHeld`, so the swap can cover the repay on its own if the
+        // bank's debt-token balance has dropped since tx build time.
+        const swapCpiData = await this.quoteDebtTopUpSwap(swapContext, repayBaseUnits);
+        return {
+            cpiDataGroups: [[swapCpiData], repayCpis],
+            preInstructions: swapCpiData.preInstructions ?? [],
+        };
+    }
+    /**
+     * Quote a swap that converts a source asset into the debt mint,
+     * covering at least `shortfall` base units.
+     */
+    static async quoteDebtTopUpSwap(ctx, shortfall) {
+        const need = BigInt(shortfall.toString());
+        if (need <= 0n) {
+            throw new Error("LeverageService.quoteDebtTopUpSwap: shortfall must be positive");
+        }
+        if (ctx.sourceBalanceBaseUnits <= 0n) {
+            throw new Error("LeverageService.quoteDebtTopUpSwap: source balance is zero");
+        }
+        const { quote } = await (0, jupiter_helpers_1.sizeExactInForMinOutput)(ctx.swap, {
+            inputMint: ctx.sourceMint,
+            outputMint: ctx.debtMint,
+            minOutputAmount: need,
+            maxInputAmount: ctx.sourceBalanceBaseUnits,
+            slippageBps: ctx.slippageBps ?? DECREASE_LEVERAGE_SWAP_SLIPPAGE_BPS,
+            safetyBufferBps: DECREASE_LEVERAGE_SWAP_BUFFER_BPS,
+            maxAccounts: DECREASE_LEVERAGE_SWAP_MAX_ACCOUNTS,
+            excludeDexes: ctx.excludeDexes,
+        });
+        return ctx.swap.getSwapCpiData(quote, ctx.swapTarget, { payer: ctx.payer });
+    }
+    /**
+     * Build a flash-loan-wrapped rebalance that moves collateral between two
+     * lending positions without decreasing any carry positions.
+     *
+     * The flow assembled here (inside a single transaction):
+     *   1. Top-level: flash-borrow source debt mint into the user's ATA.
+     *   2. CPI: repay flash-borrowed amount on source → frees collateral.
+     *   3. CPI: withdraw `collateralUiAmount` from source.
+     *   4. CPI: deposit that collateral on destination.
+     *   5. CPI: borrow destination debt mint (sized slightly above the swap
+     *      input needed to produce the flash repay, so post-slippage output
+     *      still covers it).
+     *   6. CPI: exact-in swap destination debt → source debt; the entire borrow
+     *      is consumed and worst-case output is at least the flash repay amount.
+     *   7. Top-level: flash-repay source debt mint.
+     *
+     * The exact-in over-borrow leaves a small **source-debt** excess in the
+     * token PDA's ATA after the swap; the on-chain handler sweeps this excess
+     * into the yielding bank before the top-level flash repay so exactly
+     * `flashRepayAmountBaseUnits` remains for the repay.
+     */
+    static async buildFlashRebalance(ctx, params) {
+        if (ctx.source.debtReserve.mint.mint === ctx.destination.debtReserve.mint.mint) {
+            throw new Error("LeverageService.buildFlashRebalance: source and destination debt mints must differ");
+        }
+        const sourceDebtMint = ctx.source.debtReserve.address;
+        const sourceDebtLiqMint = ctx.source.debtReserve.mint.mint;
+        const sourceDebtDecimals = ctx.source.debtReserve.mint.mintDecimals;
+        const destDebtLiqMint = ctx.destination.debtReserve.mint.mint;
+        const destDebtDecimals = ctx.destination.debtReserve.mint.mintDecimals;
+        const sourceRepayBaseUnits = await this.calcSourceRepayForWithdraw(ctx, params);
+        if (sourceRepayBaseUnits.lten(0)) {
+            throw new Error("LeverageService.buildFlashRebalance: source repay amount must be positive — use the simple rebalance path when no flash loan is needed");
+        }
+        const sourceRepayUiAmount = (0, common_1.toUiAmount)(sourceRepayBaseUnits, sourceDebtDecimals);
+        const flashFeeRate = await ctx.flashLoan.getFlashLoanFeeRate(ctx.source.pool, sourceDebtMint);
+        // For `withdrawAll`, the rebalance-token builder sends Kamino's
+        // `u64::MAX` repay sentinel — Kamino computes the obligation's
+        // *refreshed* debt at execution time, which exceeds the off-chain
+        // principal snapshot by any unrealized interest accrual. Over-borrow by
+        // 5 bps so the ATA always covers the refreshed debt; the surplus is
+        // swept into the yielding bank by the rebalance handler's dust path.
+        //
+        // For partial rebalances the builder sends `flashBorrowAmount` as the
+        // explicit repay amount — the on-chain repay matches the ATA balance
+        // exactly, so no buffer is needed (over-borrowing would just bloat the
+        // dust sweep and pay an unnecessary flash fee).
+        const SOURCE_REPAY_OVERBORROW_BPS = 5n;
+        const sourceRepayBigInt = BigInt(sourceRepayBaseUnits.toString());
+        const flashBorrowBigInt = params.withdrawAll
+            ? sourceRepayBigInt + (sourceRepayBigInt * SOURCE_REPAY_OVERBORROW_BPS) / 10000n
+            : sourceRepayBigInt;
+        const flashFeeBigInt = (0, common_1.applyFeeCeil)(flashBorrowBigInt, flashFeeRate);
+        const flashRepayBigInt = flashBorrowBigInt + flashFeeBigInt;
+        const flashBorrowAmountBaseUnits = new core_1.BN(flashBorrowBigInt.toString());
+        const flashFeeBaseUnits = new core_1.BN(flashFeeBigInt.toString());
+        const flashRepayAmountBaseUnits = new core_1.BN(flashRepayBigInt.toString());
+        const reserveBorrowCapacityBaseUnits = BigInt((0, common_1.fromUiAmount)(ctx.destination.debtReserve.borrows.limit - ctx.destination.debtReserve.borrows.totalAmount, destDebtDecimals).toString());
+        // Borrow capacity is calculated from current destination collateral only —
+        // supply never moves in a debt-only rebalance.
+        const utilizationBorrowCapacityBaseUnits = await this.calcDestinationBorrowCapacityForDeposit(ctx, { ...params, collateralUiAmount: 0 });
+        const maxDestinationBorrowBaseUnits = [
+            params.maxDestinationBorrowBaseUnits,
+            reserveBorrowCapacityBaseUnits,
+            utilizationBorrowCapacityBaseUnits,
+        ]
+            .filter((amount) => amount !== undefined)
+            .reduce((min, amount) => (amount < min ? amount : min));
+        if (maxDestinationBorrowBaseUnits <= 0n) {
+            throw new Error("LeverageService.buildFlashRebalance: destination reserve has no available borrow capacity");
+        }
+        // ExactIn-sized swap: routes through the dense ExactIn graph instead of
+        // the sparser ExactOut graph (which often returns NO_ROUTES_FOUND on
+        // Jupiter). We over-borrow slightly so the worst-case post-slippage
+        // output still covers `flashRepayBigInt`; the post-swap source-debt
+        // excess is swept on-chain into the yielding bank.
+        const { quote: swapQuote } = await (0, jupiter_helpers_1.sizeExactInForMinOutput)(ctx.swap, {
+            inputMint: destDebtLiqMint,
+            outputMint: sourceDebtLiqMint,
+            minOutputAmount: flashRepayBigInt,
+            maxInputAmount: maxDestinationBorrowBaseUnits,
+            slippageBps: params.swapSlippageBps ?? 15,
+            safetyBufferBps: params.swapBufferBps ?? 5,
+            maxAccounts: FLASH_REBALANCE_SWAP_MAX_ACCOUNTS,
+        });
+        // Split the quote's below-par gap into market basis (oracle-fair cross
+        // rate vs 1:1) and execution cost (quote vs that fair rate — route fees
+        // + price impact), and bound each independently. The $1-pinned on-chain
+        // books charge the *whole* gap to the token at conversion time, but only
+        // the execution component is permanently lost; the basis component is
+        // mark-to-market that reverses on unwind if the basis persists.
+        if (params.maxSwapCostBps !== undefined || params.maxMarketBasisBps !== undefined) {
+            const [sourcePrices, destPrices] = await Promise.all([
+                new reservesManager_1.ReservesManager(ctx.source.supplyReserve, ctx.source.debtReserve, ctx.environment).prices(),
+                new reservesManager_1.ReservesManager(ctx.destination.supplyReserve, ctx.destination.debtReserve, ctx.environment).prices(),
+            ]);
+            const fairOutPerIn = destPrices.debt.realtimePrice / sourcePrices.debt.realtimePrice;
+            if (!Number.isFinite(fairOutPerIn) || fairOutPerIn <= 0) {
+                throw new Error(`LeverageService.buildFlashRebalance: invalid oracle prices for swap cost check ` +
+                    `(source=${sourcePrices.debt.realtimePrice} dest=${destPrices.debt.realtimePrice})`);
+            }
+            const inUi = Number(swapQuote.inputAmount) / Math.pow(10, destDebtDecimals);
+            const outUi = Number(swapQuote.outputAmount) / Math.pow(10, sourceDebtDecimals);
+            const executionCostBps = (1 - outUi / inUi / fairOutPerIn) * 10000;
+            const marketBasisBps = (1 - fairOutPerIn) * 10000;
+            if (params.maxSwapCostBps !== undefined && executionCostBps > params.maxSwapCostBps) {
+                throw new FlashRebalanceSwapCostExceededError("execution-cost", executionCostBps, marketBasisBps, params.maxSwapCostBps, swapQuote.inputAmount, swapQuote.outputAmount);
+            }
+            if (params.maxMarketBasisBps !== undefined &&
+                Math.abs(marketBasisBps) > params.maxMarketBasisBps) {
+                throw new FlashRebalanceSwapCostExceededError("market-basis", executionCostBps, marketBasisBps, params.maxMarketBasisBps, swapQuote.inputAmount, swapQuote.outputAmount);
+            }
+        }
+        const swapCpi = await ctx.swap.getSwapCpiData(swapQuote, ctx.user, { payer: ctx.payer });
+        const destinationBorrowBaseUnits = new core_1.BN(swapQuote.inputAmount.toString());
+        const destinationBorrowUiAmount = (0, common_1.toUiAmount)(destinationBorrowBaseUnits, destDebtDecimals);
+        // Build the CPI bundles serially in execution order. The LP instruction
+        // clients track reserve registrations per-obligation-per-txId; each
+        // bundle's `getRefreshCpisIfNeeded` sees the cached reserves registered
+        // by earlier calls on the same obligation. Running these in parallel
+        // (Promise.all) would interleave non-deterministically and could cause
+        // the later op's refresh to miss a reserve.
+        //
+        // Repay is built with NO uiAmount → the CPI data is a Skip sentinel.
+        // On-chain, the rebalance_token handler fills the amount from
+        // `flash_cpis.repay_amount` via `invoke_amount_cpi`, keeping the repay
+        // amount authoritative from one top-level param instead of embedded in
+        // a CPI we can't easily update after a quote refresh.
+        const sourceRepay = await ctx.source.lendingIx.getRepayCpiData({
+            user: ctx.user,
+            payer: ctx.payer,
+            pool: ctx.source.pool,
+            reserve: sourceDebtMint,
+            userAccount: ctx.source.userAccount,
+            txId: ctx.txId,
+        });
+        // For a full repay the source debt row is removed from the obligation before
+        // the destination borrow's RefreshObligation runs. Flag it now so that CPI's
+        // accounts are built with 0 borrows; otherwise klend rejects the mismatched
+        // account count with InvalidAccountInput (error 6006).
+        // Partial rebalances leave the debt row intact — do not mark.
+        if (params.withdrawAll) {
+            ctx.source.lendingIx.markObligationDebtCleared(ctx.txId, ctx.source.userAccount, sourceDebtMint);
+        }
+        const destBorrow = await ctx.destination.lendingIx.getInitBorrowPositionCpiBundle({
+            user: ctx.user,
+            payer: ctx.payer,
+            pool: ctx.destination.pool,
+            reserve: ctx.destination.debtReserve.address,
+            userAccount: ctx.destination.userAccount,
+            uiAmount: destinationBorrowUiAmount,
+            txId: ctx.txId,
+        }, ctx.destination.supplyReserve.address);
+        // The flash borrow/repay use the payer (a real top-level signer) as
+        // `userTransferAuthority` because `ctx.user` (the obligation owner) is
+        // typically a PDA and can't sign at the top level. The borrowed liquidity
+        // still flows into the obligation owner's source-debt ATA — Kamino
+        // requires the borrow's `userDestinationLiquidity` to equal the repay's
+        // `userSourceLiquidity`, so both reference the same ATA. The on-chain
+        // rebalance handler grants the payer SPL Approve over that ATA at the
+        // end so the top-level flash repay's transfer can settle via delegation.
+        const userSourceDebtAta = await (0, common_1.getAtaAddress)(sourceDebtLiqMint, ctx.user, ctx.source.debtReserve.mint.mintTokenProgram);
+        const flashBorrowIx = await ctx.flashLoan.getFlashBorrowIx({
+            user: ctx.payer,
+            pool: ctx.source.pool,
+            reserve: sourceDebtMint,
+            amountBaseUnits: flashBorrowAmountBaseUnits,
+            destinationAta: userSourceDebtAta,
+        });
+        const sourceIx = ctx.source.lendingIx;
+        const destIx = ctx.destination.lendingIx;
+        const sourcePreInstructions = await sourceIx.getPreInstructions(ctx.txId);
+        const lendingPreInstructions = sourceIx === destIx
+            ? sourcePreInstructions
+            : [...sourcePreInstructions, ...(await destIx.getPreInstructions(ctx.txId))];
+        // Lending-platform pre-instructions must come first (they prepare reserve
+        // state the inner CPIs depend on). Swap-driven pre-instructions
+        // (e.g. createATA for intermediate-mint hops in a Jupiter route) ride
+        // immediately after — both must precede the host's other ATA setup so
+        // they're in scope by the time the rebalance CPI dispatches the swap.
+        const swapPreInstructions = swapCpi.preInstructions ?? [];
+        const preInstructions = [...lendingPreInstructions, ...swapPreInstructions];
+        const postSuccessCacheInvalidations = [
+            ...destBorrow.postSuccessCacheInvalidations,
+            ...(swapCpi.postSuccessCacheInvalidations ?? []),
+        ];
+        return {
+            flashBorrowAmountBaseUnits,
+            flashRepayAmountBaseUnits,
+            flashFeeBaseUnits,
+            sourceRepayUiAmount,
+            destinationBorrowUiAmount,
+            flashBorrowIx,
+            sourceRepayCpis: [...sourceRepay.prerequisiteCpis, ...sourceRepay.cpis],
+            destinationBorrowCpis: [...destBorrow.prerequisiteCpis, ...destBorrow.cpis],
+            swapCpis: [swapCpi],
+            preInstructions,
+            postSuccessCacheInvalidations,
+        };
+    }
+    /**
+     * Build the top-level flash-repay instruction for a previously-built flash
+     * rebalance, given the final transaction index of its `flashBorrowIx`.
+     *
+     * Split from {@link buildFlashRebalance} because `borrowIxIndex` depends on
+     * the caller's full tx layout (pre-instructions + heap frame + ATA creations
+     * + flash-borrow position), which in turn depends on the ATA list derived
+     * from the plan's `remainingAccounts` — a chicken-and-egg the caller resolves
+     * by assembling the preamble before calling this.
+     */
+    static async buildFlashRepayIx(ctx, plan, borrowIxIndex) {
+        // The payer (top-level signer) authorizes the repay. Kamino enforces
+        // that the borrow's `userDestinationLiquidity` matches the repay's
+        // `userSourceLiquidity` — both must reference the obligation-owner's
+        // source-debt ATA — so we explicitly route the repay through that ATA
+        // rather than letting it default to the payer's. The on-chain
+        // rebalance handler grants the payer SPL Approve over this ATA before
+        // returning, so the top-level repay's transfer settles via delegation.
+        const userSourceDebtAta = await (0, common_1.getAtaAddress)(ctx.source.debtReserve.mint.mint, ctx.user, ctx.source.debtReserve.mint.mintTokenProgram);
+        return ctx.flashLoan.getFlashRepayIx({
+            user: ctx.payer,
+            pool: ctx.source.pool,
+            reserve: ctx.source.debtReserve.address,
+            amountBaseUnits: plan.flashBorrowAmountBaseUnits,
+            borrowIxIndex,
+            userSourceLiquidity: userSourceDebtAta,
+        });
+    }
+    static async calcSourceRepayForWithdraw(ctx, params) {
+        const manager = new lendingPositionManager_1.LendingPositionManager(ctx.source.lendingIx.data, ctx.source.pool, ctx.source.userAccount, ctx.source.supplyReserve, ctx.source.debtReserve, ctx.environment);
+        if (params.withdrawAll) {
+            const { debtUiAmount } = await manager.getLendingPositionAmounts();
+            return (0, common_1.fromUiAmount)(debtUiAmount, ctx.source.debtReserve.mint.mintDecimals);
+        }
+        const debtChangeUi = await manager.calcDebtChangeAmountForCollateralWithdrawal(params.collateralUiAmount, params.sourceTargetUtilizationRateBps);
+        // `calcDebtChangeAmountForCollateralWithdrawal` returns a signed UI delta:
+        // negative → repay, positive → (under-leveraged) borrow. The flash path is
+        // only relevant for the repay case.
+        const repayUi = Math.max(0, -debtChangeUi);
+        return (0, common_1.fromUiAmount)(repayUi, ctx.source.debtReserve.mint.mintDecimals);
+    }
+    static async calcDestinationBorrowCapacityForDeposit(ctx, params) {
+        if (params.destinationMaxUtilizationRateBps === undefined) {
+            return undefined;
+        }
+        const manager = new lendingPositionManager_1.LendingPositionManager(ctx.destination.lendingIx.data, ctx.destination.pool, ctx.destination.userAccount, ctx.destination.supplyReserve, ctx.destination.debtReserve, ctx.environment);
+        const current = await manager.getLendingPositionAmounts();
+        const reserves = new reservesManager_1.ReservesManager(ctx.destination.supplyReserve, ctx.destination.debtReserve, ctx.environment);
+        const debtAdjustmentUsd = await reserves.calcDebtAdjustmentUsd(current.supplyUiAmount + params.collateralUiAmount, current.debtUiAmount, params.destinationMaxUtilizationRateBps, { positionChangeMode: "debtOnly" });
+        const prices = await reserves.prices();
+        if (debtAdjustmentUsd <= 0) {
+            return 0n;
+        }
+        const debtUiAmount = debtAdjustmentUsd / prices.debt.realtimePrice;
+        return BigInt((0, common_1.fromUiAmount)(debtUiAmount, ctx.destination.debtReserve.mint.mintDecimals).toString());
+    }
+}
+exports.LeverageService = LeverageService;