@kamino-finance/klend-sdk 5.0.3 → 5.0.4

package/src/classes/utils.ts

@@ -142,29 +142,6 @@ export const parseTokenSymbol = (tokenSymbol: number[]): string => {
   return String.fromCharCode(...tokenSymbol.filter((x) => x > 0));
 };
 
-export function parseZeroPaddedUtf8(utf8Array: number[]): string {
-  for (let last = utf8Array.length - 1; last >= 0; last--) {
-    const trailing_zero = utf8Array[last];
-    if (trailing_zero != 0) {
-      const encoding = new Uint8Array(last + 1);
-      for (let i = 0; i <= last; i++) {
-        encoding[i] = utf8Array[i];
-      }
-      break;
-    }
-  }
-  return new TextDecoder().decode();
-}
-
-export function renderZeroPaddedUtf8(str: string, utf8ArrayLength: number): number[] {
-  const encoding = new TextEncoder().encode(str);
-  const result = new Array<number>(utf8ArrayLength);
-  for (let i = 0; i < result.length; i++) {
-    result[i] = i < encoding.length ? encoding[i] : 0;
-  }
-  return result;
-}
-
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -213,10 +190,3 @@ export function calculateAPRFromAPY(apy: Decimal.Value) {
     .minus(1)
     .times(SLOTS_PER_YEAR);
 }
-
-export function sameLengthArrayEquals(left: Array<number>, right: Array<number>): boolean {
-  if (left.length != right.length) {
-    throw new Error(`Not same length: ${left.length} != ${left.length}`);
-  }
-  return left.every((value, index) => value === right[index]);
-}

package/src/client_kamino_manager.ts

@@ -87,7 +87,7 @@ async function main() {
 
   commands
     .command('add-asset-to-market')
-    .requiredOption('--market <string>', 'Market address to add asset to')
+    .requiredOption('--market <string>', 'Market addres to add asset to')
     .requiredOption('--mint <string>', 'Reserve liquidity token mint')
     .requiredOption('--mint-program-id <string>', 'Reserve liquidity token mint program id')
     .requiredOption('--reserve-config-path <string>', 'Path for the reserve config')

package/src/idl_codegen/accounts/LendingMarket.ts

@@ -51,8 +51,6 @@ export interface LendingMarketFields {
   /** Min net value accepted to be found in a position after any lending action in an obligation (scaled by quote currency decimals) */
   minNetValueInObligationSf: BN
   minValueSkipLiquidationLtvBfChecks: BN
-  /** Market name, zero-padded. */
-  name: Array<number>
   padding1: Array<BN>
 }
 
@@ -103,8 +101,6 @@ export interface LendingMarketJSON {
   /** Min net value accepted to be found in a position after any lending action in an obligation (scaled by quote currency decimals) */
   minNetValueInObligationSf: string
   minValueSkipLiquidationLtvBfChecks: string
-  /** Market name, zero-padded. */
-  name: Array<number>
   padding1: Array<string>
 }
 
@@ -155,8 +151,6 @@ export class LendingMarket {
   /** Min net value accepted to be found in a position after any lending action in an obligation (scaled by quote currency decimals) */
   readonly minNetValueInObligationSf: BN
   readonly minValueSkipLiquidationLtvBfChecks: BN
-  /** Market name, zero-padded. */
-  readonly name: Array<number>
   readonly padding1: Array<BN>
 
   static readonly discriminator = Buffer.from([
@@ -186,8 +180,7 @@ export class LendingMarket {
     borsh.array(borsh.u64(), 90, "elevationGroupPadding"),
     borsh.u128("minNetValueInObligationSf"),
     borsh.u64("minValueSkipLiquidationLtvBfChecks"),
-    borsh.array(borsh.u8(), 32, "name"),
-    borsh.array(borsh.u64(), 173, "padding1"),
+    borsh.array(borsh.u64(), 177, "padding1"),
   ])
 
   constructor(fields: LendingMarketFields) {
@@ -219,7 +212,6 @@ export class LendingMarket {
     this.minNetValueInObligationSf = fields.minNetValueInObligationSf
     this.minValueSkipLiquidationLtvBfChecks =
       fields.minValueSkipLiquidationLtvBfChecks
-    this.name = fields.name
     this.padding1 = fields.padding1
   }
 
@@ -295,7 +287,6 @@ export class LendingMarket {
       minNetValueInObligationSf: dec.minNetValueInObligationSf,
       minValueSkipLiquidationLtvBfChecks:
         dec.minValueSkipLiquidationLtvBfChecks,
-      name: dec.name,
       padding1: dec.padding1,
     })
   }
@@ -329,7 +320,6 @@ export class LendingMarket {
       minNetValueInObligationSf: this.minNetValueInObligationSf.toString(),
       minValueSkipLiquidationLtvBfChecks:
         this.minValueSkipLiquidationLtvBfChecks.toString(),
-      name: this.name,
       padding1: this.padding1.map((item) => item.toString()),
     }
   }
@@ -368,7 +358,6 @@ export class LendingMarket {
       minValueSkipLiquidationLtvBfChecks: new BN(
         obj.minValueSkipLiquidationLtvBfChecks
       ),
-      name: obj.name,
       padding1: obj.padding1.map((item) => new BN(item)),
     })
   }

package/src/idl_codegen/accounts/Obligation.ts

@@ -13,7 +13,10 @@ export interface ObligationFields {
   lendingMarket: PublicKey
   /** Owner authority which can borrow liquidity */
   owner: PublicKey
-  /** Deposited collateral for the obligation, unique by deposit reserve address */
+  /**
+   * TODO: Does this break the stack size when copied onto the stack, if too big?
+   * Deposited collateral for the obligation, unique by deposit reserve address
+   */
   deposits: Array<types.ObligationCollateralFields>
   /** Worst LTV for the collaterals backing the loan, represented as a percentage */
   lowestReserveDepositLiquidationLtv: BN
@@ -57,7 +60,10 @@ export interface ObligationJSON {
   lendingMarket: string
   /** Owner authority which can borrow liquidity */
   owner: string
-  /** Deposited collateral for the obligation, unique by deposit reserve address */
+  /**
+   * TODO: Does this break the stack size when copied onto the stack, if too big?
+   * Deposited collateral for the obligation, unique by deposit reserve address
+   */
   deposits: Array<types.ObligationCollateralJSON>
   /** Worst LTV for the collaterals backing the loan, represented as a percentage */
   lowestReserveDepositLiquidationLtv: string
@@ -102,7 +108,10 @@ export class Obligation {
   readonly lendingMarket: PublicKey
   /** Owner authority which can borrow liquidity */
   readonly owner: PublicKey
-  /** Deposited collateral for the obligation, unique by deposit reserve address */
+  /**
+   * TODO: Does this break the stack size when copied onto the stack, if too big?
+   * Deposited collateral for the obligation, unique by deposit reserve address
+   */
   readonly deposits: Array<types.ObligationCollateral>
   /** Worst LTV for the collaterals backing the loan, represented as a percentage */
   readonly lowestReserveDepositLiquidationLtv: BN

package/src/idl_codegen/types/UpdateLendingMarketConfigValue.ts

@@ -283,41 +283,6 @@ export class ElevationGroup {
   }
 }
 
-export type NameFields = [Array<number>]
-export type NameValue = [Array<number>]
-
-export interface NameJSON {
-  kind: "Name"
-  value: [Array<number>]
-}
-
-export class Name {
-  static readonly discriminator = 8
-  static readonly kind = "Name"
-  readonly discriminator = 8
-  readonly kind = "Name"
-  readonly value: NameValue
-
-  constructor(value: NameFields) {
-    this.value = [value[0]]
-  }
-
-  toJSON(): NameJSON {
-    return {
-      kind: "Name",
-      value: [this.value[0]],
-    }
-  }
-
-  toEncodable() {
-    return {
-      Name: {
-        _0: this.value[0],
-      },
-    }
-  }
-}
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fromDecoded(
   obj: any
@@ -358,10 +323,6 @@ export function fromDecoded(
     const val = obj["ElevationGroup"]
     return new ElevationGroup([types.ElevationGroup.fromDecoded(val["_0"])])
   }
-  if ("Name" in obj) {
-    const val = obj["Name"]
-    return new Name([val["_0"]])
-  }
 
   throw new Error("Invalid enum object")
 }
@@ -394,9 +355,6 @@ export function fromJSON(
     case "ElevationGroup": {
       return new ElevationGroup([types.ElevationGroup.fromJSON(obj.value[0])])
     }
-    case "Name": {
-      return new Name([obj.value[0]])
-    }
   }
 }
 
@@ -410,7 +368,6 @@ export function layout(property?: string) {
     borsh.struct([borsh.u128("_0")], "U128"),
     borsh.struct([borsh.publicKey("_0")], "Pubkey"),
     borsh.struct([types.ElevationGroup.layout("_0")], "ElevationGroup"),
-    borsh.struct([borsh.array(borsh.u8(), 32, "_0")], "Name"),
   ])
   if (property !== undefined) {
     return ret.replicate(property)

package/src/idl_codegen/types/UpdateLendingMarketMode.ts

@@ -417,29 +417,6 @@ export class UpdatePaddingFields {
   }
 }
 
-export interface UpdateNameJSON {
-  kind: "UpdateName"
-}
-
-export class UpdateName {
-  static readonly discriminator = 18
-  static readonly kind = "UpdateName"
-  readonly discriminator = 18
-  readonly kind = "UpdateName"
-
-  toJSON(): UpdateNameJSON {
-    return {
-      kind: "UpdateName",
-    }
-  }
-
-  toEncodable() {
-    return {
-      UpdateName: {},
-    }
-  }
-}
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fromDecoded(obj: any): types.UpdateLendingMarketModeKind {
   if (typeof obj !== "object") {
@@ -500,9 +477,6 @@ export function fromDecoded(obj: any): types.UpdateLendingMarketModeKind {
   if ("UpdatePaddingFields" in obj) {
     return new UpdatePaddingFields()
   }
-  if ("UpdateName" in obj) {
-    return new UpdateName()
-  }
 
   throw new Error("Invalid enum object")
 }
@@ -565,9 +539,6 @@ export function fromJSON(
     case "UpdatePaddingFields": {
       return new UpdatePaddingFields()
     }
-    case "UpdateName": {
-      return new UpdateName()
-    }
   }
 }
 
@@ -591,7 +562,6 @@ export function layout(property?: string) {
     borsh.struct([], "UpdateMinNetValueObligationPostAction"),
     borsh.struct([], "UpdateMinValueSkipPriorityLiqCheck"),
     borsh.struct([], "UpdatePaddingFields"),
-    borsh.struct([], "UpdateName"),
   ])
   if (property !== undefined) {
     return ret.replicate(property)

package/src/idl_codegen/types/index.ts

@@ -116,7 +116,6 @@ export type UpdateLendingMarketConfigValueKind =
   | UpdateLendingMarketConfigValue.U128
   | UpdateLendingMarketConfigValue.Pubkey
   | UpdateLendingMarketConfigValue.ElevationGroup
-  | UpdateLendingMarketConfigValue.Name
 export type UpdateLendingMarketConfigValueJSON =
   | UpdateLendingMarketConfigValue.BoolJSON
   | UpdateLendingMarketConfigValue.U8JSON
@@ -126,7 +125,6 @@ export type UpdateLendingMarketConfigValueJSON =
   | UpdateLendingMarketConfigValue.U128JSON
   | UpdateLendingMarketConfigValue.PubkeyJSON
   | UpdateLendingMarketConfigValue.ElevationGroupJSON
-  | UpdateLendingMarketConfigValue.NameJSON
 
 export { UpdateLendingMarketMode }
 
@@ -149,7 +147,6 @@ export type UpdateLendingMarketModeKind =
   | UpdateLendingMarketMode.UpdateMinNetValueObligationPostAction
   | UpdateLendingMarketMode.UpdateMinValueSkipPriorityLiqCheck
   | UpdateLendingMarketMode.UpdatePaddingFields
-  | UpdateLendingMarketMode.UpdateName
 export type UpdateLendingMarketModeJSON =
   | UpdateLendingMarketMode.UpdateOwnerJSON
   | UpdateLendingMarketMode.UpdateEmergencyModeJSON
@@ -169,7 +166,6 @@ export type UpdateLendingMarketModeJSON =
   | UpdateLendingMarketMode.UpdateMinNetValueObligationPostActionJSON
   | UpdateLendingMarketMode.UpdateMinValueSkipPriorityLiqCheckJSON
   | UpdateLendingMarketMode.UpdatePaddingFieldsJSON
-  | UpdateLendingMarketMode.UpdateNameJSON
 
 export { LastUpdate } from "./LastUpdate"
 export type { LastUpdateFields, LastUpdateJSON } from "./LastUpdate"

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -107,6 +107,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     inputAmountLamports: withdrawableCollLamports,
     inputMint: collTokenMint,
     outputMint: debtTokenMint,
+    amountDebtAtaBalance: new Decimal(0), // only used for kTokens
   };
 
   // Build the repay & withdraw collateral tx to get the number of accounts
@@ -143,6 +144,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
       inputAmountLamports: collSwapInLamports,
       inputMint: collTokenMint,
       outputMint: debtTokenMint,
+      amountDebtAtaBalance: new Decimal(0), // only used for kTokens
     },
     initialInputs: {
       debtRepayAmountLamports: repayAmountLamports,

package/src/leverage/calcs.ts

@@ -1,6 +1,15 @@
 import { PublicKey } from '@solana/web3.js';
 import Decimal from 'decimal.js';
-import { Kamino, StrategyWithAddress, TokenAmounts } from '@kamino-finance/kliquidity-sdk';
+import { collToLamportsDecimal, Kamino, StrategyWithAddress, TokenAmounts } from '@kamino-finance/kliquidity-sdk';
+import { KaminoMarket, KaminoObligation, KaminoReserve } from '../classes';
+import { getExpectedTokenBalanceAfterBorrow } from './utils';
+import {
+  AdjustLeverageCalcsResult,
+  DepositLeverageCalcsResult,
+  PriceAinBProvider,
+  WithdrawLeverageCalcsResult,
+} from './types';
+import { fuzzyEqual } from '../utils';
 
 export const toJson = (object: any): string => {
   return JSON.stringify(object, null, 2);
@@ -126,9 +135,13 @@ export async function calculateMultiplyEffects(
       isClosingPosition =
         (withdrawModeEstimatedDepositTokenWithdrawn.gte(new Decimal(deposited)) ||
           withdrawModeEstimatedBorrowTokenWithdrawn.gte(new Decimal(borrowed)) ||
-          fuzzyEq(withdrawModeEstimatedDepositTokenWithdrawn, new Decimal(deposited), closingPositionDiffTolerance) ||
-          fuzzyEq(withdrawModeEstimatedBorrowTokenWithdrawn, new Decimal(borrowed), closingPositionDiffTolerance)) &&
-        !fuzzyEq(withdrawModeEstimatedDepositTokenWithdrawn, new Decimal(0), closingPositionDiffTolerance);
+          fuzzyEqual(
+            withdrawModeEstimatedDepositTokenWithdrawn,
+            new Decimal(deposited),
+            closingPositionDiffTolerance
+          ) ||
+          fuzzyEqual(withdrawModeEstimatedBorrowTokenWithdrawn, new Decimal(borrowed), closingPositionDiffTolerance)) &&
+        !fuzzyEqual(withdrawModeEstimatedDepositTokenWithdrawn, new Decimal(0), closingPositionDiffTolerance);
 
       totalDeposited = isClosingPosition ? new Decimal(0) : deposited.sub(withdrawModeEstimatedDepositTokenWithdrawn);
       totalBorrowed = isClosingPosition ? new Decimal(0) : borrowed.sub(withdrawModeEstimatedBorrowTokenWithdrawn);
@@ -270,10 +283,6 @@ export function calcWithdrawAmounts(params: WithdrawParams): WithdrawResult {
   };
 }
 
-export const fuzzyEq = (a: Decimal.Value, b: Decimal.Value, epsilon = 0.0001) => {
-  return new Decimal(a).sub(b).abs().lte(epsilon);
-};
-
 interface UseEstimateAdjustAmountsProps {
   targetLeverage: Decimal;
   debtTokenMint: PublicKey;
@@ -463,3 +472,301 @@ export async function simulateMintKToken(
 
   return [requiredA, requiredB, actualMint];
 }
+
+export const depositLeverageCalcs = (props: {
+  depositAmount: Decimal;
+  depositTokenIsCollToken: boolean;
+  depositTokenIsSol: boolean;
+  priceDebtToColl: Decimal;
+  targetLeverage: Decimal;
+  slippagePct: Decimal;
+  flashLoanFee: Decimal;
+}): DepositLeverageCalcsResult => {
+  // Initialize local variables from the props object
+  const {
+    depositAmount,
+    depositTokenIsCollToken,
+    depositTokenIsSol,
+    priceDebtToColl,
+    targetLeverage,
+    slippagePct,
+    flashLoanFee,
+  } = props;
+  const slippage = slippagePct.div('100');
+
+  const initDepositInSol = depositTokenIsSol ? depositAmount : new Decimal(0);
+
+  // Core logic
+  if (depositTokenIsCollToken) {
+    const y = targetLeverage.mul(priceDebtToColl);
+    const x = flashLoanFee.add('1').mul(slippage.add('1')).div(priceDebtToColl);
+    const finalColl = depositAmount.mul(x).div(x.sub(targetLeverage.sub('1').div(y)));
+    const debt = finalColl.sub(depositAmount).mul(x);
+    const flashBorrowColl = finalColl.sub(depositAmount).mul(flashLoanFee.add('1'));
+
+    return {
+      flashBorrowInCollToken: flashBorrowColl,
+      initDepositInSol,
+      debtTokenToBorrow: debt,
+      collTokenToDeposit: finalColl,
+      swapDebtTokenIn: debt,
+      swapCollTokenExpectedOut: finalColl.sub(depositAmount),
+      flashBorrowInDebtTokenKtokenOnly: new Decimal(0),
+      singleSidedDepositKtokenOnly: new Decimal(0),
+      requiredCollateralKtokenOnly: new Decimal(0),
+    };
+  } else {
+    const y = targetLeverage.mul(priceDebtToColl);
+    const x = flashLoanFee.add('1').mul(slippage.add('1')).div(priceDebtToColl);
+    const finalColl = depositAmount.div(x.sub(targetLeverage.sub('1').div(y)));
+    const flashBorrowColl = finalColl.mul(flashLoanFee.add('1'));
+    const debt = targetLeverage.sub('1').mul(finalColl).div(y);
+
+    return {
+      flashBorrowInCollToken: flashBorrowColl,
+      initDepositInSol,
+      debtTokenToBorrow: debt,
+      collTokenToDeposit: finalColl,
+      swapDebtTokenIn: debt.add(depositAmount),
+      swapCollTokenExpectedOut: finalColl,
+      flashBorrowInDebtTokenKtokenOnly: new Decimal(0),
+      singleSidedDepositKtokenOnly: new Decimal(0),
+      requiredCollateralKtokenOnly: new Decimal(0),
+    };
+  }
+};
+
+export const depositLeverageKtokenCalcs = async (props: {
+  kamino: Kamino;
+  strategy: StrategyWithAddress;
+  debtTokenMint: PublicKey;
+  depositAmount: Decimal;
+  depositTokenIsCollToken: boolean;
+  depositTokenIsSol: boolean;
+  priceDebtToColl: Decimal;
+  targetLeverage: Decimal;
+  slippagePct: Decimal;
+  flashLoanFee: Decimal;
+  priceAinB: PriceAinBProvider;
+  strategyHoldings?: TokenAmounts;
+}): Promise<DepositLeverageCalcsResult> => {
+  const {
+    kamino,
+    strategy,
+    debtTokenMint,
+    depositAmount,
+    depositTokenIsCollToken,
+    depositTokenIsSol,
+    priceDebtToColl,
+    targetLeverage,
+    slippagePct,
+    flashLoanFee,
+    priceAinB,
+    strategyHoldings,
+  } = props;
+  const initDepositInSol = depositTokenIsSol ? depositAmount : new Decimal(0);
+  const slippage = slippagePct.div('100');
+
+  let flashBorrowInDebtToken: Decimal;
+  let collTokenToDeposit: Decimal;
+  let debtTokenToBorrow: Decimal;
+
+  if (depositTokenIsCollToken) {
+    const x = slippage.add('1').div(priceDebtToColl);
+    const y = flashLoanFee.add('1').mul(priceDebtToColl);
+    const z = targetLeverage.mul(y).div(targetLeverage.sub(1));
+    flashBorrowInDebtToken = depositAmount.div(z.minus(new Decimal(1).div(x)));
+    collTokenToDeposit = depositAmount.add(flashBorrowInDebtToken.div(x));
+    debtTokenToBorrow = flashBorrowInDebtToken.mul(new Decimal(1).add(flashLoanFee));
+
+    return {
+      flashBorrowInCollToken: new Decimal(0),
+      initDepositInSol,
+      collTokenToDeposit,
+      debtTokenToBorrow,
+      swapDebtTokenIn: new Decimal(0),
+      swapCollTokenExpectedOut: new Decimal(0),
+      flashBorrowInDebtTokenKtokenOnly: flashBorrowInDebtToken,
+      requiredCollateralKtokenOnly: collTokenToDeposit.sub(depositAmount), // Assuming netValue is requiredCollateral, adjust as needed
+      singleSidedDepositKtokenOnly: flashBorrowInDebtToken,
+    };
+  } else {
+    const y = targetLeverage.mul(priceDebtToColl);
+    // although we will only swap ~half of the debt token, we account for the slippage on the entire amount as we are working backwards from the minimum collateral and do not know the exact swap proportion in advance
+    // This also allows for some variation in the pool ratios between calculation + submitting the tx
+    const x = flashLoanFee.add('1').mul(slippage.add('1')).div(priceDebtToColl);
+    // Calculate the amount of collateral tokens we will deposit in order to achieve the desired leverage after swapping a portion of the debt token and flash loan fees
+    const finalColl = depositAmount.div(x.sub(targetLeverage.sub('1').div(y)));
+    // Calculate how many A and B tokens we will need to actually mint the desired amount of ktoken collateral
+    // The actual amount of ktokens received may be less than the finalColl due to smart proportional contract logic
+    // So we use the actualColl as the amount we will deposit
+    const [estimatedA, estimatedB, actualColl] = await simulateMintKToken(
+      kamino!,
+      strategy!,
+      finalColl,
+      strategyHoldings
+    );
+    const pxAinB = await priceAinB(strategy!.strategy.tokenAMint, strategy!.strategy.tokenBMint);
+    const isTokenADeposit = strategy.strategy.tokenAMint.equals(debtTokenMint);
+    // Calculate the amount we need to flash borrow by combining value of A and B into the debt token
+    const singleSidedDepositAmount = isTokenADeposit
+      ? estimatedA.add(estimatedB.div(pxAinB))
+      : estimatedB.add(estimatedA.mul(pxAinB));
+
+    // Add slippage to the entire amount, add flash loan fee to part we will flash borrow
+    flashBorrowInDebtToken = singleSidedDepositAmount
+      .div(new Decimal('1').sub(slippage))
+      .sub(depositAmount)
+      .div(new Decimal('1').sub(flashLoanFee));
+    // Deposit the min ktoken amount we calculated at the beginning
+    // Any slippage will be left in the user's wallet as ktokens
+    collTokenToDeposit = actualColl;
+    debtTokenToBorrow = flashBorrowInDebtToken.div(new Decimal('1').sub(flashLoanFee));
+    // Add slippage to ensure we try to swap/deposit as much as possible after flash loan fees
+    const singleSidedDeposit = singleSidedDepositAmount.div(new Decimal('1').sub(slippage));
+
+    return {
+      flashBorrowInCollToken: new Decimal(0),
+      initDepositInSol,
+      collTokenToDeposit,
+      debtTokenToBorrow,
+      swapDebtTokenIn: new Decimal(0),
+      swapCollTokenExpectedOut: new Decimal(0),
+      flashBorrowInDebtTokenKtokenOnly: flashBorrowInDebtToken,
+      singleSidedDepositKtokenOnly: singleSidedDeposit,
+      requiredCollateralKtokenOnly: collTokenToDeposit, // Assuming collTokenToDeposit is requiredCollateral, adjust as needed
+    };
+  }
+};
+
+export function withdrawLeverageCalcs(
+  market: KaminoMarket,
+  collReserve: KaminoReserve,
+  debtReserve: KaminoReserve,
+  priceCollToDebt: Decimal,
+  withdrawAmount: Decimal,
+  deposited: Decimal,
+  borrowed: Decimal,
+  currentSlot: number,
+  isClosingPosition: boolean,
+  selectedTokenIsCollToken: boolean,
+  selectedTokenMint: PublicKey,
+  obligation: KaminoObligation,
+  flashLoanFee: Decimal,
+  slippagePct: Decimal
+): WithdrawLeverageCalcsResult {
+  // 1. Calculate coll_amount and debt_amount to repay such that we maintain leverage and we withdraw to
+  // the wallet `amountInDepositTokenToWithdrawToWallet` amount of collateral token
+  // We need to withdraw withdrawAmountInDepositToken coll tokens
+  // and repay repayAmountInBorrowToken debt tokens
+  const { adjustDepositPosition: withdrawAmountCalculated, adjustBorrowPosition: initialRepayAmount } =
+    isClosingPosition
+      ? { adjustDepositPosition: deposited, adjustBorrowPosition: borrowed }
+      : calcWithdrawAmounts({
+          collTokenMint: collReserve.getLiquidityMint(),
+          priceCollToDebt: new Decimal(priceCollToDebt),
+          currentDepositPosition: deposited,
+          currentBorrowPosition: borrowed,
+          withdrawAmount: new Decimal(withdrawAmount),
+          selectedTokenMint: selectedTokenMint,
+        });
+
+  // Add slippage for the accrued interest rate amount
+  const irSlippageBpsForDebt = obligation!
+    .estimateObligationInterestRate(market, debtReserve!, obligation?.state.borrows[0]!, 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 = initialRepayAmount
+    .mul(irSlippageBpsForDebt.add('0.1').div('10_000').add('1'))
+    .toDecimalPlaces(debtReserve?.state.liquidity.mintDecimals.toNumber()!, Decimal.ROUND_CEIL);
+
+  // 6. Get swap ixns
+  // 5. Get swap estimations to understand how much we need to borrow from borrow reserve
+  // prevent withdrawing more then deposited if we close position
+  const depositTokenWithdrawAmount = !isClosingPosition
+    ? withdrawAmountCalculated.mul(new Decimal(1).plus(flashLoanFee))
+    : withdrawAmountCalculated;
+
+  // We are swapping debt token
+  // When withdrawing coll, it means we just need to swap enough to pay for the flash borrow
+  const swapAmountIfWithdrawingColl = repayAmount
+    .mul(new Decimal(1).plus(flashLoanFee))
+    .mul(new Decimal(1).plus(slippagePct.div(100)))
+    .div(priceCollToDebt);
+
+  // When withdrawing debt, it means we need to swap just the collateral we are withdrwaing
+  // enough to cover the debt we are repaying, leaving the remaining in the wallet
+  const swapAmountIfWithdrawingDebt = withdrawAmountCalculated;
+
+  const collTokenSwapIn = selectedTokenIsCollToken ? swapAmountIfWithdrawingColl : swapAmountIfWithdrawingDebt;
+  const debtTokenExpectedSwapOut = collTokenSwapIn.mul(priceCollToDebt).div(new Decimal(1).add(slippagePct.div(100)));
+
+  return {
+    withdrawAmount: withdrawAmountCalculated,
+    repayAmount,
+    collTokenSwapIn,
+    debtTokenExpectedSwapOut,
+    depositTokenWithdrawAmount,
+  };
+}
+
+export async function adjustDepositLeverageCalcs(
+  market: KaminoMarket,
+  owner: PublicKey,
+  debtReserve: KaminoReserve,
+  adjustDepositPosition: Decimal,
+  adjustBorrowPosition: Decimal,
+  priceDebtToColl: Decimal,
+  flashLoanFee: Decimal,
+  slippagePct: Decimal,
+  collIsKtoken: boolean
+): Promise<AdjustLeverageCalcsResult> {
+  // used if coll is Ktoken and we borrow debt token instead
+  const amountToFlashBorrowDebt = adjustDepositPosition
+    .div(priceDebtToColl)
+    .mul(new Decimal(new Decimal(1).add(slippagePct.div(100))))
+    .toDecimalPlaces(debtReserve!.stats.decimals, Decimal.ROUND_UP);
+
+  const borrowAmount = adjustDepositPosition
+    .mul(new Decimal(1).plus(flashLoanFee))
+    .mul(new Decimal(new Decimal(1).add(slippagePct.div(100))))
+    .div(priceDebtToColl);
+
+  const expectedDebtTokenAtaBalance = await getExpectedTokenBalanceAfterBorrow(
+    market.getConnection(),
+    debtReserve.getLiquidityMint(),
+    owner,
+    collToLamportsDecimal(!collIsKtoken ? borrowAmount : amountToFlashBorrowDebt, debtReserve!.stats.decimals).floor(),
+    debtReserve!.state.liquidity.mintDecimals.toNumber()
+  );
+
+  return {
+    adjustDepositPosition,
+    adjustBorrowPosition,
+    amountToFlashBorrowDebt,
+    borrowAmount,
+    expectedDebtTokenAtaBalance,
+    withdrawAmountWithSlippageAndFlashLoanFee: new Decimal(0),
+  };
+}
+
+export function adjustWithdrawLeverageCalcs(
+  adjustDepositPosition: Decimal,
+  adjustBorrowPosition: Decimal,
+  flashLoanFee: Decimal,
+  slippagePct: Decimal
+): AdjustLeverageCalcsResult {
+  // used if coll is Ktoken and we borrow debt token instead
+  const withdrawAmountWithSlippageAndFlashLoanFee = Decimal.abs(adjustDepositPosition)
+    .mul(new Decimal(1).plus(flashLoanFee))
+    .mul(new Decimal(1).add(slippagePct.div(100)));
+
+  return {
+    adjustDepositPosition,
+    adjustBorrowPosition,
+    amountToFlashBorrowDebt: new Decimal(0),
+    borrowAmount: new Decimal(0),
+    expectedDebtTokenAtaBalance: new Decimal(0),
+    withdrawAmountWithSlippageAndFlashLoanFee,
+  };
+}

package/src/leverage/index.ts

@@ -2,3 +2,4 @@ export * from './calcs';
 export * from './instructions';
 export * from './operations';
 export * from './utils';
+export * from './types';