@kamino-finance/klend-sdk 5.0.0 → 5.0.2-fix

package/src/classes/obligation.ts

@@ -362,11 +362,14 @@ export class KaminoObligation {
     collateralExchangeRates: Map<PublicKey, Decimal>
   ): ObligationCollateral[] {
     const newDeposits: ObligationCollateral[] = [];
+    const depositIndex = obligationDeposits.findIndex((deposit) => deposit.depositReserve.equals(changeReserve));
+
+    // Always copy the previous deposits and modify the changeReserve one if it exists
     for (let i = 0; i < obligationDeposits.length; i++) {
       if (obligationDeposits[i].depositReserve.equals(changeReserve)) {
         const coll: ObligationCollateralFields = { ...obligationDeposits[i] };
         const exchangeRate = collateralExchangeRates.get(changeReserve)!;
-        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate);
+        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
         const updatedDeposit = new Decimal(obligationDeposits[i].depositedAmount.toNumber()).add(changeInCollateral);
         coll.depositedAmount = new BN(positiveOrZero(updatedDeposit).toString());
         newDeposits.push(new ObligationCollateral(coll));
@@ -375,6 +378,25 @@ export class KaminoObligation {
       }
     }
 
+    if (depositIndex === -1) {
+      // If the reserve is not in the obligation, we add it
+      const firstBorrowIndexAvailable = obligationDeposits.findIndex((deposit) =>
+        deposit.depositReserve.equals(PublicKey.default)
+      );
+
+      if (firstBorrowIndexAvailable === -1) {
+        throw new Error('No available borrows to modify');
+      }
+
+      const coll: ObligationCollateralFields = { ...obligationDeposits[firstBorrowIndexAvailable] };
+      const exchangeRate = collateralExchangeRates.get(changeReserve)!;
+      const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
+      coll.depositedAmount = new BN(positiveOrZero(new Decimal(changeInCollateral)).toString());
+      coll.depositReserve = changeReserve;
+
+      newDeposits[firstBorrowIndexAvailable] = new ObligationCollateral(coll);
+    }
+
     return newDeposits;
   }
 
@@ -387,17 +409,30 @@ export class KaminoObligation {
     const newBorrows: ObligationLiquidity[] = [];
     const borrowIndex = obligationBorrows.findIndex((borrow) => borrow.borrowReserve.equals(changeReserve));
 
-    if (borrowIndex !== -1) {
-      const borrow: ObligationLiquidityFields = { ...obligationBorrows[borrowIndex] };
-      const newBorrowedAmount: Decimal = new Fraction(borrow.borrowedAmountSf).toDecimal().add(changeInLamports);
-      const newBorrowedAmountSf = Fraction.fromDecimal(positiveOrZero(newBorrowedAmount)).getValue();
-      borrow.borrowedAmountSf = newBorrowedAmountSf;
-      newBorrows.push(new ObligationLiquidity(borrow));
-    } else {
+    // Always copy the previous borrows and modify the changeReserve one if it exists
+    for (let i = 0; i < obligationBorrows.length; i++) {
+      if (obligationBorrows[i].borrowReserve.equals(changeReserve)) {
+        const borrow: ObligationLiquidityFields = { ...obligationBorrows[borrowIndex] };
+        const newBorrowedAmount: Decimal = new Fraction(borrow.borrowedAmountSf).toDecimal().add(changeInLamports);
+        const newBorrowedAmountSf = Fraction.fromDecimal(positiveOrZero(newBorrowedAmount)).getValue();
+        borrow.borrowedAmountSf = newBorrowedAmountSf;
+
+        newBorrows.push(new ObligationLiquidity(borrow));
+      } else {
+        newBorrows.push(obligationBorrows[i]);
+      }
+    }
+
+    if (borrowIndex === -1) {
+      // If the reserve is not in the obligation, we add it
       const firstBorrowIndexAvailable = obligationBorrows.findIndex((borrow) =>
         borrow.borrowReserve.equals(PublicKey.default)
       );
 
+      if (firstBorrowIndexAvailable === -1) {
+        throw new Error('No available borrows to modify');
+      }
+
       const borrow: ObligationLiquidityFields = { ...obligationBorrows[firstBorrowIndexAvailable] };
       borrow.borrowedAmountSf = Fraction.fromDecimal(new Decimal(changeInLamports)).getValue();
       borrow.borrowReserve = changeReserve;
@@ -405,7 +440,7 @@ export class KaminoObligation {
         padding: [],
         value: [Fraction.fromDecimal(cumulativeBorrowRate).getValue(), new BN(0), new BN(0), new BN(0)],
       };
-      newBorrows.push(new ObligationLiquidity(borrow));
+      newBorrows[firstBorrowIndexAvailable] = new ObligationLiquidity(borrow);
     }
 
     return newBorrows;
@@ -433,7 +468,23 @@ export class KaminoObligation {
     const { amountCollateral, amountDebt, action, mintCollateral, mintDebt, market } = params;
     let newStats = { ...this.refreshedStats };
 
-    const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(market, this.state, params.slot);
+    const collateralReservePk = mintCollateral ? market.getReserveByMint(mintCollateral)!.address : undefined;
+    const debtReservePk = mintDebt ? market.getReserveByMint(mintDebt)!.address : undefined;
+
+    const additionalReserves = [];
+    if (collateralReservePk !== undefined) {
+      additionalReserves.push(collateralReservePk);
+    }
+    if (debtReservePk !== undefined) {
+      additionalReserves.push(debtReservePk);
+    }
+
+    const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(
+      market,
+      this.state,
+      params.slot,
+      additionalReserves
+    );
 
     const elevationGroup = params.elevationGroupOverride ?? this.state.elevationGroup;
 
@@ -444,8 +495,6 @@ export class KaminoObligation {
     // so we have to recalculate the entire position, not just an updated deposit or borrow
     // as both LTVs and borrow factors can change, affecting all calcs
 
-    const collateralReservePk = mintCollateral ? market.getReserveByMint(mintCollateral)!.address : undefined;
-    const debtReservePk = mintDebt ? market.getReserveByMint(mintDebt)!.address : undefined;
     const debtReserveCumulativeBorrowRate = mintDebt
       ? market.getReserveByMint(mintDebt)!.getCumulativeBorrowRate()
       : undefined;
@@ -453,6 +502,14 @@ export class KaminoObligation {
     let newObligationDeposits = this.state.deposits;
     let newObligationBorrows = this.state.borrows;
 
+    // Print deposits and borrows before
+    for (const deposit of this.state.deposits) {
+      console.log(`Before Deposit: ${deposit.depositReserve.toBase58()} - ${deposit.depositedAmount}`);
+    }
+    for (const borrow of this.state.borrows) {
+      console.log(`Before Borrow: ${borrow.borrowReserve.toBase58()} - ${borrow.borrowedAmountSf}`);
+    }
+
     switch (action) {
       case 'deposit': {
         if (amountCollateral === undefined || mintCollateral === undefined) {
@@ -567,6 +624,14 @@ export class KaminoObligation {
       null
     );
 
+    // Print deposits and borrows after
+    for (const deposit of newObligationDeposits) {
+      console.log(`After Deposit: ${deposit.depositReserve.toBase58()} - ${deposit.depositedAmount}`);
+    }
+    for (const borrow of newObligationBorrows) {
+      console.log(`After Borrow: ${borrow.borrowReserve.toBase58()} - ${borrow.borrowedAmountSf}`);
+    }
+
     newStats = refreshedStats;
     newDeposits = deposits;
     newBorrows = borrows;
@@ -921,12 +986,17 @@ export class KaminoObligation {
       throw new Error('Reserve not found');
     }
 
-    const liquidityAvailable = reserve.getLiquidityAvailableForDebtReserveGivenCaps(market, [elevationGroup])[0];
+    const liquidityAvailable = reserve.getLiquidityAvailableForDebtReserveGivenCaps(
+      market,
+      [elevationGroup],
+      Array.from(this.deposits.keys())
+    )[0];
     const maxBorrowAmount = this.getBorrowPower(market, liquidityMint, slot, elevationGroup);
 
     if (elevationGroup === this.state.elevationGroup) {
       return Decimal.min(maxBorrowAmount, liquidityAvailable);
     } else {
+      // TODO: this is wrong, most liquidity caps are global, we should add up only the ones that are specific to this mode
       const { amount: debtThisReserve } = this.borrows.get(reserve.address) || { amount: new Decimal(0) };
       const liquidityAvailablePostMigration = Decimal.max(0, liquidityAvailable.minus(debtThisReserve));
       return Decimal.min(maxBorrowAmount, liquidityAvailablePostMigration);
@@ -1212,7 +1282,8 @@ export class KaminoObligation {
   public static getRatesForObligation(
     kaminoMarket: KaminoMarket,
     obligation: Obligation,
-    slot: number
+    slot: number,
+    additionalReserves: PublicKey[] = []
   ): {
     collateralExchangeRates: Map<PublicKey, Decimal>;
     cumulativeBorrowRates: Map<PublicKey, Decimal>;
@@ -1220,12 +1291,14 @@ export class KaminoObligation {
     const collateralExchangeRates = KaminoObligation.getCollateralExchangeRatesForObligation(
       kaminoMarket,
       obligation,
-      slot
+      slot,
+      additionalReserves
     );
     const cumulativeBorrowRates = KaminoObligation.getCumulativeBorrowRatesForObligation(
       kaminoMarket,
       obligation,
-      slot
+      slot,
+      additionalReserves
     );
 
     return {
@@ -1248,20 +1321,35 @@ export class KaminoObligation {
   static getCollateralExchangeRatesForObligation(
     kaminoMarket: KaminoMarket,
     obligation: Obligation,
-    slot: number
+    slot: number,
+    additionalReserves: PublicKey[]
   ): Map<PublicKey, Decimal> {
     const collateralExchangeRates = new PubkeyHashMap<PublicKey, Decimal>();
+
+    // Create a set of all reserves coming from deposit plus additional reserves
+    const allReserves = new Set<PublicKey>();
     for (let i = 0; i < obligation.deposits.length; i++) {
       const deposit = obligation.deposits[i];
-      if (isNotNullPubkey(deposit.depositReserve) && !collateralExchangeRates.has(deposit.depositReserve)) {
-        const reserve = kaminoMarket.getReserveByAddress(deposit.depositReserve)!;
-        const collateralExchangeRate = reserve.getEstimatedCollateralExchangeRate(
-          slot,
-          kaminoMarket.state.referralFeeBps
-        );
-        collateralExchangeRates.set(reserve.address, collateralExchangeRate);
+      if (isNotNullPubkey(deposit.depositReserve)) {
+        allReserves.add(deposit.depositReserve);
+      }
+    }
+    for (let i = 0; i < additionalReserves.length; i++) {
+      if (isNotNullPubkey(additionalReserves[i])) {
+        allReserves.add(additionalReserves[i]);
       }
     }
+
+    // Run through all reserves and get the exchange rate
+    for (const reserve of allReserves) {
+      const reserveInstance = kaminoMarket.getReserveByAddress(reserve)!;
+      const collateralExchangeRate = reserveInstance.getEstimatedCollateralExchangeRate(
+        slot,
+        kaminoMarket.state.referralFeeBps
+      );
+      collateralExchangeRates.set(reserve, collateralExchangeRate);
+    }
+
     return collateralExchangeRates;
   }
 
@@ -1284,16 +1372,39 @@ export class KaminoObligation {
     }
   }
 
-  static getCumulativeBorrowRatesForObligation(kaminoMarket: KaminoMarket, obligation: Obligation, slot: number) {
-    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
+  static getCumulativeBorrowRatesForObligation(
+    kaminoMarket: KaminoMarket,
+    obligation: Obligation,
+    slot: number,
+    additionalReserves: PublicKey[] = []
+  ): Map<PublicKey, Decimal> {
+    const allReserves = new Set<PublicKey>();
     for (let i = 0; i < obligation.borrows.length; i++) {
       const borrow = obligation.borrows[i];
-      if (isNotNullPubkey(borrow.borrowReserve) && !cumulativeBorrowRates.has(borrow.borrowReserve)) {
-        const reserve = kaminoMarket.getReserveByAddress(borrow.borrowReserve)!;
-        const cumulativeBorrowRate = reserve.getEstimatedCumulativeBorrowRate(slot, kaminoMarket.state.referralFeeBps);
-        cumulativeBorrowRates.set(reserve.address, cumulativeBorrowRate);
+      if (isNotNullPubkey(borrow.borrowReserve)) {
+        allReserves.add(borrow.borrowReserve);
       }
     }
+
+    // Add additional reserves
+    for (let i = 0; i < additionalReserves.length; i++) {
+      if (isNotNullPubkey(additionalReserves[i])) {
+        allReserves.add(additionalReserves[i]);
+      }
+    }
+
+    const cumulativeBorrowRates = new PubkeyHashMap<PublicKey, Decimal>();
+
+    // Run through all reserves and get the cumulative borrow rate
+    for (const reserve of allReserves) {
+      const reserveInstance = kaminoMarket.getReserveByAddress(reserve)!;
+      const cumulativeBorrowRate = reserveInstance.getEstimatedCumulativeBorrowRate(
+        slot,
+        kaminoMarket.state.referralFeeBps
+      );
+      cumulativeBorrowRates.set(reserve, cumulativeBorrowRate);
+    }
+
     return cumulativeBorrowRates;
   }
 

package/src/classes/reserve.ts

@@ -570,7 +570,7 @@ export class KaminoReserve {
     return Decimal.max(new Decimal(0), maxBorrowAmount);
   }
 
-  calcSimulatedBorrowAPR(
+  calcSimulatedBorrowRate(
     amount: Decimal,
     action: ActionType,
     slot: number,
@@ -580,7 +580,20 @@ export class KaminoReserve {
     const slotAdjustmentFactor = this.slotAdjustmentFactor();
     const newUtilization = this.calcSimulatedUtilizationRatio(amount, action, slot, referralFeeBps, outflowAmount);
     const curve = truncateBorrowCurve(this.state.config.borrowRateCurve.points);
-    return getBorrowRate(newUtilization, curve) * slotAdjustmentFactor + this.getFixedHostInterestRate().toNumber();
+    return getBorrowRate(newUtilization, curve) * slotAdjustmentFactor;
+  }
+
+  calcSimulatedBorrowAPR(
+    amount: Decimal,
+    action: ActionType,
+    slot: number,
+    referralFeeBps: number,
+    outflowAmount?: Decimal
+  ) {
+    return (
+      this.calcSimulatedBorrowRate(amount, action, slot, referralFeeBps, outflowAmount) +
+      this.getFixedHostInterestRate().toNumber()
+    );
   }
 
   calcSimulatedSupplyAPR(
@@ -591,7 +604,7 @@ export class KaminoReserve {
     outflowAmount?: Decimal
   ) {
     const newUtilization = this.calcSimulatedUtilizationRatio(amount, action, slot, referralFeeBps, outflowAmount);
-    const simulatedBorrowAPR = this.calcSimulatedBorrowAPR(amount, action, slot, referralFeeBps, outflowAmount);
+    const simulatedBorrowAPR = this.calcSimulatedBorrowRate(amount, action, slot, referralFeeBps, outflowAmount);
     const protocolTakeRatePct = 1 - this.state.config.protocolTakeRatePct / 100;
 
     return newUtilization * simulatedBorrowAPR * protocolTakeRatePct;
@@ -1033,7 +1046,11 @@ export class KaminoReserve {
   }
 
   /* This takes into account all the caps */
-  getLiquidityAvailableForDebtReserveGivenCaps(market: KaminoMarket, elevationGroups: number[]): Decimal[] {
+  getLiquidityAvailableForDebtReserveGivenCaps(
+    market: KaminoMarket,
+    elevationGroups: number[],
+    collateralReserves: PublicKey[] = []
+  ): Decimal[] {
     const caps = this.getBorrowCapForReserve(market);
 
     const liquidityAvailable = this.getLiquidityAvailableAmount();
@@ -1069,7 +1086,16 @@ export class KaminoReserve {
           (x) => x.elevationGroup === elevationGroup
         );
         if (capsGivenEgroup.length > 0) {
-          remainingInsideEmodeCaps = Decimal.min(...capsGivenEgroup.map((x) => x.maxDebt.minus(x.currentValue)));
+          remainingInsideEmodeCaps = Decimal.min(
+            ...capsGivenEgroup.map((x) => {
+              // check reserve is part of collReserves array
+              if (collateralReserves.find((collateralReserve) => collateralReserve.equals(x.collateralReserve))) {
+                return x.maxDebt.minus(x.currentValue);
+              } else {
+                return new Decimal(U64_MAX);
+              }
+            })
+          );
         }
         return Decimal.min(
           positiveOrZero(liquidityAvailable),

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -77,7 +77,11 @@ export function calcMaxWithdrawCollateral(
   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);
+  const remainingDebtBfWeightedValue = remainingDebtAmountLamports
+    .ceil()
+    .div(debtReserve.getMintFactor())
+    .mul(debtBorrowFactor)
+    .mul(debtOraclePx);
 
   let isClosingPosition = false;
   if (remainingDebtAmountLamports.lte(new Decimal(0)) && obligation.getBorrows().length === 1) {

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -132,7 +132,11 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   const swapQuote = await quoter(swapQuoteInputs, uniqueKlendAccounts);
 
   const swapQuotePxDebtToColl = swapQuote.priceAInB;
-  const collSwapInLamports = flashRepayAmountLamports.div(debtReserve.getMintFactor()).div(swapQuotePxDebtToColl).mul(collReserve.getMintFactor()).ceil();
+  const collSwapInLamports = flashRepayAmountLamports
+    .div(debtReserve.getMintFactor())
+    .div(swapQuotePxDebtToColl)
+    .mul(collReserve.getMintFactor())
+    .ceil();
 
   return {
     swapInputs: {