@kamino-finance/klend-sdk 5.13.7 → 5.13.9

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -2,7 +2,11 @@ import Decimal from 'decimal.js';
 import { KaminoMarket, KaminoObligation, KaminoReserve, numberToLamportsDecimal } from '../classes';
 import { PublicKey } from '@solana/web3.js';
 import { lamportsToDecimal } from '../classes/utils';
-import { MaxWithdrawLtvCheck, getMaxWithdrawLtvCheck } from './repay_with_collateral_operations';
+import {
+  MaxWithdrawLtvCheck,
+  getMaxCollateralFromRepayAmount,
+  getMaxWithdrawLtvCheck,
+} from './repay_with_collateral_operations';
 
 export function calcRepayAmountWithSlippage(
   kaminoMarket: KaminoMarket,
@@ -16,7 +20,7 @@ export function calcRepayAmountWithSlippage(
   repayAmountLamports: Decimal;
   flashRepayAmountLamports: Decimal;
 } {
-  const irSlippageBpsForDebt = obligation
+  const interestRateAccrued = obligation
     .estimateObligationInterestRate(
       kaminoMarket,
       debtReserve,
@@ -24,9 +28,9 @@ export function calcRepayAmountWithSlippage(
       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
+  // add 0.1% to interestRateAccrued because we don't want to estimate slightly less than SC and end up not repaying enough
   const repayAmountIrAdjusted = amount
-    .mul(irSlippageBpsForDebt.mul(new Decimal('1.001')))
+    .mul(interestRateAccrued.mul(new Decimal('1.001')))
     .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
 
   let repayAmount: Decimal;
@@ -34,7 +38,7 @@ export function calcRepayAmountWithSlippage(
   if (
     repayAmountIrAdjusted.greaterThanOrEqualTo(
       lamportsToDecimal(
-        obligation.borrows.get(debtReserve.address)?.amount || new Decimal(0),
+        obligation.getBorrowByReserve(debtReserve.address)?.amount || new Decimal(0),
         debtReserve.stats.decimals
       )
     )
@@ -83,8 +87,7 @@ export function calcMaxWithdrawCollateral(
   debtReserveAddr: PublicKey,
   repayAmountLamports: Decimal
 ): {
-  repayAmountLamports: Decimal;
-  withdrawableCollLamports: Decimal;
+  maxWithdrawableCollLamports: Decimal;
   canWithdrawAllColl: boolean;
   repayingAllDebt: boolean;
 } {
@@ -92,8 +95,9 @@ export function calcMaxWithdrawCollateral(
   const borrow = obligation.getBorrowByReserve(debtReserveAddr)!;
   const depositReserve = market.getReserveByAddress(deposit.reserveAddress)!;
   const debtReserve = market.getReserveByAddress(borrow.reserveAddress)!;
-  const depositTotalLamports = deposit.amount.floor();
+  const depositTotalLamports = deposit.amount.floor(); // TODO: can remove floor, we have lamports only for deposits
 
+  // Calculate the market value of the remaining debt after repaying
   const remainingBorrowLamports = borrow.amount.sub(repayAmountLamports).ceil();
   const remainingBorrowAmount = remainingBorrowLamports.div(debtReserve.getMintFactor());
   let remainingBorrowsValue = remainingBorrowAmount.mul(debtReserve.getOracleMarketPrice());
@@ -103,17 +107,31 @@ export function calcMaxWithdrawCollateral(
       .filter((p) => !p.reserveAddress.equals(borrow.reserveAddress))
       .reduce((acc, b) => acc.add(b.marketValueRefreshed), new Decimal('0'));
   }
-  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(obligation);
 
-  let remainingDepositsValueWithLtv = new Decimal('0');
+  const hypotheticalWithdrawLamports = getMaxCollateralFromRepayAmount(
+    repayAmountLamports.div(debtReserve.getMintFactor()),
+    debtReserve,
+    depositReserve
+  );
+
+  // Calculate the max withdraw ltv we can withdraw up to
+  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(
+    obligation,
+    repayAmountLamports,
+    debtReserve,
+    hypotheticalWithdrawLamports,
+    depositReserve
+  );
+  // Calculate the max borrowable value remaining against deposits
+  let maxBorrowableValueRemainingAgainstDeposits = new Decimal('0');
   if (obligation.getDeposits().length > 1) {
-    remainingDepositsValueWithLtv = obligation
+    maxBorrowableValueRemainingAgainstDeposits = obligation
       .getDeposits()
       .filter((p) => !p.reserveAddress.equals(deposit.reserveAddress))
       .reduce((acc, d) => {
         const { maxLtv, liquidationLtv } = obligation.getLtvForReserve(
           market,
-          market.getReserveByAddress(d.reserveAddress)!
+          market.getExistingReserveByAddress(d.reserveAddress)
         );
         const maxWithdrawLtv =
           maxWithdrawLtvCheck === MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD ? liquidationLtv : maxLtv;
@@ -121,11 +139,11 @@ export function calcMaxWithdrawCollateral(
       }, new Decimal('0'));
   }
 
-  // can withdraw all coll
-  if (remainingDepositsValueWithLtv.gte(remainingBorrowsValue)) {
+  // if the remaining borrow value is less than the
+  // this means that the user's ltv is less or equal to the max ltv
+  if (maxBorrowableValueRemainingAgainstDeposits.gte(remainingBorrowsValue)) {
     return {
-      repayAmountLamports: repayAmountLamports,
-      withdrawableCollLamports: depositTotalLamports,
+      maxWithdrawableCollLamports: depositTotalLamports,
       canWithdrawAllColl: true,
       repayingAllDebt: repayAmountLamports.gte(borrow.amount),
     };
@@ -138,16 +156,15 @@ export function calcMaxWithdrawCollateral(
       maxWithdrawLtvCheck === MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD ? collLiquidationLtv : collMaxLtv;
     const numerator = deposit.marketValueRefreshed
       .mul(maxWithdrawLtv)
-      .add(remainingDepositsValueWithLtv)
+      .add(maxBorrowableValueRemainingAgainstDeposits)
       .sub(remainingBorrowsValue);
 
     const denominator = depositReserve.getOracleMarketPrice().mul(maxWithdrawLtv);
     const maxCollWithdrawAmount = numerator.div(denominator);
-    const withdrawableCollLamports = maxCollWithdrawAmount.mul(depositReserve.getMintFactor()).floor();
+    const maxWithdrawableCollLamports = maxCollWithdrawAmount.mul(depositReserve.getMintFactor()).floor();
 
     return {
-      repayAmountLamports: repayAmountLamports,
-      withdrawableCollLamports,
+      maxWithdrawableCollLamports,
       canWithdrawAllColl: false,
       repayingAllDebt: repayAmountLamports.gte(borrow.amount),
     };
@@ -158,7 +175,7 @@ export function estimateDebtRepaymentWithColl(props: {
   collAmount: Decimal; // in decimals
   priceDebtToColl: Decimal;
   slippagePct: Decimal;
-  flashBorrowReserveFlashLoanFeePercentage: Decimal;
+  flashLoanFeePct: Decimal;
   kaminoMarket: KaminoMarket;
   debtTokenMint: PublicKey;
   obligation: KaminoObligation;
@@ -168,34 +185,32 @@ export function estimateDebtRepaymentWithColl(props: {
     collAmount,
     priceDebtToColl,
     slippagePct,
-    flashBorrowReserveFlashLoanFeePercentage,
+    flashLoanFeePct,
     kaminoMarket,
     debtTokenMint,
     obligation,
     currentSlot,
   } = props;
-  const slippage = slippagePct.div('100');
-  const flashLoanFee = flashBorrowReserveFlashLoanFeePercentage.div('100');
-  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
-  if (debtReserve === undefined) {
-    throw new Error('Debt reserve not found');
-  }
+  const slippageMultiplier = new Decimal(1.0).add(slippagePct.div('100'));
+  const flashLoanFeeMultiplier = new Decimal(1.0).add(flashLoanFeePct.div('100'));
+
+  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
 
-  const debtAfterSwap = collAmount.div(new Decimal(1.0).add(slippage)).div(priceDebtToColl);
-  const debtAfterFlashLoanRepay = debtAfterSwap.div(new Decimal(1.0).add(flashLoanFee));
+  const debtAfterSwap = collAmount.div(slippageMultiplier).div(priceDebtToColl);
+  const debtAfterFlashLoanRepay = debtAfterSwap.div(flashLoanFeeMultiplier);
 
-  const irSlippageBpsForDebt = obligation
+  const accruedInterestRate = obligation
     .estimateObligationInterestRate(
       kaminoMarket,
       debtReserve,
-      obligation?.state.borrows.find((borrow) => borrow.borrowReserve?.equals(debtReserve.address))!,
+      obligation.getObligationLiquidityByReserve(debtReserve.address),
       currentSlot
     )
     .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
 
   // Estimate slightly more, by adding 1% to IR in order to avoid the case where UI users can repay the max we allow them
   const debtIrAdjusted = debtAfterFlashLoanRepay
-    .div(irSlippageBpsForDebt.mul(new Decimal('1.01')))
+    .div(accruedInterestRate.mul(new Decimal('1.01')))
     .toDecimalPlaces(debtReserve.state.liquidity.mintDecimals.toNumber(), Decimal.ROUND_CEIL);
 
   return debtIrAdjusted;
@@ -205,19 +220,21 @@ export function estimateCollNeededForDebtRepayment(props: {
   debtAmount: Decimal; // in decimals
   priceDebtToColl: Decimal;
   slippagePct: Decimal;
-  flashBorrowReserveFlashLoanFeePercentage: Decimal;
+  flashLoanFeePct: Decimal;
 }): Decimal {
   const {
     debtAmount, // in decimals
     priceDebtToColl,
     slippagePct,
-    flashBorrowReserveFlashLoanFeePercentage,
+    flashLoanFeePct,
   } = props;
-  const slippage = slippagePct.div('100');
-  const flashLoanFee = flashBorrowReserveFlashLoanFeePercentage.div('100');
+  const slippageRatio = slippagePct.div('100');
+  const flashLoanFeeRatio = flashLoanFeePct.div('100');
+  const slippageMultiplier = new Decimal(1.0).add(slippageRatio);
+  const flashLoanFeeMultiplier = new Decimal(1.0).add(flashLoanFeeRatio);
 
-  const debtFlashLoanRepay = debtAmount.mul(new Decimal(1.0).add(flashLoanFee));
-  const collToSwap = debtFlashLoanRepay.mul(new Decimal(1.0).add(slippage)).mul(priceDebtToColl);
+  const debtFlashLoanRepay = debtAmount.mul(flashLoanFeeMultiplier);
+  const collToSwap = debtFlashLoanRepay.mul(slippageMultiplier).mul(priceDebtToColl);
 
   return collToSwap;
 }

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -83,14 +83,8 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   flashLoanInfo: FlashLoanInfo;
   initialInputs: RepayWithCollInitialInputs<QuoteResponse>;
 }> {
-  const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
-  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
-  if (!collReserve) {
-    throw new Error(`Collateral reserve with mint ${collTokenMint} not found in market ${kaminoMarket.getAddress()}`);
-  }
-  if (!debtReserve) {
-    throw new Error(`Debt reserve with mint ${debtTokenMint} not found in market ${kaminoMarket.getAddress()}`);
-  }
+  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
+  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
 
   const {
     repayAmountLamports,
@@ -110,7 +104,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
       `Collateral position not found for ${collReserve.stats.symbol} reserve ${collReserve.address} in obligation ${obligation.obligationAddress}`
     );
   }
-  const { withdrawableCollLamports } = calcMaxWithdrawCollateral(
+  const { maxWithdrawableCollLamports } = calcMaxWithdrawCollateral(
     kaminoMarket,
     obligation,
     collReserve.address,
@@ -118,14 +112,8 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     repayAmountLamports
   );
 
-  // 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 maxCollNeededFromOracle = finalRepayAmount
-    .mul(debtReserve.getOracleMarketPrice())
-    .div(collReserve.getOracleMarketPrice())
-    .mul('1.1')
-    .mul(collReserve.getMintFactor())
-    .ceil();
-  const inputAmountLamports = Decimal.min(withdrawableCollLamports, maxCollNeededFromOracle);
+  const maxCollNeededFromOracle = getMaxCollateralFromRepayAmount(finalRepayAmount, debtReserve, collReserve);
+  const inputAmountLamports = Decimal.min(maxWithdrawableCollLamports, maxCollNeededFromOracle);
 
   // Build the repay & withdraw collateral tx to get the number of accounts
   const klendIxs: LeverageIxsOutput = await buildRepayWithCollateralIxs(
@@ -153,7 +141,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     inputAmountLamports,
     inputMint: collTokenMint,
     outputMint: debtTokenMint,
-    amountDebtAtaBalance: new Decimal(0), // only used for kTokens
+    amountDebtAtaBalance: undefined, // only used for kTokens
   };
 
   const swapQuote = await quoter(swapQuoteInputs, uniqueKlendAccounts);
@@ -171,13 +159,13 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
       minOutAmountLamports: flashRepayAmountLamports,
       inputMint: collTokenMint,
       outputMint: debtTokenMint,
-      amountDebtAtaBalance: new Decimal(0), // only used for kTokens
+      amountDebtAtaBalance: undefined, // only used for kTokens
     },
     flashLoanInfo: klendIxs.flashLoanInfo,
     initialInputs: {
       debtRepayAmountLamports: repayAmountLamports,
       flashRepayAmountLamports,
-      maxCollateralWithdrawLamports: withdrawableCollLamports,
+      maxCollateralWithdrawLamports: maxWithdrawableCollLamports,
       swapQuote,
       currentSlot,
       klendAccounts: uniqueKlendAccounts,
@@ -223,17 +211,8 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
-  const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
-
-  if (!collReserve) {
-    throw new Error(`Collateral reserve with mint ${collTokenMint} not found in market ${kaminoMarket.getAddress()}`);
-  }
-
-  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
-
-  if (!debtReserve) {
-    throw new Error(`Debt reserve with mint ${debtTokenMint} not found in market ${kaminoMarket.getAddress()}`);
-  }
+  const collReserve = kaminoMarket.getExistingReserveByMint(collTokenMint);
+  const debtReserve = kaminoMarket.getExistingReserveByMint(debtTokenMint);
 
   // the client should use these values to prevent this input, but the tx may succeed, so we don't want to fail
   // there is also a chance that the tx will consume debt token from the user's ata which they would not expect
@@ -326,7 +305,13 @@ async function buildRepayWithCollateralIxs(
 
   const requestElevationGroup = !isClosingPosition && obligation.state.elevationGroup !== 0;
 
-  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(obligation);
+  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(
+    obligation,
+    debtRepayAmountLamports,
+    debtReserve,
+    collWithdrawLamports,
+    collReserve
+  );
 
   // 3. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
   let repayAndWithdrawAction;
@@ -393,8 +378,74 @@ async function buildRepayWithCollateralIxs(
   return res;
 }
 
-export const getMaxWithdrawLtvCheck = (obligation: KaminoObligation) => {
+export const getMaxWithdrawLtvCheck = (
+  obligation: KaminoObligation,
+  repayAmountLamports: Decimal,
+  debtReserve: KaminoReserve,
+  collWithdrawAmount: Decimal,
+  collReserve: KaminoReserve
+) => {
+  const [finalLtv, finalMaxLtv] = calculatePostOperationLtv(
+    obligation,
+    repayAmountLamports,
+    debtReserve,
+    collWithdrawAmount,
+    collReserve
+  );
+
+  if (finalLtv.lte(finalMaxLtv)) {
+    return MaxWithdrawLtvCheck.MAX_LTV;
+  }
+
   return obligation.refreshedStats.userTotalBorrowBorrowFactorAdjusted.gte(obligation.refreshedStats.borrowLimit)
     ? MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD
     : MaxWithdrawLtvCheck.MAX_LTV;
 };
+
+function calculatePostOperationLtv(
+  obligation: KaminoObligation,
+  repayAmountLamports: Decimal,
+  debtReserve: KaminoReserve,
+  collWithdrawAmount: Decimal,
+  collReserve: KaminoReserve
+): [Decimal, Decimal] {
+  const repayValue = repayAmountLamports
+    .div(debtReserve.getMintFactor())
+    .mul(debtReserve.getOracleMarketPrice())
+    .mul(debtReserve.getBorrowFactor());
+  const collWithdrawValue = collWithdrawAmount.div(collReserve.getMintFactor()).mul(collReserve.getOracleMarketPrice());
+
+  // Calculate new borrow value and deposit value
+  const newBorrowBfValue = Decimal.max(
+    new Decimal(0),
+    obligation.refreshedStats.userTotalBorrowBorrowFactorAdjusted.sub(repayValue)
+  );
+  const newDepositValue = Decimal.max(
+    new Decimal(0),
+    obligation.refreshedStats.userTotalDeposit.sub(collWithdrawValue)
+  );
+  
+  const newMaxBorrowableValue = Decimal.max(
+    new Decimal(0),
+    obligation.refreshedStats.borrowLimit.sub(collWithdrawValue.mul(collReserve.stats.loanToValue))
+  );
+
+  const newMaxLtv = newMaxBorrowableValue.div(newDepositValue);
+
+  // return final ltv and final max ltv
+  return [newBorrowBfValue.div(newDepositValue), newMaxLtv];
+}
+
+export function getMaxCollateralFromRepayAmount(
+  repayAmount: Decimal,
+  debtReserve: KaminoReserve,
+  collReserve: KaminoReserve
+) {
+  // 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
+  return repayAmount
+    .mul(debtReserve.getOracleMarketPrice())
+    .div(collReserve.getOracleMarketPrice())
+    .mul('1.1')
+    .mul(collReserve.getMintFactor())
+    .ceil();
+}

package/src/utils/multisig.ts

@@ -1,22 +1,25 @@
 import { PublicKey } from '@solana/web3.js';
 
-const SQUADS_API_BASE_URL = 'https://4fnetmviidiqkjzenwxe66vgoa0soerr.lambda-url.us-east-1.on.aws/';
+const SQUADS_API_BASE_URL = 'https://4fnetmviidiqkjzenwxe66vgoa0soerr.lambda-url.us-east-1.on.aws';
 
 export async function walletIsSquadsMultisig(wallet: PublicKey) {
-  const response = await fetch(`${SQUADS_API_BASE_URL}/is-multisig?wallet=${wallet.toBase58()}`);
+  const response = await fetch(`${SQUADS_API_BASE_URL}/isSquad/${wallet.toBase58()}`);
   const data = await response.json();
   const squadsResponse = data as SquadsMultisigResponse;
   return squadsResponse.isSquad;
 }
 
 // todo: find a way to get the admins number and threshold
-export async function getSquadsMultisigAdminsAndThreshold(_wallet: PublicKey): Promise<{
+export async function getSquadsMultisigAdminsAndThreshold(wallet: PublicKey): Promise<{
   adminsNumber: number;
   threshold: number;
 }> {
+  const response = await fetch(`${SQUADS_API_BASE_URL}/multisig/${wallet.toBase58()}`);
+  const data = await response.json();
+  const squadsResponse = data as SquadsMultisigAccountResponse;
   return {
-    adminsNumber: 1,
-    threshold: 1,
+    adminsNumber: squadsResponse.keys.length,
+    threshold: squadsResponse.threshold,
   };
 }
 
@@ -31,3 +34,14 @@ export interface WalletType {
   walletAdminsNumber: number;
   walletThreshold: number;
 }
+
+export type SquadsMultisigAccountResponse = {
+  allow_external_execute: boolean;
+  authority_index: number;
+  bump: number;
+  create_key: string;
+  keys: number[][];
+  ms_change_index: number;
+  threshold: number;
+  transaction_index: number;
+};