@kamino-finance/klend-sdk 4.0.1 → 4.1.0

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;
   }
@@ -935,9 +982,9 @@ export class KaminoReserve {
       currentValue: Decimal;
     }[] = market
       .getMarketElevationGroupDescriptions()
-      .filter((x) => x.debtReserve === this.address.toString())
+      .filter((x) => x.debtReserve.equals(this.address))
       .map((elevationGroupDescription: ElevationGroupDescription) =>
-        elevationGroupDescription.collateralReserves.map((collateralReserveAddress) => {
+        elevationGroupDescription.collateralReserves.toArray().map((collateralReserveAddress) => {
           const collRes = market.reserves.get(new PublicKey(collateralReserveAddress))!;
 
           const debtLimitAgainstThisCollInGroup =
@@ -1015,14 +1062,15 @@ export class KaminoReserve {
           positiveOrZero(remainingGlobalCap),
           positiveOrZero(liquidityGivenUtilizationCap)
         );
-
         return availableInCrossMode;
       } else {
-        const remainingInsideEmodeCaps = Decimal.min(
-          ...caps.debtAgainstCollateralReserveCaps
-            .filter((x) => x.elevationGroup === elevationGroup)
-            .map((x) => x.maxDebt.minus(x.currentValue))
+        let remainingInsideEmodeCaps = new Decimal(0);
+        const capsGivenEgroup = caps.debtAgainstCollateralReserveCaps.filter(
+          (x) => x.elevationGroup === elevationGroup
         );
+        if (capsGivenEgroup.length > 0) {
+          remainingInsideEmodeCaps = Decimal.min(...capsGivenEgroup.map((x) => x.maxDebt.minus(x.currentValue)));
+        }
         return Decimal.min(
           positiveOrZero(liquidityAvailable),
           positiveOrZero(remainingInsideEmodeCaps),

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;