@kamino-finance/klend-sdk 4.0.2 → 5.0.0

package/src/classes/action.ts

@@ -15,6 +15,7 @@ import {
   NATIVE_MINT,
   TOKEN_PROGRAM_ID,
   createCloseAccountInstruction,
+  createSyncNativeInstruction,
 } from '@solana/spl-token';
 import BN from 'bn.js';
 import Decimal from 'decimal.js';
@@ -47,7 +48,6 @@ import {
   buildComputeBudgetIx,
   createAssociatedTokenAccountIdempotentInstruction,
   ObligationType,
-  syncNative,
   U64_MAX,
   referrerTokenStatePda,
   userMetadataPda,
@@ -1043,14 +1043,14 @@ export class KaminoAction {
     kaminoMarket: KaminoMarket,
     currentSlot: number = 0
   ) {
-    const { axn, createAtasIxns } = await KaminoAction.initializeWithdrawReferrerFees(
+    const { axn, createAtaIxs } = await KaminoAction.initializeWithdrawReferrerFees(
       tokenMint,
       owner,
       kaminoMarket,
       currentSlot
     );
 
-    axn.preTxnIxs.push(...createAtasIxns);
+    axn.preTxnIxs.push(...createAtaIxs);
     axn.preTxnIxsLabels.push(`createAtasIxs[${axn.userTokenAccountAddress.toString()}]`);
 
     axn.addRefreshReserveIxs([axn.reserve.address]);
@@ -2445,70 +2445,57 @@ export class KaminoAction {
     }
 
     if ((action === 'withdraw' || action === 'borrow' || action === 'redeem') && !this.mint.equals(WRAPPED_SOL_MINT)) {
-      const userTokenAccountInfo = await this.kaminoMarket.getConnection().getAccountInfo(this.userTokenAccountAddress);
-
-      if (!userTokenAccountInfo) {
-        const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
-          this.owner,
-          this.reserve.getLiquidityMint(),
-          this.owner,
-          this.reserve.getLiquidityTokenProgram(),
-          this.userTokenAccountAddress
-        );
+      const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+        this.owner,
+        this.reserve.getLiquidityMint(),
+        this.owner,
+        this.reserve.getLiquidityTokenProgram(),
+        this.userTokenAccountAddress
+      );
 
-        if (this.positions === POSITION_LIMIT) {
-          this.preTxnIxs.push(createUserTokenAccountIx);
-          this.preTxnIxsLabels.push(`CreateLiquidityUserAta[${this.owner}]`);
-        } else {
-          this.setupIxs.unshift(createUserTokenAccountIx);
-          this.setupIxsLabels.unshift(`CreateLiquidityUserAta[${this.owner}]`);
-        }
+      if (this.positions === POSITION_LIMIT) {
+        this.preTxnIxs.push(createUserTokenAccountIx);
+        this.preTxnIxsLabels.push(`CreateLiquidityUserAta[${this.owner}]`);
+      } else {
+        this.setupIxs.unshift(createUserTokenAccountIx);
+        this.setupIxsLabels.unshift(`CreateLiquidityUserAta[${this.owner}]`);
       }
     }
 
     if (action === 'liquidate') {
-      const userTokenAccountInfo = await this.kaminoMarket.getConnection().getAccountInfo(this.userTokenAccountAddress);
-
       if (!this.outflowReserve) {
         throw new Error(`Outflow reserve state not found ${this.mint}`);
       }
 
-      if (!userTokenAccountInfo) {
-        const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
-          this.owner,
-          this.outflowReserve.getLiquidityMint(),
-          this.owner,
-          this.outflowReserve.getLiquidityTokenProgram(),
-          this.userTokenAccountAddress
-        );
-        if (this.positions === POSITION_LIMIT && this.mint.equals(WRAPPED_SOL_MINT)) {
-          this.preTxnIxs.push(createUserTokenAccountIx);
-          this.preTxnIxsLabels.push(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
-        } else {
-          this.setupIxs.unshift(createUserTokenAccountIx);
-          this.setupIxsLabels.unshift(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
-        }
+      const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+        this.owner,
+        this.outflowReserve.getLiquidityMint(),
+        this.owner,
+        this.outflowReserve.getLiquidityTokenProgram(),
+        this.userTokenAccountAddress
+      );
+      if (this.positions === POSITION_LIMIT && this.mint.equals(WRAPPED_SOL_MINT)) {
+        this.preTxnIxs.push(createUserTokenAccountIx);
+        this.preTxnIxsLabels.push(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
+      } else {
+        this.setupIxs.unshift(createUserTokenAccountIx);
+        this.setupIxsLabels.unshift(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
       }
 
-      const userCollateralAccountInfo = await this.kaminoMarket
-        .getConnection()
-        .getAccountInfo(this.userCollateralAccountAddress);
-      if (!userCollateralAccountInfo) {
-        const [, createUserCollateralAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
-          this.owner,
-          this.outflowReserve.getCTokenMint(),
-          this.owner,
-          TOKEN_PROGRAM_ID,
-          this.userCollateralAccountAddress
-        );
+      const [, createUserCollateralAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+        this.owner,
+        this.outflowReserve.getCTokenMint(),
+        this.owner,
+        TOKEN_PROGRAM_ID,
+        this.userCollateralAccountAddress
+      );
 
-        if (this.positions === POSITION_LIMIT && this.mint.equals(WRAPPED_SOL_MINT)) {
-          this.preTxnIxs.push(createUserCollateralAccountIx);
-          this.preTxnIxsLabels.push(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
-        } else {
-          this.setupIxs.unshift(createUserCollateralAccountIx);
-          this.setupIxsLabels.unshift(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
-        }
+      if (this.positions === POSITION_LIMIT && this.mint.equals(WRAPPED_SOL_MINT)) {
+        this.preTxnIxs.push(createUserCollateralAccountIx);
+        this.preTxnIxsLabels.push(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
+      } else {
+        this.setupIxs.unshift(createUserCollateralAccountIx);
+        this.setupIxsLabels.unshift(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
       }
 
       if (!this.additionalTokenAccountAddress) {
@@ -2547,43 +2534,32 @@ export class KaminoAction {
     }
 
     if (action === 'withdraw' || action === 'mint' || action === 'deposit' || action === 'repayAndWithdraw') {
-      const userTokenAccountInfo = await this.kaminoMarket.getConnection().getAccountInfo(this.userTokenAccountAddress);
-
-      // TODO: Might need to remove this
-      if (!userTokenAccountInfo) {
-        const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
-          this.owner,
-          this.reserve.getLiquidityMint(),
-          this.owner,
-          this.reserve.getLiquidityTokenProgram(),
-          this.userTokenAccountAddress
-        );
-        this.preTxnIxs.push(createUserTokenAccountIx);
-        this.preTxnIxsLabels.push(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
-      }
+      const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+        this.owner,
+        this.reserve.getLiquidityMint(),
+        this.owner,
+        this.reserve.getLiquidityTokenProgram(),
+        this.userTokenAccountAddress
+      );
+      this.preTxnIxs.push(createUserTokenAccountIx);
+      this.preTxnIxsLabels.push(`CreateUserAta[${this.userTokenAccountAddress.toBase58()}]`);
     }
     if (action === 'mint') {
-      const userCollateralAccountInfo = await this.kaminoMarket
-        .getConnection()
-        .getAccountInfo(this.userCollateralAccountAddress);
-
-      if (!userCollateralAccountInfo) {
-        const collateralMintPubkey = this.reserve.getCTokenMint();
-        const [, createUserCollateralAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
-          this.owner,
-          collateralMintPubkey,
-          this.owner,
-          TOKEN_PROGRAM_ID,
-          this.userCollateralAccountAddress
-        );
+      const collateralMintPubkey = this.reserve.getCTokenMint();
+      const [, createUserCollateralAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+        this.owner,
+        collateralMintPubkey,
+        this.owner,
+        TOKEN_PROGRAM_ID,
+        this.userCollateralAccountAddress
+      );
 
-        if (this.positions === POSITION_LIMIT && this.mint.equals(WRAPPED_SOL_MINT)) {
-          this.preTxnIxs.push(createUserCollateralAccountIx);
-          this.preTxnIxsLabels.push(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
-        } else {
-          this.setupIxs.unshift(createUserCollateralAccountIx);
-          this.setupIxsLabels.unshift(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
-        }
+      if (this.positions === POSITION_LIMIT && this.mint.equals(WRAPPED_SOL_MINT)) {
+        this.preTxnIxs.push(createUserCollateralAccountIx);
+        this.preTxnIxsLabels.push(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
+      } else {
+        this.setupIxs.unshift(createUserCollateralAccountIx);
+        this.setupIxsLabels.unshift(`CreateCollateralUserAta[${this.userCollateralAccountAddress.toString()}]`);
       }
     }
   }
@@ -2661,7 +2637,7 @@ export class KaminoAction {
       TOKEN_PROGRAM_ID
     );
 
-    const syncIx = syncNative(userTokenAccountAddress);
+    const syncIx = createSyncNativeInstruction(userTokenAccountAddress);
     if (userWSOLAccountInfo) {
       if (sendAction) {
         preIxs.push(syncIx);
@@ -2801,12 +2777,12 @@ export class KaminoAction {
       throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress().toBase58()}`);
     }
 
-    const { atas, createAtasIxns } = await getAtasWithCreateIxnsIfMissing(
-      kaminoMarket.getConnection(),
-      owner,
-      [reserve.getLiquidityMint()],
-      [reserve.getLiquidityTokenProgram()]
-    );
+    const { atas, createAtaIxs } = await getAtasWithCreateIxnsIfMissing(kaminoMarket.getConnection(), owner, [
+      {
+        mint: reserve.getLiquidityMint(),
+        tokenProgram: reserve.getLiquidityTokenProgram(),
+      },
+    ]);
 
     const userTokenAccountAddress = atas[0];
 
@@ -2830,7 +2806,7 @@ export class KaminoAction {
         undefined,
         undefined
       ),
-      createAtasIxns,
+      createAtaIxs,
     };
   }
 
@@ -2867,7 +2843,7 @@ export class KaminoAction {
     owner: PublicKey,
     kaminoObligation: KaminoObligation | null,
     referrer: PublicKey
-  ) {
+  ): Promise<PublicKey> {
     let referrerKey = referrer;
     if (!referrer || referrer.equals(PublicKey.default)) {
       if (kaminoObligation === null) {
@@ -2881,4 +2857,22 @@ export class KaminoAction {
     }
     return referrerKey;
   }
+
+  public static actionToIxs(action: KaminoAction): Array<TransactionInstruction> {
+    const ixs: TransactionInstruction[] = [...action.setupIxs];
+    ixs.push(...KaminoAction.actionToLendingIxs(action));
+    ixs.push(...action.cleanupIxs);
+    return ixs;
+  }
+
+  public static actionToLendingIxs(action: KaminoAction): Array<TransactionInstruction> {
+    const ixs: TransactionInstruction[] = [];
+    for (let i = 0; i < action.lendingIxs.length; i++) {
+      ixs.push(action.lendingIxs[i]);
+      if (i !== action.lendingIxs.length - 1) {
+        ixs.push(...action.inBetweenIxs);
+      }
+    }
+    return ixs;
+  }
 }

package/src/classes/obligation.ts

@@ -305,6 +305,15 @@ export class KaminoObligation {
     return this.refreshedStats.netAccountValue;
   }
 
+  /**
+   * Get the loan to value and liquidation loan to value for a collateral token reserve as ratios, accounting for the obligation elevation group if it is active
+   * @param market
+   * @param reserve
+   */
+  public getLtvForReserve(market: KaminoMarket, reserve: KaminoReserve): { maxLtv: Decimal; liquidationLtv: Decimal } {
+    return KaminoObligation.getLtvForReserve(market, reserve, this.state.elevationGroup);
+  }
+
   /**
    * @returns the potential elevation groups the obligation qualifies for
    */
@@ -807,12 +816,12 @@ export class KaminoObligation {
     return borrowLimit.div(userTotalDeposit);
   }
 
-  /* 
-    How much of a given token can a user borrow extra given an elevation group, 
+  /*
+    How much of a given token can a user borrow extra given an elevation group,
     regardless of caps and liquidity or assuming infinite liquidity and infinite caps,
     until it hits max LTV.
 
-    This is purely a function about the borrow power of an obligation, 
+    This is purely a function about the borrow power of an obligation,
     not a reserve-specific, caps-specific, liquidity-specific function.
 
     * @param market - The KaminoMarket instance.
@@ -890,7 +899,7 @@ export class KaminoObligation {
     return Decimal.max(new Decimal(0), maxBorrowAmount);
   }
 
-  /* 
+  /*
     How much of a given token can a user borrow extra given an elevation group,
     and a specific reserve, until it hits max LTV and given available liquidity and caps.
 
@@ -924,7 +933,7 @@ export class KaminoObligation {
     }
   }
 
-  /* 
+  /*
     Returns true if the loan is eligible for the elevation group, including for the default one.
     * @param market - The KaminoMarket object representing the market.
     * @param slot - The slot number of the loan.
@@ -979,7 +988,7 @@ export class KaminoObligation {
     return isEligibleBasedOnLtv;
   }
 
-  /* 
+  /*
     Returns all elevation groups for a given obligation, except the default one
     * @param market - The KaminoMarket instance.
     * @returns An array of ElevationGroupDescription objects representing the elevation groups for the obligation.

package/src/classes/reserve.ts

@@ -20,7 +20,7 @@ import {
   TokenOracleData,
   U64_MAX,
 } from '../utils';
-import { ReserveDataType, ReserveFarmInfo, ReserveRewardYield, ReserveStatus } from './shared';
+import { FeeCalculation, Fees, ReserveDataType, ReserveFarmInfo, ReserveRewardYield, ReserveStatus } from './shared';
 import { Reserve, ReserveFields } from '../idl_codegen/accounts';
 import { BorrowRateCurve, CurvePointFields, ReserveConfig, UpdateConfigMode } from '../idl_codegen/types';
 import { calculateAPYFromAPR, getBorrowRate, lamportsToNumberDecimal, parseTokenSymbol, positiveOrZero } from './utils';
@@ -642,6 +642,53 @@ export class KaminoReserve {
     return this.state.collateral.mintPubkey;
   }
 
+  calculateFees(
+    amountLamports: Decimal,
+    borrowFeeRate: Decimal,
+    feeCalculation: FeeCalculation,
+    referralFeeBps: number,
+    hasReferrer: boolean
+  ): Fees {
+    const referralFeeRate = new Decimal(referralFeeBps).div(ONE_HUNDRED_PCT_IN_BPS);
+    if (borrowFeeRate.gt('0') && amountLamports.gt('0')) {
+      const needToAssessReferralFee = referralFeeRate.gt('0') && hasReferrer;
+      const minimumFee = new Decimal('1'); // 1 token to market owner, nothing to referrer
+
+      let borrowFeeAmount: Decimal;
+      if (feeCalculation === FeeCalculation.Exclusive) {
+        borrowFeeAmount = amountLamports.mul(borrowFeeRate);
+      } else {
+        const borrowFeeFactor = borrowFeeRate.div(borrowFeeRate.add('1'));
+        borrowFeeAmount = amountLamports.mul(borrowFeeFactor);
+      }
+      const borrowFee = Decimal.max(borrowFeeAmount, minimumFee);
+      if (borrowFee.gte(amountLamports)) {
+        throw Error('Borrow amount is too small to receive liquidity after fees');
+      }
+      const referralFee = needToAssessReferralFee
+        ? referralFeeRate.eq(1)
+          ? borrowFee
+          : borrowFee.mul(referralFeeRate).floor()
+        : new Decimal(0);
+
+      const protocolFee = borrowFee.sub(referralFee);
+
+      return { protocolFees: protocolFee, referrerFees: referralFee };
+    } else {
+      return { protocolFees: new Decimal(0), referrerFees: new Decimal(0) };
+    }
+  }
+
+  calculateFlashLoanFees(flashLoanAmountLamports: Decimal, referralFeeBps: number, hasReferrer: boolean): Fees {
+    return this.calculateFees(
+      flashLoanAmountLamports,
+      this.getFlashLoanFee(),
+      FeeCalculation.Exclusive,
+      referralFeeBps,
+      hasReferrer
+    );
+  }
+
   setBuffer(buffer: AccountInfo<Buffer> | null) {
     this.buffer = buffer;
   }

package/src/classes/shared.ts

@@ -55,3 +55,13 @@ export type ReserveFarmInfo = {
   fetched: boolean;
   farmStates: FarmState[];
 };
+
+export enum FeeCalculation {
+  Inclusive = 'Inclusive',
+  Exclusive = 'Exclusive',
+}
+
+export type Fees = {
+  protocolFees: Decimal;
+  referrerFees: Decimal;
+};

package/src/classes/vault.ts

@@ -185,11 +185,16 @@ export class KaminoVaultClient {
     const createAtasIxns: TransactionInstruction[] = [];
     const closeAtasIxns: TransactionInstruction[] = [];
     if (vaultState.tokenMint.equals(WRAPPED_SOL_MINT)) {
-      const {
-        atas: wsolAta,
-        createAtasIxns: createWsolAtaIxns,
-        closeAtasIxns: closeWsolAtaIxns,
-      } = await getAtasWithCreateIxnsIfMissing(this._connection, user, [WRAPPED_SOL_MINT], [TOKEN_PROGRAM_ID]);
+      const { atas: wsolAta, createAtaIxs: createWsolAtaIxns } = await getAtasWithCreateIxnsIfMissing(
+        this._connection,
+        user,
+        [
+          {
+            mint: WRAPPED_SOL_MINT,
+            tokenProgram: TOKEN_PROGRAM_ID,
+          },
+        ]
+      );
       createAtasIxns.push(...createWsolAtaIxns);
       const depositWsolixn = getDepositWsolIxns(
         user,
@@ -197,15 +202,14 @@ export class KaminoVaultClient {
         numberToLamportsDecimal(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil()
       );
       createAtasIxns.push(...depositWsolixn);
-      closeAtasIxns.push(...closeWsolAtaIxns);
     }
 
-    const { atas, createAtasIxns: createSharesAtaIxns } = await getAtasWithCreateIxnsIfMissing(
-      this._connection,
-      user,
-      [vaultState.sharesMint],
-      [TOKEN_PROGRAM_ID]
-    );
+    const { atas, createAtaIxs: createSharesAtaIxns } = await getAtasWithCreateIxnsIfMissing(this._connection, user, [
+      {
+        mint: vaultState.sharesMint,
+        tokenProgram: TOKEN_PROGRAM_ID,
+      },
+    ]);
     createAtasIxns.push(...createSharesAtaIxns);
 
     const userSharesAta = atas[0];
@@ -256,12 +260,12 @@ export class KaminoVaultClient {
     const vaultState = await vault.getState(this._connection);
 
     const userSharesAta = getAssociatedTokenAddress(vaultState.sharesMint, user);
-    const { atas, createAtasIxns } = await getAtasWithCreateIxnsIfMissing(
-      this._connection,
-      user,
-      [vaultState.tokenMint],
-      [TOKEN_PROGRAM_ID]
-    );
+    const { atas, createAtaIxs } = await getAtasWithCreateIxnsIfMissing(this._connection, user, [
+      {
+        mint: vaultState.tokenMint,
+        tokenProgram: TOKEN_PROGRAM_ID,
+      },
+    ]);
     const userTokenAta = atas[0];
 
     const tokensToWithdraw = shareAmount.div(await this.getTokensPerShareSingleVault(vault, slot));
@@ -329,7 +333,7 @@ export class KaminoVaultClient {
       })
     );
 
-    return [...createAtasIxns, ...withdrawIxns];
+    return [...createAtaIxs, ...withdrawIxns];
   }
 
   /**

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -1,7 +1,104 @@
 import Decimal from 'decimal.js';
-import { KaminoMarket, KaminoObligation } from '../classes';
+import { KaminoMarket, KaminoObligation, KaminoReserve, numberToLamportsDecimal } from '../classes';
 import { PublicKey } from '@solana/web3.js';
 
+export function calcRepayAmountWithSlippage(
+  kaminoMarket: KaminoMarket,
+  debtReserve: KaminoReserve,
+  currentSlot: number,
+  obligation: KaminoObligation,
+  amount: Decimal,
+  referrer: PublicKey
+): {
+  repayAmount: Decimal;
+  repayAmountLamports: Decimal;
+  flashRepayAmountLamports: Decimal;
+} {
+  const irSlippageBpsForDebt = obligation
+    .estimateObligationInterestRate(
+      kaminoMarket,
+      debtReserve,
+      obligation.state.borrows.find((borrow) => borrow.borrowReserve.equals(debtReserve.address))!,
+      currentSlot
+    )
+    .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
+  // add 0.1% to irSlippageBpsForDebt because we don't want to estimate slightly less than SC and end up not reapying enough
+  const repayAmount = amount
+    .mul(irSlippageBpsForDebt.mul(new Decimal('1.001')))
+    .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
+  const repayAmountLamports = numberToLamportsDecimal(repayAmount, debtReserve.stats.decimals);
+
+  const { flashRepayAmountLamports } = calcFlashRepayAmount({
+    reserve: debtReserve,
+    referralFeeBps: kaminoMarket.state.referralFeeBps,
+    hasReferral: !referrer.equals(PublicKey.default),
+    flashBorrowAmountLamports: repayAmountLamports,
+  });
+  return { repayAmount, repayAmountLamports, flashRepayAmountLamports };
+}
+
+export const calcFlashRepayAmount = (props: {
+  reserve: KaminoReserve;
+  referralFeeBps: number;
+  hasReferral: boolean;
+  flashBorrowAmountLamports: Decimal;
+}): {
+  flashRepayAmountLamports: Decimal;
+} => {
+  const { reserve, referralFeeBps, hasReferral, flashBorrowAmountLamports } = props;
+  const { referrerFees, protocolFees } = reserve.calculateFlashLoanFees(
+    flashBorrowAmountLamports,
+    referralFeeBps,
+    hasReferral
+  );
+  const flashRepayAmountLamports = flashBorrowAmountLamports.add(referrerFees).add(protocolFees);
+
+  return {
+    flashRepayAmountLamports,
+  };
+};
+
+export function calcMaxWithdrawCollateral(
+  kaminoMarket: KaminoMarket,
+  collReserveAddr: PublicKey,
+  debtReserveAddr: PublicKey,
+  obligation: KaminoObligation,
+  repayAmountLamports: Decimal
+) {
+  const collReserve = kaminoMarket.getReserveByAddress(collReserveAddr)!;
+  const debtReserve = kaminoMarket.getReserveByAddress(debtReserveAddr)!;
+
+  const debtOraclePx = debtReserve.getOracleMarketPrice();
+  const collOraclePx = collReserve.getOracleMarketPrice();
+  const { maxLtv: collMaxLtv } = obligation.getLtvForReserve(kaminoMarket, collReserve);
+  const debtBorrowFactor = debtReserve.getBorrowFactor();
+
+  const debtPosition = obligation.getBorrowByReserve(debtReserve.address)!;
+  const collPosition = obligation.getDepositByReserve(collReserve.address)!;
+  const initialCollValue = collPosition.amount.floor().div(collReserve.getMintFactor()).mul(collOraclePx);
+  const remainingDebtAmountLamports = debtPosition.amount.sub(repayAmountLamports);
+  const remainingDebtBfWeightedValue = remainingDebtAmountLamports.ceil().div(debtReserve.getMintFactor()).mul(debtBorrowFactor).mul(debtOraclePx);
+
+  let isClosingPosition = false;
+  if (remainingDebtAmountLamports.lte(new Decimal(0)) && obligation.getBorrows().length === 1) {
+    isClosingPosition = true;
+  }
+  const numerator = initialCollValue.mul(collMaxLtv).sub(remainingDebtBfWeightedValue);
+  const denominator = collOraclePx.mul(collMaxLtv);
+  const maxCollWithdrawAmount = numerator.div(denominator);
+  const maxCollateralWithdrawalAmountLamports = maxCollWithdrawAmount.mul(collReserve.getMintFactor()).floor();
+
+  let withdrawableCollLamports: Decimal;
+  if (isClosingPosition) {
+    // sanity check: we have extra collateral to swap, but we want to ensure we don't quote for way more than needed and get a bad px
+    const maxSwapCollLamportsWithBuffer = maxCollateralWithdrawalAmountLamports.mul('1.1');
+    withdrawableCollLamports = Decimal.min(maxSwapCollLamportsWithBuffer, collPosition.amount).floor();
+  } else {
+    withdrawableCollLamports = Decimal.max(new Decimal(0), maxCollateralWithdrawalAmountLamports);
+  }
+  return { isClosingPosition, withdrawableCollLamports };
+}
+
 export function estimateDebtRepaymentWithColl(props: {
   collAmount: Decimal; // in decimals
   priceDebtToColl: Decimal;