@kamino-finance/klend-sdk 7.0.6 → 7.0.8

package/src/classes/action.ts

@@ -330,7 +330,7 @@ export class KaminoAction {
     );
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addRefreshObligation(payer);
@@ -363,7 +363,7 @@ export class KaminoAction {
     );
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addRefreshObligation(owner);
@@ -404,7 +404,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -467,7 +467,7 @@ export class KaminoAction {
     );
     const addInitObligationForFarm = true;
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     if (isSome(axn.referrer)) {
@@ -529,7 +529,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -572,7 +572,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -620,7 +620,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -679,7 +679,7 @@ export class KaminoAction {
     const twoTokenAction = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     if (isSome(axn.referrer)) {
@@ -776,7 +776,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
     const twoTokenAction = true;
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -830,7 +830,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
     const twoTokenAction = true;
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -886,7 +886,7 @@ export class KaminoAction {
     const addInitObligationForFarmForWithdraw = false;
     const twoTokenAction = true;
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -975,7 +975,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     axn.depositReserves.push(...(obligationCustomizations?.addedDepositReserves || []));
@@ -1054,7 +1054,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -1114,7 +1114,7 @@ export class KaminoAction {
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
-      axn.addComputeBudgetIxn(extraComputeBudget);
+      axn.addComputeBudgetIx(extraComputeBudget);
     }
 
     await axn.addSupportIxs(
@@ -3082,7 +3082,7 @@ export class KaminoAction {
     this.lendingIxsLabels.push(`WithdrawReferrerFeesIx[${this.owner.toString()}]`);
   }
 
-  private addComputeBudgetIxn(units: number) {
+  private addComputeBudgetIx(units: number) {
     this.computeBudgetIxs.push(buildComputeBudgetIx(units));
     this.computeBudgetIxsLabels.push(`AddComputeBudget[${units}]`);
   }

package/src/classes/manager.ts

@@ -1042,7 +1042,15 @@ export class KaminoManager {
     currentSlot?: Slot,
     tokensPrices?: Map<Address, Decimal>
   ): Promise<VaultOverview> {
-    return this._vaultClient.getVaultOverview(vault, price, slot, vaultReserves, kaminoMarkets, currentSlot, tokensPrices);
+    return this._vaultClient.getVaultOverview(
+      vault,
+      price,
+      slot,
+      vaultReserves,
+      kaminoMarkets,
+      currentSlot,
+      tokensPrices
+    );
   }
 
   /**
@@ -1205,6 +1213,21 @@ export class KaminoManager {
     return this._vaultClient.getVaultRewardsAPY(vault, vaultTokenPrice, farmsClient, slot);
   }
 
+  /**
+   * Get all the token mints of the vault, vault farm rewards and the allocation  rewards
+   * @param vaults - the vaults to get the token mints for
+   * @param [vaultReservesMap] - the vault reserves map to get the reserves for; if not provided, the function will fetch the reserves
+   * @param farmsMap - the farms map to get the farms for
+   * @returns a set of token mints
+   */
+  async getAllVaultsTokenMintsIncludingRewards(
+    vaults: KaminoVault[],
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmsMap?: Map<Address, FarmState>
+  ) {
+    return this._vaultClient.getAllVaultsTokenMintsIncludingRewards(vaults, vaultReservesMap, farmsMap);
+  }
+
   /**
    * This will return the APY of the reserve farms (debt and supply)
    * @param reserve - the reserve to get the farms APY for

package/src/classes/obligation.ts

@@ -1399,6 +1399,13 @@ export class KaminoObligation {
       throw new Error('Reserve not found');
     }
 
+    const reserveAvailableLiquidity = depositReserve.getLiquidityAvailableAmount();
+    const withdrawalCapRemained = depositReserve
+      .getDepositWithdrawalCapCapacity()
+      .sub(depositReserve.getDepositWithdrawalCapCurrent(slot));
+
+    const reserveWithdrawalLimit = Decimal.min(withdrawalCapRemained, reserveAvailableLiquidity);
+
     const userDepositPosition = this.getDepositByReserve(depositReserve.address);
 
     if (!userDepositPosition) {
@@ -1408,7 +1415,7 @@ export class KaminoObligation {
     const userDepositPositionAmount = userDepositPosition.amount;
 
     if (this.refreshedStats.userTotalBorrowBorrowFactorAdjusted.equals(new Decimal(0))) {
-      return new Decimal(userDepositPositionAmount);
+      return Decimal.max(0, Decimal.min(userDepositPositionAmount, reserveWithdrawalLimit));
     }
 
     const { maxLtv: reserveMaxLtv } = KaminoObligation.getLtvForReserve(
@@ -1436,15 +1443,8 @@ export class KaminoObligation {
     const maxWithdrawAmount = maxWithdrawValue
       .div(depositReserve.getOracleMarketPrice())
       .mul(depositReserve.getMintFactor());
-    const reserveAvailableLiquidity = depositReserve.getLiquidityAvailableAmount();
 
-    const withdrawalCapRemained = depositReserve
-      .getDepositWithdrawalCapCapacity()
-      .sub(depositReserve.getDepositWithdrawalCapCurrent(slot));
-    return Decimal.max(
-      0,
-      Decimal.min(userDepositPositionAmount, maxWithdrawAmount, reserveAvailableLiquidity, withdrawalCapRemained)
-    );
+    return Decimal.max(0, Decimal.min(userDepositPositionAmount, maxWithdrawAmount, reserveWithdrawalLimit));
   }
 
   getObligationLiquidityByReserve(reserveAddress: Address): ObligationLiquidity {

package/src/classes/vault.ts

@@ -1545,7 +1545,6 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     createAtaIfNeeded: boolean = true
   ): Promise<IInstruction[]> {
-    console.log('create invest ix for reserve', reserve.address);
     const vaultState = await vault.getState(this.getConnection());
     const cTokenVault = await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const [lendingMarketAuth] = await lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId);
@@ -3082,6 +3081,106 @@ export class KaminoVaultClient {
     return getFarmIncentives(kFarmsClient, vaultState.vaultFarm, sharePrice, stakedTokenMintDecimals, tokensPrices);
   }
 
+  /**
+   * Get all the token mints of the vault, vault farm rewards and the allocation  rewards
+   * @param vaults - the vaults to get the token mints for
+   * @param [vaultReservesMap] - the vault reserves map to get the reserves for; if not provided, the function will fetch the reserves
+   * @param farmsMap - the farms map to get the farms for
+   * @returns a set of token mints
+   */
+  async getAllVaultsTokenMintsIncludingRewards(
+    vaults: KaminoVault[],
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmsMap?: Map<Address, FarmState>
+  ) {
+    const vaultsTokenMints = new Set<Address>();
+
+    const kFarmsMap = farmsMap ? farmsMap : new Map<Address, FarmState>();
+
+    const farmsToFetch = new Set<Address>();
+    const reservesToFetch = new Set<Address>();
+
+    for (const vault of vaults) {
+      const vaultState = await vault.getState(this.getConnection());
+      vaultsTokenMints.add(vaultState.tokenMint);
+      const hasFarm = await vault.hasFarm(this.getConnection());
+      if (hasFarm) {
+        const farmAddress = vaultState.vaultFarm;
+        if (!kFarmsMap.has(farmAddress)) {
+          farmsToFetch.add(farmAddress);
+        } else {
+          const farmState = kFarmsMap.get(farmAddress)!;
+          farmState.rewardInfos.forEach((rewardInfo) => {
+            if (rewardInfo.token.mint !== DEFAULT_PUBLIC_KEY) {
+              vaultsTokenMints.add(rewardInfo.token.mint);
+            }
+          });
+        }
+      }
+
+      const reserves = vaultState.vaultAllocationStrategy.map((allocationStrategy) => allocationStrategy.reserve);
+      reserves.forEach((reserve) => {
+        if (reserve === DEFAULT_PUBLIC_KEY) {
+          return;
+        }
+
+        if (vaultReservesMap && !vaultReservesMap.has(reserve)) {
+          const reserveState = vaultReservesMap.get(reserve)!;
+          const supplyFarm = reserveState.state.farmCollateral;
+          if (supplyFarm !== DEFAULT_PUBLIC_KEY) {
+            if (!kFarmsMap.has(supplyFarm)) {
+              farmsToFetch.add(supplyFarm);
+            } else {
+              const farmState = kFarmsMap.get(supplyFarm)!;
+              farmState.rewardInfos.forEach((rewardInfo) => {
+                if (rewardInfo.token.mint !== DEFAULT_PUBLIC_KEY) {
+                  vaultsTokenMints.add(rewardInfo.token.mint);
+                }
+              });
+            }
+          }
+        } else {
+          reservesToFetch.add(reserve);
+        }
+      });
+    }
+
+    // fetch the reserves first so we can add their farms to farms to be fetched, if needed
+    const missingReservesStates = await Reserve.fetchMultiple(this.getConnection(), Array.from(reservesToFetch));
+
+    missingReservesStates.forEach((reserveState) => {
+      if (reserveState) {
+        const supplyFarm = reserveState.farmCollateral;
+        if (supplyFarm !== DEFAULT_PUBLIC_KEY) {
+          if (!kFarmsMap.has(supplyFarm)) {
+            farmsToFetch.add(supplyFarm);
+          } else {
+            const farmState = kFarmsMap.get(supplyFarm)!;
+            farmState.rewardInfos.forEach((rewardInfo) => {
+              if (rewardInfo.token.mint !== DEFAULT_PUBLIC_KEY) {
+                vaultsTokenMints.add(rewardInfo.token.mint);
+              }
+            });
+          }
+        }
+      }
+    });
+
+    // fetch the missing farms
+    const missingFarmsStates = await FarmState.fetchMultiple(this.getConnection(), Array.from(farmsToFetch));
+    missingFarmsStates.forEach((farmState) => {
+      if (farmState) {
+        farmState.rewardInfos.forEach((rewardInfo) => {
+          if (rewardInfo.token.mint !== DEFAULT_PUBLIC_KEY) {
+            vaultsTokenMints.add(rewardInfo.token.mint);
+          }
+        });
+      }
+    });
+
+    return vaultsTokenMints;
+  }
+
   async getVaultReservesFarmsIncentives(
     vaultOrState: KaminoVault | VaultState,
     vaultTokenPrice: Decimal,

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -120,27 +120,31 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   const inputAmountLamports = Decimal.min(maxWithdrawableCollLamports, maxCollNeededFromOracle);
 
   // Build the repay & withdraw collateral tx to get the number of accounts
-  const klendIxs: LeverageIxsOutput = await buildRepayWithCollateralIxs(
-    kaminoMarket,
-    debtReserve,
-    collReserve,
-    owner,
-    obligation,
-    referrer,
-    currentSlot,
-    budgetAndPriorityFeeIxs,
-    scopeRefreshConfig,
-    {
-      preActionIxs: [],
-      swapIxs: [],
-      lookupTables: [],
-      quote: {} as SwapQuote<QuoteResponse>,
-    },
-    isClosingPosition,
-    repayAmountLamports,
-    inputAmountLamports,
-    useV2Ixs
-  );
+  const klendIxs: LeverageIxsOutput = (
+    await buildRepayWithCollateralIxs(
+      kaminoMarket,
+      debtReserve,
+      collReserve,
+      owner,
+      obligation,
+      referrer,
+      currentSlot,
+      budgetAndPriorityFeeIxs,
+      scopeRefreshConfig,
+      [
+        {
+          preActionIxs: [],
+          swapIxs: [],
+          lookupTables: [],
+          quote: {} as SwapQuote<QuoteResponse>,
+        },
+      ],
+      isClosingPosition,
+      repayAmountLamports,
+      inputAmountLamports,
+      useV2Ixs
+    )
+  )[0];
   const uniqueKlendAccounts = uniqueAccountsWithProgramIds(klendIxs.instructions);
 
   const swapQuoteInputs: SwapInputs = {
@@ -244,35 +248,33 @@ export async function getRepayWithCollIxs<QuoteResponse>({
 
   const swapResponses = await swapper(swapInputs, initialInputs.klendAccounts, swapQuote);
 
-  return Promise.all(
-    swapResponses.map(async (swapResponse) => {
-      const ixs: LeverageIxsOutput = await buildRepayWithCollateralIxs(
-        kaminoMarket,
-        debtReserve,
-        collReserve,
-        owner,
-        obligation,
-        referrer,
-        currentSlot,
-        budgetAndPriorityFeeIxs,
-        scopeRefreshConfig,
-        swapResponse,
-        isClosingPosition,
-        debtRepayAmountLamports,
-        swapInputs.inputAmountLamports,
-        useV2Ixs
-      );
-
-      return {
-        ixs: ixs.instructions,
-        lookupTables: swapResponse.lookupTables,
-        swapInputs,
-        flashLoanInfo: ixs.flashLoanInfo,
-        initialInputs,
-        quote: swapResponse.quote.quoteResponse,
-      };
-    })
+  const repayWithCollateralIxs = await buildRepayWithCollateralIxs(
+    kaminoMarket,
+    debtReserve,
+    collReserve,
+    owner,
+    obligation,
+    referrer,
+    currentSlot,
+    budgetAndPriorityFeeIxs,
+    scopeRefreshConfig,
+    swapResponses,
+    isClosingPosition,
+    debtRepayAmountLamports,
+    swapInputs.inputAmountLamports,
+    useV2Ixs
   );
+
+  return repayWithCollateralIxs.map((ixs, index) => {
+    return {
+      ixs: ixs.instructions,
+      lookupTables: swapResponses[index].lookupTables,
+      swapInputs,
+      flashLoanInfo: ixs.flashLoanInfo,
+      initialInputs,
+      quote: swapResponses[index].quote.quoteResponse,
+    };
+  });
 }
 
 async function buildRepayWithCollateralIxs<QuoteResponse>(
@@ -285,12 +287,12 @@ async function buildRepayWithCollateralIxs<QuoteResponse>(
   currentSlot: Slot,
   budgetAndPriorityFeeIxs: IInstruction[] | undefined,
   scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-  swapQuoteIxs: SwapIxs<QuoteResponse>,
+  swapQuoteIxsArray: SwapIxs<QuoteResponse>[],
   isClosingPosition: boolean,
   debtRepayAmountLamports: Decimal,
   collWithdrawLamports: Decimal,
   useV2Ixs: boolean
-): Promise<LeverageIxsOutput> {
+): Promise<LeverageIxsOutput[]> {
   // 1. Create atas & budget txns
   const budgetIxs = budgetAndPriorityFeeIxs || getComputeBudgetAndPriorityFeeIxs(1_400_000);
 
@@ -369,29 +371,31 @@ async function buildRepayWithCollateralIxs<QuoteResponse>(
   }
 
   // 4. Swap collateral to debt to repay flash loan
-  const { preActionIxs, swapIxs } = swapQuoteIxs;
-  const swapInstructions = removeBudgetIxs(swapIxs);
-
-  const ixs = [
-    ...scopeRefreshIx,
-    ...budgetIxs,
-    ...atasAndIxs.map((x) => x.createAtaIx),
-    flashBorrowIx,
-    ...preActionIxs,
-    ...KaminoAction.actionToIxs(repayAndWithdrawAction),
-    ...swapInstructions,
-    flashRepayIx,
-  ];
-
-  const res: LeverageIxsOutput = {
-    flashLoanInfo: {
-      flashBorrowReserve: debtReserve.address,
-      flashLoanFee: debtReserve.getFlashLoanFee(),
-    },
-    instructions: ixs,
-  };
-
-  return res;
+  return swapQuoteIxsArray.map((swapQuoteIxs) => {
+    const { preActionIxs, swapIxs } = swapQuoteIxs;
+    const swapInstructions = removeBudgetIxs(swapIxs);
+
+    const ixs = [
+      ...scopeRefreshIx,
+      ...budgetIxs,
+      ...atasAndIxs.map((x) => x.createAtaIx),
+      flashBorrowIx,
+      ...preActionIxs,
+      ...KaminoAction.actionToIxs(repayAndWithdrawAction),
+      ...swapInstructions,
+      flashRepayIx,
+    ];
+
+    const res: LeverageIxsOutput = {
+      flashLoanInfo: {
+        flashBorrowReserve: debtReserve.address,
+        flashLoanFee: debtReserve.getFlashLoanFee(),
+      },
+      instructions: ixs,
+    };
+
+    return res;
+  });
 }
 
 export const getMaxWithdrawLtvCheck = (

package/src/lending_operations/swap_collateral_operations.ts

@@ -164,7 +164,16 @@ export async function getSwapCollIxs<QuoteResponse>(
   //  - To construct 1. (i.e. flash-borrow), we need to know the target collateral swap-out from 4.
 
   // Construct the Klend's own ixs with a fake swap-out (only to learn the klend accounts used):
-  const fakeKlendIxs = await getKlendIxs(args, FAKE_TARGET_COLL_SWAP_OUT_AMOUNT, context);
+
+  const scopeRefreshIx = await getScopeRefreshIx(
+    context.market,
+    context.sourceCollReserve,
+    context.targetCollReserve,
+    context.obligation,
+    context.scopeRefreshConfig
+  );
+
+  const fakeKlendIxs = await getKlendIxs(args, FAKE_TARGET_COLL_SWAP_OUT_AMOUNT, context, scopeRefreshIx);
   const klendAccounts = uniqueAccountsWithProgramIds(listIxs(fakeKlendIxs));
 
   // Construct the external swap ixs (and learn the actual swap-out amount):
@@ -179,7 +188,7 @@ export async function getSwapCollIxs<QuoteResponse>(
       checkResultingObligationValid(args, externalSwapIxs.swapOutAmount, context);
 
       // Construct the Klend's own ixs with an actual swap-out amount:
-      const klendIxs = await getKlendIxs(args, externalSwapIxs.swapOutAmount, context);
+      const klendIxs = await getKlendIxs(args, externalSwapIxs.swapOutAmount, context, scopeRefreshIx);
 
       return {
         ixs: listIxs(klendIxs, externalSwapIxs.ixs),
@@ -275,21 +284,14 @@ type SwapCollKlendIxs = {
 async function getKlendIxs(
   args: SwapCollArgs,
   targetCollSwapOutAmount: Decimal,
-  context: SwapCollContext<any>
+  context: SwapCollContext<any>,
+  scopeRefreshIx: IInstruction[]
 ): Promise<SwapCollKlendIxs> {
   const { ataCreationIxs, targetCollAta } = await getAtaCreationIxs(context);
   const setupIxs = [...context.budgetAndPriorityFeeIxs, ...ataCreationIxs];
 
-  const scopeRefreshIxn = await getScopeRefreshIx(
-    context.market,
-    context.sourceCollReserve,
-    context.targetCollReserve,
-    context.obligation,
-    context.scopeRefreshConfig
-  );
-
-  if (scopeRefreshIxn) {
-    setupIxs.unshift(...scopeRefreshIxn);
+  if (scopeRefreshIx) {
+    setupIxs.unshift(...scopeRefreshIx);
   }
 
   const targetCollFlashBorrowedAmount = calculateTargetCollFlashBorrowedAmount(targetCollSwapOutAmount, context);