@kamino-finance/klend-sdk 5.1.0 → 5.1.2

package/dist/utils/rpc.js.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../../src/utils/rpc.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rpc.js","sourceRoot":"","sources":["../../src/utils/rpc.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamino-finance/klend-sdk",
-  "version": "5.1.0",
+  "version": "5.1.2",
   "description": "Typescript SDK for interacting with the Kamino Lending (klend) protocol",
   "repository": {
     "type": "git",
@@ -65,7 +65,8 @@
     "buffer": "^6.0.3",
     "commander": "^9.3.0",
     "decimal.js": "^10.4.3",
-    "exponential-backoff": "^3.1.1"
+    "exponential-backoff": "^3.1.1",
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@orca-so/sdk": "^1.2.25",

package/src/classes/manager.ts

@@ -14,7 +14,10 @@ import {
   KaminoVaultConfig,
   kaminoVaultId,
   ReserveAllocationConfig,
+  ReserveOverview,
   VaultHolder,
+  VaultHoldings,
+  VaultHoldingsWithUSDValue,
 } from './vault';
 import {
   AddAssetToMarketParams,
@@ -26,6 +29,7 @@ import {
   initLendingMarket,
   InitLendingMarketAccounts,
   InitLendingMarketArgs,
+  KaminoReserve,
   LendingMarket,
   lendingMarketAuthPda,
   MarketWithAddress,
@@ -318,7 +322,11 @@ export class KaminoManager {
     return this._vaultClient.depositIxs(user, vault, tokenAmount);
   }
 
-  async updateVaultConfigIx(vault: KaminoVault, mode: VaultConfigFieldKind, value: string): Promise<TransactionInstruction> {
+  async updateVaultConfigIx(
+    vault: KaminoVault,
+    mode: VaultConfigFieldKind,
+    value: string
+  ): Promise<TransactionInstruction> {
     return this._vaultClient.updateVaultConfigIx(vault, mode, value);
   }
 
@@ -378,6 +386,18 @@ export class KaminoManager {
     return this._vaultClient.getTokensPerShareSingleVault(vault, slot);
   }
 
+  /**
+   * This method calculates the price of one vault share(kToken)
+   * @param vault - vault to calculate sharePrice for
+   * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+   * @param tokenPrice - the price of the vault token (e.g. SOL) in USD
+   * @returns - share value in USD
+   */
+  async getSharePriceInUSD(vault: KaminoVault, slot: number, tokenPrice: Decimal): Promise<Decimal> {
+    const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+    return tokensPerShare.mul(tokenPrice);
+  }
+
   /**
    * This method returns the user shares balance for a given vault
    * @param user - user to calculate the shares balance for
@@ -507,6 +527,95 @@ export class KaminoManager {
     return result;
   };
 
+  /**
+   * This will return an VaultHoldings object which contains the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve
+   * @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 VaultHoldings object
+   */
+  async getVaultHoldings(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<VaultHoldings> {
+    return this._vaultClient.getVaultHoldings(vault, slot, vaultReserves);
+  }
+
+  /**
+   * This will return an VaultHoldingsWithUSDValue object which contains an holdings field representing the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve and additional fields for the total USD value of the available and invested amounts
+   * @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
+   * @param price - the price of the token in the vault (e.g. USDC)
+   * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
+   */
+  async getVaultHoldingsWithPrice(
+    vault: VaultState,
+    slot: number,
+    price: Decimal,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<VaultHoldingsWithUSDValue> {
+    return this._vaultClient.getVaultHoldingsWithPrice(vault, slot, price, vaultReserves);
+  }
+
+  /**
+   * This will return an overview of each reserve that is part of the vault allocation
+   * @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 a hashmap from vault reserve pubkey to ReserveOverview object
+   */
+  async getVaultReservesDetails(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<PubkeyHashMap<PublicKey, ReserveOverview>> {
+    return this._vaultClient.getVaultReservesDetails(vault, slot, vaultReserves);
+  }
+
+  /**
+   * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves
+   * @param vault - the kamino vault to get APY 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 APY for the vault
+   */
+  async getVaultTheoreticalAPY(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<Decimal> {
+    return this._vaultClient.getVaultTheoreticalAPY(vault, slot, vaultReserves);
+  }
+
+  /**
+   * This will load the onchain state for all the reserves that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  async loadVaultReserves(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
+    return this._vaultClient.loadVaultReserves(vaultState);
+  }
+
+  /**
+   * This will get the list of all reserve pubkeys that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  getAllVaultReserves(vault: VaultState): PublicKey[] {
+    return this._vaultClient.getAllVaultReserves(vault);
+  }
+
+  /**
+   * This will load the onchain state for all the reserves that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  getVaultReserves(vault: VaultState): PublicKey[] {
+    return this._vaultClient.getVaultReserves(vault);
+  }
+
   /**
    * This will trigger invest by balancing, based on weights, the reserve allocations of the vault. It can either withdraw or deposit into reserves to balance them. This is a function that should be cranked
    * @param kaminoVault - vault to invest from

package/src/classes/vault.ts

@@ -61,6 +61,7 @@ import bs58 from 'bs58';
 import { getProgramAccounts } from '../utils/rpc';
 
 export const kaminoVaultId = new PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
+export const kaminoVaultStagingId = new PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuYMFMTsE77FiRsL2');
 
 const TOKEN_VAULT_SEED = 'token_vault';
 const CTOKEN_VAULT_SEED = 'ctoken_vault';
@@ -389,9 +390,15 @@ 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 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 array of instructions to be used to be executed
    */
-  async depositIxs(user: PublicKey, vault: KaminoVault, tokenAmount: Decimal): Promise<TransactionInstruction[]> {
+  async depositIxs(
+    user: PublicKey,
+    vault: KaminoVault,
+    tokenAmount: Decimal,
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this._connection);
 
     const userTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, user);
@@ -450,7 +457,7 @@ export class KaminoVaultClient {
 
     const vaultReserves = this.getVaultReserves(vaultState);
 
-    const vaultReservesState = await this.loadVaultReserves(vaultState);
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
 
     let vaultReservesAccountMetas: AccountMeta[] = [];
     let vaultReservesLendingMarkets: AccountMeta[] = [];
@@ -825,16 +832,21 @@ export class KaminoVaultClient {
    * 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
    * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+   * @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 - token per share value
    */
-  async getTokensPerShareSingleVault(vault: KaminoVault, slot: number): Promise<Decimal> {
+  async getTokensPerShareSingleVault(
+    vault: KaminoVault,
+    slot: number,
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<Decimal> {
     const vaultState = await vault.getState(this._connection);
-    const reserves = await this.loadVaultReserves(vaultState);
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
 
     const totalVaultLiquidityAmount = new Decimal(vaultState.tokenAvailable.toString());
     vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
       if (!allocationStrategy.reserve.equals(PublicKey.default)) {
-        const reserve = reserves.get(allocationStrategy.reserve);
+        const reserve = vaultReservesState.get(allocationStrategy.reserve);
         if (reserve === undefined) {
           throw new Error(`Reserve ${allocationStrategy.reserve.toBase58()} not found`);
         }
@@ -983,13 +995,32 @@ export class KaminoVaultClient {
     return reserveAllocationAvailableLiquidityToWithdraw;
   }
 
-  private getVaultReserves(vault: VaultState): PublicKey[] {
+  /**
+   * This will get the list of all reserve pubkeys that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  getAllVaultReserves(vault: VaultState): PublicKey[] {
+    return vault.vaultAllocationStrategy.map((vaultAllocation) => vaultAllocation.reserve);
+  }
+
+  /**
+   * This will get the list of all reserve pubkeys that the vault has allocations for ex
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  getVaultReserves(vault: VaultState): PublicKey[] {
     return vault.vaultAllocationStrategy
       .filter((vaultAllocation) => !vaultAllocation.reserve.equals(PublicKey.default))
       .map((vaultAllocation) => vaultAllocation.reserve);
   }
 
-  private async loadVaultReserves(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
+  /**
+   * This will load the onchain state for all the reserves that the vault has allocations for
+   * @param vaultState - the vault state to load reserves for
+   * @returns a hashmap from each reserve pubkey to the reserve state
+   */
+  async loadVaultReserves(vaultState: VaultState): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
     const vaultReservesAddresses = this.getVaultReserves(vaultState);
     const reserveAccounts = await this._connection.getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
 
@@ -1026,6 +1057,152 @@ export class KaminoVaultClient {
 
     return kaminoReserves;
   }
+
+  /**
+   * This will return an VaultHoldings object which contains the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve
+   * @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 VaultHoldings object
+   */
+  async getVaultHoldings(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<VaultHoldings> {
+    const vaultHoldings: VaultHoldings = {
+      available: new Decimal(vault.tokenAvailable.toString()),
+      invested: new Decimal(0),
+      investedInReserves: new PubkeyHashMap<PublicKey, Decimal>(),
+    };
+
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+
+    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()).mul(
+        reserveCollExchangeRate
+      );
+
+      vaultHoldings.invested = vaultHoldings.invested.add(reserveAllocationLiquidityAmount);
+      vaultHoldings.investedInReserves.set(allocationStrategy.reserve, reserveAllocationLiquidityAmount);
+    });
+
+    return vaultHoldings;
+  }
+
+  /**
+   * This will return an VaultHoldingsWithUSDValue object which contains an holdings field representing the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve and additional fields for the total USD value of the available and invested amounts
+   * @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
+   * @param price - the price of the token in the vault (e.g. USDC)
+   * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
+   */
+  async getVaultHoldingsWithPrice(
+    vault: VaultState,
+    slot: number,
+    price: Decimal,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<VaultHoldingsWithUSDValue> {
+    const holdings = await this.getVaultHoldings(vault, slot, vaultReserves);
+
+    const investedInReservesUSD = new PubkeyHashMap<PublicKey, Decimal>();
+    holdings.investedInReserves.forEach((amount, reserve) => {
+      investedInReservesUSD.set(reserve, amount.mul(price));
+    });
+    const holdingsWithUSDValue: VaultHoldingsWithUSDValue = {
+      holdings: holdings,
+      availableUSD: holdings.available.mul(price),
+      investedUSD: holdings.invested.mul(price),
+      investedInReservesUSD: investedInReservesUSD,
+    };
+
+    return holdingsWithUSDValue;
+  }
+
+  /**
+   * This will return an overview of each reserve that is part of the vault allocation
+   * @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 a hashmap from vault reserve pubkey to ReserveOverview object
+   */
+  async getVaultReservesDetails(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<PubkeyHashMap<PublicKey, ReserveOverview>> {
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+    const reservesDetails = new PubkeyHashMap<PublicKey, ReserveOverview>();
+
+    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`);
+      }
+
+      reserve.getBorrowedAmount();
+      const reserveOverview: ReserveOverview = {
+        supplyAPY: new Decimal(reserve.totalSupplyAPY(slot)),
+        uUtilizationRatio: new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0)),
+        liquidationThresholdPct: new Decimal(reserve.state.config.liquidationThresholdPct),
+        borrowedAmount: reserve.getBorrowedAmount(),
+      };
+      reservesDetails.set(allocationStrategy.reserve, reserveOverview);
+    });
+
+    return reservesDetails;
+  }
+
+  /**
+   * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves
+   * @param vault - the kamino vault to get APY 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 APY for the vault
+   */
+  async getVaultTheoreticalAPY(
+    vault: VaultState,
+    slot: number,
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<Decimal> {
+    const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
+
+    let totalWeights = new Decimal(0);
+    let totalAPY = 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 reserveAPY = new Decimal(reserve.totalSupplyAPY(slot));
+      const weight = new Decimal(allocationStrategy.targetAllocationWeight.toString());
+      const weightedAPY = reserveAPY.mul(weight);
+      totalAPY = totalAPY.add(weightedAPY);
+      totalWeights = totalWeights.add(weight);
+    });
+
+    return totalAPY.div(totalWeights);
+  }
 } // KaminoVaultClient
 
 export class KaminoVault {
@@ -1134,3 +1311,23 @@ export type VaultHolder = {
   holderPubkey: PublicKey;
   amount: Decimal;
 };
+
+export type VaultHoldings = {
+  available: Decimal;
+  invested: Decimal;
+  investedInReserves: PubkeyHashMap<PublicKey, Decimal>;
+};
+
+export type VaultHoldingsWithUSDValue = {
+  holdings: VaultHoldings;
+  availableUSD: Decimal;
+  investedUSD: Decimal;
+  investedInReservesUSD: PubkeyHashMap<PublicKey, Decimal>;
+};
+
+export type ReserveOverview = {
+  supplyAPY: Decimal;
+  uUtilizationRatio: Decimal;
+  liquidationThresholdPct: Decimal;
+  borrowedAmount: Decimal;
+};

package/src/client_kamino_manager.ts

@@ -496,6 +496,14 @@ async function main() {
     console.log('oracleConfigs', JSON.parse(JSON.stringify(oracleConfigs)));
   });
 
+  commands.command('get-all-vaults').action(async () => {
+    const env = initializeClient(false, false);
+    const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+    const allVaults = await kaminoManager.getAllVaults();
+    console.log('all vaults', allVaults);
+  });
+
   commands
     .command('download-lending-market-config')
     .requiredOption('--lending-market <string>', 'Lending Market Address')