@kamino-finance/klend-sdk 7.3.2 → 7.3.4

package/src/classes/manager.ts

@@ -104,6 +104,7 @@ import type { AccountInfoBase, AccountInfoWithJsonData, AccountInfoWithPubkey }
 import { arrayElementConfigItems, ConfigUpdater } from './configItems';
 import { OracleMappings } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts';
 import { getReserveFarmRewardsAPY as getReserveFarmRewardsAPYUtils, ReserveIncentives } from '../utils/farmUtils';
+import { fetchKaminoCdnData } from '../utils/readCdnData';
 
 const base58Decoder = getBase58Decoder();
 
@@ -585,6 +586,25 @@ export class KaminoManager {
     return this._vaultClient.depositIxs(user, vault, tokenAmount, vaultReservesMap, farmState);
   }
 
+  /**
+   * This function creates instructions to buy shares (i.e. deposit) into a vault. It will also create ATA creation instructions for the vault shares that the user receives in return
+   * @param user - user to nuy shares
+   * @param vault - vault to buy shares from (if the state is not provided, it will be fetched)
+   * @param tokenAmount - token amount to be swapped for shares, in decimals (will be converted in lamports)
+   * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @param [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
+   * @returns - an instance of DepositIxs which contains the instructions to buy shares in vault and the instructions to stake the shares in the farm if the vault has a farm
+   */
+  async buyVaultSharesIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    tokenAmount: Decimal,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<DepositIxs> {
+    return this._vaultClient.buySharesIxs(user, vault, tokenAmount, vaultReservesMap, farmState);
+  }
+
   /**
    * This function creates instructions to stake the shares in the vault farm if the vault has a farm
    * @param user - user to stake
@@ -718,6 +738,27 @@ export class KaminoManager {
     return this._vaultClient.withdrawIxs(user, vault, shareAmount, slot, vaultReservesMap, farmState);
   }
 
+  /**
+   * This function will return the missing ATA creation instructions, as well as one or multiple withdraw instructions, based on how many reserves it's needed to withdraw from. This might have to be split in multiple transactions
+   * @param user - user to sell shares for vault tokens
+   * @param vault - vault to sell shares from
+   * @param shareAmount - share amount to sell (in tokens, not lamports), in order to withdraw everything, any value > user share amount
+   * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+   * @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
+   * @param [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
+   * @returns an array of instructions to create missing ATAs if needed and the withdraw instructions
+   */
+  async sellVaultSharesIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    shareAmount: Decimal,
+    slot: Slot,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<WithdrawIxs> {
+    return this._vaultClient.sellSharesIxs(user, vault, shareAmount, slot, vaultReservesMap, farmState);
+  }
+
   /**
    * This method withdraws all the pending fees from the vault to the owner's token ATA
    * @param vault - vault for which the admin withdraws the pending fees
@@ -880,7 +921,10 @@ export class KaminoManager {
     const allReserves = reservePairs.map(([, reserve]) => reserve);
 
     // Get all oracle accounts
-    const allOracleAccounts = await getAllOracleAccounts(this.getRpc(), allReserves);
+    const [allOracleAccounts, cdnResourcesData] = await Promise.all([
+      getAllOracleAccounts(this.getRpc(), allReserves),
+      fetchKaminoCdnData(),
+    ]);
     // Group reserves by market
     const marketToReserve = new Map<Address, ReserveWithAddress[]>();
     for (const [reserveAddress, reserveState] of reservePairs) {
@@ -919,7 +963,8 @@ export class KaminoManager {
             state,
             oracle,
             this.getRpc(),
-            this.recentSlotDurationMs
+            this.recentSlotDurationMs,
+            cdnResourcesData
           );
           reservesByAddress.set(kaminoReserve.address, kaminoReserve);
         });

package/src/classes/market.ts

@@ -56,6 +56,7 @@ import { ObligationZP } from '../@codegen/klend/zero_padding';
 import { checkDefined } from '../utils/validations';
 import { Buffer } from 'buffer';
 import { ReserveStatus } from '../@codegen/klend/types';
+import { fetchKaminoCdnData } from '../utils/readCdnData';
 
 export type KaminoMarketRpcApi = GetAccountInfoApi &
   GetMultipleAccountsApi &
@@ -479,7 +480,10 @@ export class KaminoMarket {
         state: reserveAccount,
       };
     });
-    const reservesAndOracles = await getTokenOracleData(this.getRpc(), deserializedReserves, oracleAccounts);
+    const [reservesAndOracles, cdnResourcesData] = await Promise.all([
+      getTokenOracleData(this.getRpc(), deserializedReserves, oracleAccounts),
+      fetchKaminoCdnData(),
+    ]);
     const kaminoReserves = new Map<Address, KaminoReserve>();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
@@ -494,7 +498,8 @@ export class KaminoMarket {
         reserve,
         oracle,
         this.rpc,
-        this.recentSlotDurationMs
+        this.recentSlotDurationMs,
+        cdnResourcesData
       );
       kaminoReserves.set(kaminoReserve.address, kaminoReserve);
     });
@@ -1712,7 +1717,10 @@ export async function getReservesForMarket(
       state: reserveAccount,
     };
   });
-  const reservesAndOracles = await getTokenOracleData(rpc, deserializedReserves, oracleAccounts);
+  const [reservesAndOracles, cdnResourcesData] = await Promise.all([
+    getTokenOracleData(rpc, deserializedReserves, oracleAccounts),
+    fetchKaminoCdnData(),
+  ]);
   const reservesByAddress = new Map<Address, KaminoReserve>();
   reservesAndOracles.forEach(([reserve, oracle], index) => {
     if (reserve.config.status === ReserveStatus.Obsolete.discriminator) {
@@ -1725,7 +1733,14 @@ export async function getReservesForMarket(
         }) reserve in market ${reserve.lendingMarket}`
       );
     }
-    const kaminoReserve = KaminoReserve.initialize(reserves[index].pubkey, reserve, oracle, rpc, recentSlotDurationMs);
+    const kaminoReserve = KaminoReserve.initialize(
+      reserves[index].pubkey,
+      reserve,
+      oracle,
+      rpc,
+      recentSlotDurationMs,
+      cdnResourcesData
+    );
     reservesByAddress.set(kaminoReserve.address, kaminoReserve);
   });
   return reservesByAddress;
@@ -1743,7 +1758,10 @@ export async function getSingleReserve(
   if (reserve === null) {
     throw new Error(`Reserve account ${reservePk} does not exist`);
   }
-  const reservesAndOracles = await getTokenOracleData(rpc, [{ address: reservePk, state: reserve }], oracleAccounts);
+  const [reservesAndOracles, cdnResourcesData] = await Promise.all([
+    getTokenOracleData(rpc, [{ address: reservePk, state: reserve }], oracleAccounts),
+    fetchKaminoCdnData(),
+  ]);
   const [, oracle] = reservesAndOracles[0];
 
   if (!oracle) {
@@ -1753,7 +1771,7 @@ export async function getSingleReserve(
       }`
     );
   }
-  return KaminoReserve.initialize(reservePk, reserve, oracle, rpc, recentSlotDurationMs);
+  return KaminoReserve.initialize(reservePk, reserve, oracle, rpc, recentSlotDurationMs, cdnResourcesData);
 }
 
 export function getReservesActive(reserves: Map<Address, KaminoReserve>): Map<Address, KaminoReserve> {

package/src/classes/reserve.ts

@@ -57,6 +57,7 @@ import { SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
 import { noopSigner } from '../utils/signer';
 import { getRewardPerTimeUnitSecond } from './farm_utils';
 import { Scope, ScopeEntryMetadata } from '@kamino-finance/scope-sdk';
+import { fetchKaminoCdnData, KaminoCdnData } from '../utils/readCdnData';
 
 export type KaminoReserveRpcApi = GetProgramAccountsApi & GetAccountInfoApi & GetMultipleAccountsApi;
 
@@ -97,10 +98,11 @@ export class KaminoReserve {
     state: Reserve,
     tokenOraclePrice: TokenOracleData,
     rpc: Rpc<KaminoReserveRpcApi>,
-    recentSlotDurationMs: number
+    recentSlotDurationMs: number,
+    cdnResourcesData?: KaminoCdnData
   ): KaminoReserve {
     const reserve = new KaminoReserve(state, address, tokenOraclePrice, rpc, recentSlotDurationMs);
-    reserve.stats = reserve.formatReserveData(state);
+    reserve.stats = reserve.formatReserveData(state, cdnResourcesData?.deprecatedAssets ?? []);
     return reserve;
   }
 
@@ -779,13 +781,16 @@ export class KaminoReserve {
   }
 
   async load(tokenOraclePrice: TokenOracleData) {
-    const parsedData = await Reserve.fetch(this.rpc, this.address);
+    const [parsedData, cdnResourcesData] = await Promise.all([
+      Reserve.fetch(this.rpc, this.address),
+      fetchKaminoCdnData(),
+    ]);
     if (!parsedData) {
       throw Error(`Unable to parse data of reserve ${this.symbol}`);
     }
     this.state = parsedData;
     this.tokenOraclePrice = tokenOraclePrice;
-    this.stats = this.formatReserveData(parsedData);
+    this.stats = this.formatReserveData(parsedData, cdnResourcesData?.deprecatedAssets ?? []);
   }
 
   totalSupplyAPY(currentSlot: Slot) {
@@ -874,7 +879,7 @@ export class KaminoReserve {
     return { apy: aprToApy(apr, 365), apr };
   }
 
-  private formatReserveData(parsedData: ReserveFields): ReserveDataType {
+  private formatReserveData(parsedData: ReserveFields, deprecatedAssets: string[]): ReserveDataType {
     const mintTotalSupply = new Decimal(parsedData.collateral.mintTotalSupply.toString()).div(this.getMintFactor());
     let reserveStatus = ReserveStatus.Active;
     switch (parsedData.config.status) {
@@ -888,6 +893,8 @@ export class KaminoReserve {
         reserveStatus = ReserveStatus.Hidden;
         break;
     }
+    const reserveIsUIDeprecated =
+      deprecatedAssets.length > 0 ? deprecatedAssets.includes(this.address.toString()) : undefined;
     return {
       // Reserve config
 
@@ -910,6 +917,7 @@ export class KaminoReserve {
       depositLimitCrossedTimestamp: parsedData.liquidity.depositLimitCrossedTimestamp.toNumber(),
       borrowLimitCrossedTimestamp: parsedData.liquidity.borrowLimitCrossedTimestamp.toNumber(),
       borrowFactor: parsedData.config.borrowFactorPct.toNumber(),
+      isUIDeprecated: reserveIsUIDeprecated,
     };
   }
 

package/src/classes/shared.ts

@@ -44,6 +44,7 @@ export type ReserveDataType = {
   accumulatedProtocolFees: Decimal;
   mintTotalSupply: Decimal;
   borrowFactor: number;
+  isUIDeprecated: boolean | undefined;
 };
 
 export type ReserveRewardYield = {