@kamino-finance/klend-sdk 5.2.1 → 5.2.3

package/src/classes/vault.ts

@@ -18,8 +18,6 @@ import {
   KaminoMarket,
   KaminoReserve,
   lamportsToDecimal,
-  LendingMarket,
-  MarketWithAddress,
   PubkeyHashMap,
   Reserve,
   WRAPPED_SOL_MINT,
@@ -50,7 +48,7 @@ import {
 import { VaultConfigFieldKind } from '../idl_codegen_kamino_vault/types';
 import { VaultState } from '../idl_codegen_kamino_vault/accounts';
 import Decimal from 'decimal.js';
-import { getTokenBalanceFromAccountInfoLamports, numberToLamportsDecimal, parseTokenSymbol } from './utils';
+import { bpsToPct, getTokenBalanceFromAccountInfoLamports, numberToLamportsDecimal, parseTokenSymbol } from './utils';
 import { deposit } from '../idl_codegen_kamino_vault/instructions';
 import { withdraw } from '../idl_codegen_kamino_vault/instructions';
 import { PROGRAM_ID } from '../idl_codegen/programId';
@@ -348,22 +346,12 @@ export class KaminoVaultClient {
         }
 
         const reserveState = reserveStates[index]!;
-
-        const market = reserveState.lendingMarket;
-        const marketState = await LendingMarket.fetch(this._connection, market, this._kaminoLendProgramId);
-        if (marketState === null) {
-          throw new Error(`Market ${market.toBase58()} not found`);
-        }
-
-        const marketWithAddress = {
-          address: market,
-          state: marketState,
-        };
+        const marketAddress = reserveState.lendingMarket;
 
         return this.withdrawPendingFeesIxn(
           vault,
           vaultState,
-          marketWithAddress,
+          marketAddress,
           { address: reserve, state: reserveState },
           adminTokenAta
         );
@@ -389,7 +377,6 @@ export class KaminoVaultClient {
    * @param user - user to deposit
    * @param vault - vault to deposit into
    * @param tokenAmount - token amount to be deposited, in decimals (will be converted in lamports)
-   * @param tokenProgramIDOverride - optional param; should be passed if token to be deposited is token22
    * @param vaultReservesMap - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @returns - an array of instructions to be used to be executed
    */
@@ -397,12 +384,11 @@ export class KaminoVaultClient {
     user: PublicKey,
     vault: KaminoVault,
     tokenAmount: Decimal,
-    tokenProgramIDOverride?: PublicKey,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
   ): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this._connection);
 
-    const tokenProgramID = tokenProgramIDOverride ? tokenProgramIDOverride : TOKEN_PROGRAM_ID;
+    const tokenProgramID = vaultState.tokenProgram;
     const userTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, user, true, tokenProgramID);
     const createAtasIxns: TransactionInstruction[] = [];
     const closeAtasIxns: TransactionInstruction[] = [];
@@ -487,15 +473,18 @@ export class KaminoVaultClient {
     user: PublicKey,
     vault: KaminoVault,
     shareAmount: Decimal,
-    slot: number
+    slot: number,
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
   ): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this._connection);
 
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+
     const userSharesAta = getAssociatedTokenAddress(vaultState.sharesMint, user);
     const [{ ata: userTokenAta, createAtaIx }] = createAtasIdempotent(user, [
       {
         mint: vaultState.tokenMint,
-        tokenProgram: TOKEN_PROGRAM_ID,
+        tokenProgram: vaultState.tokenProgram,
       },
     ]);
 
@@ -531,40 +520,31 @@ export class KaminoVaultClient {
       });
     }
 
-    const reserveStates = await Reserve.fetchMultiple(this._connection, reservesToWithdraw, this._kaminoLendProgramId);
-    const withdrawIxns: TransactionInstruction[] = await Promise.all(
-      reservesToWithdraw.map(async (reserve, index) => {
-        if (reserveStates[index] === null) {
-          throw new Error(`Reserve ${reserve.toBase58()} not found`);
-        }
-
-        const reserveState = reserveStates[index]!;
+    const withdrawIxns: TransactionInstruction[] = [];
+    withdrawIxns.push(createAtaIx);
 
-        const market = reserveState.lendingMarket;
-        const marketState = await LendingMarket.fetch(this._connection, market, this._kaminoLendProgramId);
-        if (marketState === null) {
-          throw new Error(`Market ${market.toBase58()} not found`);
-        }
-
-        const marketWithAddress = {
-          address: market,
-          state: marketState,
-        };
+    reservesToWithdraw.forEach((reserve, index) => {
+      const reserveState = vaultReservesState.get(reserve);
+      if (reserveState === undefined) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found in vault reserves map`);
+      }
 
-        return this.withdrawIxn(
-          user,
-          vault,
-          vaultState,
-          marketWithAddress,
-          { address: reserve, state: reserveState },
-          userSharesAta,
-          userTokenAta,
-          amountToWithdraw[index]
-        );
-      })
-    );
+      const marketAddress = reserveState.state.lendingMarket;
+      const withdrawFromReserveIx = this.withdrawIxn(
+        user,
+        vault,
+        vaultState,
+        marketAddress,
+        { address: reserve, state: reserveState.state },
+        userSharesAta,
+        userTokenAta,
+        amountToWithdraw[index],
+        vaultReservesState
+      );
+      withdrawIxns.push(withdrawFromReserveIx);
+    });
 
-    return [createAtaIx, ...withdrawIxns];
+    return withdrawIxns;
   }
 
   /**
@@ -646,17 +626,18 @@ export class KaminoVaultClient {
     return [createAtaIx, investIx];
   }
 
-  private async withdrawIxn(
+  private withdrawIxn(
     user: PublicKey,
     vault: KaminoVault,
     vaultState: VaultState,
-    marketWithAddress: MarketWithAddress,
+    marketAddress: PublicKey,
     reserve: ReserveWithAddress,
     userSharesAta: PublicKey,
     userTokenAta: PublicKey,
-    shareAmountLamports: Decimal
-  ): Promise<TransactionInstruction> {
-    const lendingMarketAuth = lendingMarketAuthPda(marketWithAddress.address, this._kaminoLendProgramId)[0];
+    shareAmountLamports: Decimal,
+    vaultReservesState: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): TransactionInstruction {
+    const lendingMarketAuth = lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId)[0];
 
     const withdrawAccounts: WithdrawAccounts = {
       user: user,
@@ -672,7 +653,7 @@ export class KaminoVaultClient {
       reserve: reserve.address,
       ctokenVault: getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
       /** CPI accounts */
-      lendingMarket: marketWithAddress.address,
+      lendingMarket: marketAddress,
       lendingMarketAuthority: lendingMarketAuth,
       reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
       reserveCollateralMint: reserve.state.collateral.mintPubkey,
@@ -688,7 +669,6 @@ export class KaminoVaultClient {
     const withdrawIxn = withdraw(withdrawArgs, withdrawAccounts, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
-    const vaultReservesState = await this.loadVaultReserves(vaultState);
 
     let vaultReservesAccountMetas: AccountMeta[] = [];
     let vaultReservesLendingMarkets: AccountMeta[] = [];
@@ -715,11 +695,11 @@ export class KaminoVaultClient {
   private async withdrawPendingFeesIxn(
     vault: KaminoVault,
     vaultState: VaultState,
-    marketWithAddress: MarketWithAddress,
+    marketAddress: PublicKey,
     reserve: ReserveWithAddress,
     adminTokenAta: PublicKey
   ): Promise<TransactionInstruction> {
-    const lendingMarketAuth = lendingMarketAuthPda(marketWithAddress.address, this._kaminoLendProgramId)[0];
+    const lendingMarketAuth = lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId)[0];
 
     const withdrawPendingFeesAccounts: WithdrawPendingFeesAccounts = {
       adminAuthority: vaultState.adminAuthority,
@@ -732,7 +712,7 @@ export class KaminoVaultClient {
       tokenMint: vaultState.tokenMint,
       tokenProgram: TOKEN_PROGRAM_ID,
       /** CPI accounts */
-      lendingMarket: marketWithAddress.address,
+      lendingMarket: marketAddress,
       lendingMarketAuthority: lendingMarketAuth,
       reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
       reserveCollateralMint: reserve.state.collateral.mintPubkey,
@@ -829,6 +809,18 @@ export class KaminoVaultClient {
     return vaultUserShareBalance;
   }
 
+  /**
+   * This method returns the management and performance fee percentages
+   * @param vaultState - vault to retrieve the fees percentages from
+   * @returns - VaultFeesPct containing management and performance fee percentages
+   */
+  getVaultFeesPct(vaultState: VaultState): VaultFeesPct {
+    return {
+      managementFeePct: bpsToPct(new Decimal(vaultState.managementFeeBps.toString())),
+      performanceFeePct: bpsToPct(new Decimal(vaultState.performanceFeeBps.toString())),
+    };
+  }
+
   /**
    * This method calculates the token per shar value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
    * @param vault - vault to calculate tokensPerShare for
@@ -1038,15 +1030,32 @@ export class KaminoVaultClient {
    *
    * @returns a hashmap from each reserve pubkey to the market overview of the collaterals that can be used and the min and max loan to value ratio in that market
    */
-  async getVaultCollaterals(vaultState: VaultState, slot: number): Promise<PubkeyHashMap<PublicKey, MarketOverview>> {
-    const vaultReservesState = Array.from((await this.loadVaultReserves(vaultState)).values());
+  async getVaultCollaterals(
+    vaultState: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    kaminoMarkets?: KaminoMarket[]
+  ): Promise<PubkeyHashMap<PublicKey, MarketOverview>> {
+    const vaultReservesStateMap = vaultReserves ? vaultReserves : await this.loadVaultReserves(vaultState);
+    const vaultReservesState = Array.from(vaultReservesStateMap.values());
 
     const vaultCollateralsPerReserve: PubkeyHashMap<PublicKey, MarketOverview> = new PubkeyHashMap();
 
     for (const reserve of vaultReservesState) {
-      const lendingMarket = await KaminoMarket.load(this._connection, reserve.state.lendingMarket, slot);
+      // try to read the market from the provided list, if it doesn't exist fetch it
+      let lendingMarket: KaminoMarket | undefined = undefined;
+      if (kaminoMarkets) {
+        lendingMarket = kaminoMarkets?.find((market) =>
+          reserve.state.lendingMarket.equals(new PublicKey(market.address))
+        );
+      }
+
       if (!lendingMarket) {
-        throw Error(`Could not fetch lending market ${reserve.state.lendingMarket.toBase58()}`);
+        const fetchedLendingMarket = await KaminoMarket.load(this._connection, reserve.state.lendingMarket, slot);
+        if (!fetchedLendingMarket) {
+          throw Error(`Could not fetch lending market ${reserve.state.lendingMarket.toBase58()}`);
+        }
+        lendingMarket = fetchedLendingMarket;
       }
 
       const marketReserves = lendingMarket.getReserves();
@@ -1060,7 +1069,9 @@ export class KaminoVaultClient {
       marketReserves
         .filter((marketReserve) => {
           return (
-            marketReserve.state.config.liquidationThresholdPct > 0 && !marketReserve.address.equals(reserve.address)
+            marketReserve.state.config.liquidationThresholdPct > 0 &&
+            !marketReserve.address.equals(reserve.address) &&
+            marketReserve.state.config.status === 0
           );
         })
         .map((filteredReserve) => {
@@ -1162,6 +1173,109 @@ export class KaminoVaultClient {
       availableUSD: holdings.available.mul(price),
       investedUSD: holdings.invested.mul(price),
       investedInReservesUSD: investedInReservesUSD,
+      totalUSD: holdings.total.mul(price),
+    };
+  }
+
+  /**
+   * This will return an VaultOverview object that encapsulates all the information about the vault, including the holdings, reserves details, theoretical APY, utilization ratio and total borrowed amount
+   * @param vault - the kamino vault to get available liquidity to withdraw for
+   * @param slot - current slot
+   * @param price - the price of the token in the vault (e.g. USDC)
+   * @param vaultReserves - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @param kaminoMarkets - optional parameter; a list of all kamino markets. If provided the function will be significantly faster as it will not have to fetch the markets
+   * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
+   */
+  async getVaultOverview(
+    vault: VaultState,
+    slot: number,
+    price: Decimal,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    kaminoMarkets?: KaminoMarket[]
+  ): Promise<VaultOverview> {
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+
+    const vaultHoldingsWithUSDValuePromise = await this.getVaultHoldingsWithPrice(
+      vault,
+      slot,
+      price,
+      vaultReservesState
+    );
+    const vaultTheoreticalAPYPromise = await this.getVaultTheoreticalAPY(vault, slot, vaultReservesState);
+    const totalInvestedAndBorrowedPromise = await this.getTotalBorrowedAndInvested(vault, slot, vaultReservesState);
+    const vaultCollateralsPromise = await this.getVaultCollaterals(vault, slot, vaultReservesState, kaminoMarkets);
+    const reservesOverviewPromise = await this.getVaultReservesDetails(vault, slot, vaultReservesState);
+
+    // all the async part of the functions above just read the vaultReservesState which is read beforehand, so excepting vaultCollateralsPromise they should do no additional network calls
+    const [
+      vaultHoldingsWithUSDValue,
+      vaultTheoreticalAPY,
+      totalInvestedAndBorrowed,
+      vaultCollaterals,
+      reservesOverview,
+    ] = await Promise.all([
+      vaultHoldingsWithUSDValuePromise,
+      vaultTheoreticalAPYPromise,
+      totalInvestedAndBorrowedPromise,
+      vaultCollateralsPromise,
+      reservesOverviewPromise,
+    ]);
+
+    return {
+      holdingsUSD: vaultHoldingsWithUSDValue,
+      reservesOverview: reservesOverview,
+      vaultCollaterals: vaultCollaterals,
+      theoreticalSupplyAPY: vaultTheoreticalAPY,
+      totalBorrowed: totalInvestedAndBorrowed.totalBorrowed,
+      utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
+    };
+  }
+
+  /**
+   * This will return an aggregation of the current state of the vault with all the invested amounts and the utilization ratio of the vault
+   * @param vault - the kamino vault to get available liquidity to withdraw for
+   * @param slot - current slot
+   * @param vaultReserves - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @returns an VaultReserveTotalBorrowedAndInvested object with the total invested amount, total borrowed amount and the utilization ratio of the vault
+   */
+  async getTotalBorrowedAndInvested(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<VaultReserveTotalBorrowedAndInvested> {
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+
+    let totalInvested = new Decimal(0);
+    let totalBorrowed = new Decimal(0);
+
+    vault.vaultAllocationStrategy.forEach((allocationStrategy) => {
+      if (allocationStrategy.reserve.equals(PublicKey.default)) {
+        return;
+      }
+
+      const reserve = vaultReservesState.get(allocationStrategy.reserve);
+      if (reserve === undefined) {
+        throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
+      }
+
+      const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, 0);
+      const reserveAllocationLiquidityAmount = new Decimal(allocationStrategy.cTokenAllocation.toString()).div(
+        reserveCollExchangeRate
+      );
+
+      const utilizationRatio = reserve.getEstimatedUtilizationRatio(slot, 0);
+      totalInvested = totalInvested.add(reserveAllocationLiquidityAmount);
+      totalBorrowed = totalBorrowed.add(reserveAllocationLiquidityAmount.mul(utilizationRatio));
+    });
+
+    let utilizationRatio = new Decimal(0);
+    if (!totalInvested.isZero()) {
+      utilizationRatio = totalBorrowed.div(totalInvested);
+    }
+    return {
+      totalInvested: totalInvested,
+      totalBorrowed: totalBorrowed,
+      utilizationRatio: utilizationRatio,
     };
   }
 
@@ -1193,9 +1307,10 @@ export class KaminoVaultClient {
       reserve.getBorrowedAmount();
       const reserveOverview: ReserveOverview = {
         supplyAPY: new Decimal(reserve.totalSupplyAPY(slot)),
-        uUtilizationRatio: new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0)),
+        utilizationRatio: new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0)),
         liquidationThresholdPct: new Decimal(reserve.state.config.liquidationThresholdPct),
         borrowedAmount: reserve.getBorrowedAmount(),
+        market: reserve.state.lendingMarket,
       };
       reservesDetails.set(allocationStrategy.reserve, reserveOverview);
     });
@@ -1371,13 +1486,21 @@ export type VaultHoldingsWithUSDValue = {
   availableUSD: Decimal;
   investedUSD: Decimal;
   investedInReservesUSD: PubkeyHashMap<PublicKey, Decimal>;
+  totalUSD: Decimal;
 };
 
 export type ReserveOverview = {
   supplyAPY: Decimal;
-  uUtilizationRatio: Decimal;
+  utilizationRatio: Decimal;
   liquidationThresholdPct: Decimal;
   borrowedAmount: Decimal;
+  market: PublicKey;
+};
+
+export type VaultReserveTotalBorrowedAndInvested = {
+  totalInvested: Decimal;
+  totalBorrowed: Decimal;
+  utilizationRatio: Decimal;
 };
 
 export type MarketOverview = {
@@ -1391,3 +1514,17 @@ export type ReserveAsCollateral = {
   mint: PublicKey;
   liquidationLTVPct: Decimal;
 };
+
+export type VaultOverview = {
+  holdingsUSD: VaultHoldingsWithUSDValue;
+  reservesOverview: PubkeyHashMap<PublicKey, ReserveOverview>;
+  vaultCollaterals: PubkeyHashMap<PublicKey, MarketOverview>;
+  theoreticalSupplyAPY: Decimal;
+  totalBorrowed: Decimal;
+  utilizationRatio: Decimal;
+};
+
+export type VaultFeesPct = {
+  managementFeePct: Decimal;
+  performanceFeePct: Decimal;
+};

package/src/client_kamino_manager.ts

@@ -643,6 +643,25 @@ async function main() {
       });
     });
 
+  commands
+    .command('get-vault-overview')
+    .requiredOption('--vault <string>', 'Vault address')
+    .action(async ({ vault }) => {
+      const env = initializeClient(false, false);
+
+      const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+      const vaultAddress = new PublicKey(vault);
+      const vaultState = await new KaminoVault(vaultAddress, undefined, env.kVaultProgramId).getState(env.connection);
+      const vaultOverview = await kaminoManager.getVaultOverview(
+        vaultState,
+        await env.connection.getSlot('confirmed'),
+        new Decimal(1.0)
+      );
+      
+      console.log('vaultOverview', vaultOverview);
+    });
+
   commands
     .command('get-user-shares-for-vault')
     .requiredOption('--vault <string>', 'Vault address')