@kamino-finance/klend-sdk 7.1.2 → 7.1.4-beta.0

package/src/lending_operations/index.ts

@@ -1,3 +1,4 @@
 export * from './repay_with_collateral_operations';
 export * from './swap_collateral_operations';
 export * from './repay_with_collateral_calcs';
+export * from './unstake_lst_collateral';

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -151,7 +151,6 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     inputAmountLamports,
     inputMint: collTokenMint,
     outputMint: debtTokenMint,
-    amountDebtAtaBalance: undefined, // only used for kTokens
   };
 
   const swapQuote = await quoter(swapQuoteInputs, uniqueKlendAccounts);
@@ -169,7 +168,6 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
       minOutAmountLamports: flashRepayAmountLamports,
       inputMint: collTokenMint,
       outputMint: debtTokenMint,
-      amountDebtAtaBalance: undefined, // only used for kTokens
     },
     flashLoanInfo: klendIxs.flashLoanInfo,
     initialInputs: {

package/src/lending_operations/swap_collateral_operations.ts

@@ -529,7 +529,6 @@ async function getExternalSwapIxs<QuoteResponse>(
     inputAmountLamports: args.sourceCollSwapAmount.mul(context.sourceCollReserve.getMintFactor()),
     inputMint: context.sourceCollReserve.getLiquidityMint(),
     outputMint: context.targetCollReserve.getLiquidityMint(),
-    amountDebtAtaBalance: undefined, // only used for kTokens
   };
   const externalSwapQuote = await context.quoter(externalSwapInputs, klendAccounts);
   const externalSwapIxsAndLuts = await context.swapper(externalSwapInputs, klendAccounts, externalSwapQuote);

package/src/lending_operations/unstake_lst_collateral.ts

@@ -0,0 +1,174 @@
+import {
+  Fraction,
+  getStandardPoolMintRemainingAccounts,
+  KaminoAction,
+  KaminoMarket,
+  KaminoObligation,
+  KaminoReserve,
+  maybeGetStakedPoolByMint,
+} from '../classes';
+import { getFlashLoanInstructions, getScopeRefreshIx } from '../leverage';
+import {
+  createAtasIdempotent,
+  getComputeBudgetAndPriorityFeeIxs,
+  ScopePriceRefreshConfig,
+  SLOTS_PER_DAY,
+} from '../utils';
+import Decimal from 'decimal.js';
+import BN from 'bn.js';
+import { Address, IInstruction, none, Option, Slot, TransactionSigner } from '@solana/kit';
+
+const LST_CONVERSION_MARGIN_BPS = new Decimal(100);
+const FULL_BPS = new Decimal(10_000);
+
+export async function buildUnstakeLstCollateralStartIxs(
+  market: KaminoMarket,
+  obligation: KaminoObligation,
+  owner: TransactionSigner,
+  lstMint: Address,
+  referrer: Option<Address>,
+  currentSlot: Slot,
+  budgetAndPriorityFeeIxs: IInstruction[] | undefined,
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined
+): Promise<{ instructions: IInstruction[]; remainingSigners: TransactionSigner[] }> {
+  // Get reserves based on obligation
+  const usolMint = await market.getUsolPoolMint();
+  const usolReserve = market.getReserveByMint(usolMint);
+  const lstReserve = market.getReserveByMint(lstMint);
+  const debtReserve = market.reserves.get(obligation.state.borrows[0].borrowReserve);
+  if (!usolReserve) {
+    throw new Error(`Cannot fetch usol reserve for mint ${usolMint}`);
+  }
+  if (!lstReserve) {
+    throw new Error(`Cannot fetch lst reserve for mint ${obligation.state.deposits[0].depositReserve}`);
+  }
+  if (!debtReserve) {
+    throw new Error(`Cannot fetch debt reserve for mint ${obligation.state.borrows[0].borrowReserve}`);
+  }
+
+  // 0. Compute sol to repay + lst to flash borrow + additional accounts
+  const stakePool = await maybeGetStakedPoolByMint(market.getRpc(), lstReserve.getLiquidityMint());
+  if (!stakePool) {
+    throw new Error(`Cannot fetch stake pool for mint ${lstReserve.getLiquidityMint()}`);
+  }
+  const { lstToConvert } = getUnstakeLstCollateralApproximateInputs(
+    market,
+    debtReserve,
+    lstReserve,
+    obligation,
+    currentSlot
+  );
+  const [depositStakedSolRemainingAccounts, remainingSigners] = await getStandardPoolMintRemainingAccounts(
+    market.getRpc(),
+    stakePool[0],
+    stakePool[1],
+    new BN(lstToConvert.toString())
+  );
+  // 1. Create atas & budget txns
+  const budgetIxs = budgetAndPriorityFeeIxs || getComputeBudgetAndPriorityFeeIxs(1_400_000);
+
+  const atas = [
+    { mint: usolReserve.getLiquidityMint(), tokenProgram: usolReserve.getLiquidityTokenProgram() },
+    { mint: lstReserve.getLiquidityMint(), tokenProgram: lstReserve.getLiquidityTokenProgram() },
+  ];
+
+  const atasAndIxs = await createAtasIdempotent(owner, atas);
+  const [, { ata: lstAta }] = atasAndIxs;
+  const scopeRefreshIx = await getScopeRefreshIx(market, lstReserve, debtReserve, obligation, scopeRefreshConfig);
+
+  // 2. Flash borrow & repay the debt to repay amount needed
+  const { flashBorrowIx, flashRepayIx } = getFlashLoanInstructions({
+    borrowIxIndex: budgetIxs.length + atasAndIxs.length + (scopeRefreshIx.length > 0 ? 1 : 0),
+    userTransferAuthority: owner,
+    lendingMarketAuthority: await market.getLendingMarketAuthority(),
+    lendingMarketAddress: market.getAddress(),
+    reserve: lstReserve,
+    amountLamports: lstToConvert,
+    destinationAta: lstAta,
+    // TODO(referrals): once we support referrals, we will have to replace the placeholder args below:
+    referrerAccount: none(),
+    referrerTokenState: none(),
+    programId: market.programId,
+  });
+
+  // 3. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
+  const unstakeLstCollateralStartAction = await KaminoAction.buildUnstakeLstCollateralStartTxns(
+    market,
+    lstToConvert.toString(),
+    usolReserve.getLiquidityMint(),
+    lstReserve.getLiquidityMint(),
+    owner,
+    currentSlot,
+    obligation,
+    depositStakedSolRemainingAccounts,
+    undefined,
+    0,
+    false,
+    undefined,
+    referrer
+  );
+
+  const instructions = [
+    ...scopeRefreshIx,
+    ...budgetIxs,
+    ...atasAndIxs.map((x) => x.createAtaIx),
+    flashBorrowIx,
+    ...KaminoAction.actionToIxs(unstakeLstCollateralStartAction),
+    flashRepayIx,
+  ];
+  return {
+    instructions,
+    remainingSigners,
+  };
+}
+
+export function getUnstakeLstCollateralApproximateInputs(
+  market: KaminoMarket,
+  debtReserve: KaminoReserve,
+  lstReserve: KaminoReserve,
+  obligation: KaminoObligation,
+  currentSlot: Slot
+): {
+  lstToConvert: Decimal;
+} {
+  // Compute the interest rate / curve after 4 days (~2 epochs)
+  const laterSlot = currentSlot + BigInt(SLOTS_PER_DAY * 4);
+  const borrow = obligation.state.borrows.find(
+    (borrow) => borrow.borrowReserve.toString() === debtReserve.address.toString()
+  );
+  const lstDeposit = obligation.state.deposits.find(
+    (deposit) => deposit.depositReserve.toString() === lstReserve.address.toString()
+  );
+  if (!borrow) {
+    throw new Error(
+      `Could not find borrow ${debtReserve.address.toString()} in obligation ${obligation.obligationAddress.toString()}`
+    );
+  }
+  if (!lstDeposit) {
+    throw new Error(
+      `Could not find deposit ${lstReserve.address.toString()} in obligation ${obligation.obligationAddress.toString()}`
+    );
+  }
+  const newInterestRate = obligation.estimateObligationInterestRate(market, debtReserve, borrow, laterSlot);
+  const debtToRepay = new Fraction(borrow.borrowedAmountSf).toDecimal().mul(newInterestRate);
+
+  // To compute the staked sol to convert we convert the sol to repay
+  // using the pool ratio, but we cap it at the total amount of deposited
+  // staked sol in the obligation (converted from collateral -> liquidity)
+  const lstPrice = lstReserve.getOracleMarketPrice();
+  const debtPrice = debtReserve.getOracleMarketPrice();
+  const equivalentLst = debtToRepay.mul(debtPrice).div(lstPrice);
+  const equivalentLstWithMargin = equivalentLst.mul(FULL_BPS.add(LST_CONVERSION_MARGIN_BPS)).div(FULL_BPS);
+
+  const newCollateralExchangeRate = debtReserve.getEstimatedCollateralExchangeRate(
+    laterSlot,
+    market.state.referralFeeBps
+  );
+  const lstCollateralAmount = new Decimal(equivalentLstWithMargin.toString()).mul(newCollateralExchangeRate);
+  const lstCollateralToConvert = Decimal.min(new Decimal(lstDeposit.depositedAmount.toString()), lstCollateralAmount);
+
+  const lstToConvert = lstCollateralToConvert.div(newCollateralExchangeRate).ceil();
+  return {
+    lstToConvert,
+  };
+}

package/src/leverage/calcs.ts

@@ -1,14 +1,7 @@
 import { Address, Slot } from '@solana/kit';
 import Decimal from 'decimal.js';
-import { collToLamportsDecimal, Kamino, StrategyWithAddress, TokenAmounts } from '@kamino-finance/kliquidity-sdk';
 import { KaminoMarket, KaminoObligation, KaminoReserve, toJson } from '../classes';
-import { getExpectedTokenBalanceAfterBorrow } from './utils';
-import {
-  AdjustLeverageCalcsResult,
-  DepositLeverageCalcsResult,
-  PriceAinBProvider,
-  WithdrawLeverageCalcsResult,
-} from './types';
+import { AdjustLeverageCalcsResult, DepositLeverageCalcsResult, WithdrawLeverageCalcsResult } from './types';
 import { fuzzyEqual } from '../utils';
 
 const closingPositionDiffTolerance = 0.0001;
@@ -404,73 +397,6 @@ export const estimateDepositMode = ({
   };
 };
 
-/**
- * Given an amount of ktokens, returns the estimated amount of token A and token B that need to be deposited
- * The amount of A and B may result in less ktokens being minted, the actual amount of ktokens minted is returned as well
- * @param kamino
- * @param strategy
- * @param mintAmount - desired amount of ktokens to mint
- * @param strategyHoldings - optional strategy holdings, if not provided will be fetched from the blockchain
- * @returns [tokenA, tokenB, actualMintAmount]
- */
-export async function simulateMintKToken(
-  kamino: Kamino,
-  strategy: StrategyWithAddress,
-  mintAmount: Decimal,
-  strategyHoldings?: TokenAmounts
-): Promise<[Decimal, Decimal, Decimal]> {
-  let holdings = strategyHoldings;
-  if (!holdings) {
-    holdings = await kamino.getStrategyTokensHoldings(strategy, 'DEPOSIT');
-  }
-  const sharesIssuedDecimal = new Decimal(strategy.strategy.sharesIssued.toString()).div(
-    10 ** strategy.strategy.sharesMintDecimals.toNumber()
-  );
-
-  // Add 1 because the sdk doesn't round up where the SC will
-  const strategyA = holdings.a.div(10 ** strategy.strategy.tokenAMintDecimals.toNumber());
-  const strategyB = holdings.b.div(10 ** strategy.strategy.tokenBMintDecimals.toNumber());
-  const aPerShare = strategyA.div(sharesIssuedDecimal);
-  const bPerShare = strategyB.div(sharesIssuedDecimal);
-
-  const requiredA = aPerShare.mul(mintAmount);
-  const requiredB = bPerShare.mul(mintAmount);
-  const pxAInB = strategyB.div(strategyA);
-
-  console.info(
-    `Estimating kToken mint of ${mintAmount} ktokens on strategy ${strategy.address.toString()} requires: estimated A: ${requiredA}, estimated B: ${requiredB}. Current pool state:\n${toJson(
-      { ...holdings, sharesIssued: sharesIssuedDecimal, poolPxAInB: pxAInB }
-    )}`
-  );
-
-  // If we deposited with this exact ratio - how many ktokens do we actually get from the program?
-  const RustDecimal = Decimal.clone({ precision: 18, rounding: Decimal.ROUND_FLOOR });
-
-  const usA = new RustDecimal(holdings.a);
-  const usB = new RustDecimal(holdings.b);
-  const uA = new RustDecimal(requiredA.mul(10 ** strategy.strategy.tokenAMintDecimals.toNumber()).ceil());
-  const uB = new RustDecimal(requiredB.mul(10 ** strategy.strategy.tokenBMintDecimals.toNumber()).ceil());
-
-  const ratio = usA.div(usB);
-  const depositableB = uA.div(ratio).floor();
-  let actualA, actualB;
-  if (depositableB.lte(uB)) {
-    actualA = depositableB.mul(ratio).floor();
-    actualB = uB;
-  } else {
-    actualA = uB.mul(ratio).floor();
-    actualB = actualA.div(ratio).floor();
-  }
-  const actualMintFromA = actualA.mul(strategy.strategy.sharesIssued.toString()).div(holdings.a).floor();
-  const actualMintFromB = actualB.mul(strategy.strategy.sharesIssued.toString()).div(holdings.b).floor();
-  const actualMint = Decimal.min(actualMintFromA, actualMintFromB).div(
-    10 ** strategy.strategy.sharesMintDecimals.toNumber()
-  );
-  console.log(`Actual deposit amounts: A: ${actualA}, B: ${actualB}, kTokens to mint: ${actualMint}`);
-
-  return [requiredA, requiredB, actualMint];
-}
-
 export const depositLeverageCalcs = (props: {
   depositAmount: Decimal;
   depositTokenIsCollToken: boolean;
@@ -509,9 +435,6 @@ export const depositLeverageCalcs = (props: {
       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);
@@ -527,113 +450,6 @@ export const depositLeverageCalcs = (props: {
       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: Address;
-  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 { tokenAMint, tokenBMint } = strategy.strategy;
-    const pxAinB = await priceAinB(tokenAMint, tokenBMint);
-    const isTokenADeposit = tokenAMint === 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
     };
   }
 };
@@ -710,17 +526,13 @@ export function withdrawLeverageCalcs(
 }
 
 export async function adjustDepositLeverageCalcs(
-  market: KaminoMarket,
-  owner: Address,
   debtReserve: KaminoReserve,
   adjustDepositPosition: Decimal,
   adjustBorrowPosition: Decimal,
   priceDebtToColl: Decimal,
   flashLoanFee: Decimal,
-  slippagePct: Decimal,
-  collIsKtoken: boolean
+  slippagePct: Decimal
 ): 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))))
@@ -731,20 +543,11 @@ export async function adjustDepositLeverageCalcs(
     .mul(new Decimal(new Decimal(1).add(slippagePct.div(100))))
     .div(priceDebtToColl);
 
-  const expectedDebtTokenAtaBalance = await getExpectedTokenBalanceAfterBorrow(
-    market.getRpc(),
-    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),
   };
 }
@@ -755,7 +558,6 @@ export function adjustWithdrawLeverageCalcs(
   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)));
@@ -765,7 +567,6 @@ export function adjustWithdrawLeverageCalcs(
     adjustBorrowPosition,
     amountToFlashBorrowDebt: new Decimal(0),
     borrowAmount: new Decimal(0),
-    expectedDebtTokenAtaBalance: new Decimal(0),
     withdrawAmountWithSlippageAndFlashLoanFee,
   };
 }