@kamino-finance/klend-sdk 7.3.2 → 7.3.3

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 = {

package/src/classes/vault.ts

@@ -139,6 +139,7 @@ import { Farms } from '@kamino-finance/farms-sdk';
 import { getFarmIncentives } from '@kamino-finance/farms-sdk/dist/utils/apy';
 import { computeReservesAllocation } from '../utils/vaultAllocation';
 import { getReserveFarmRewardsAPY } from '../utils/farmUtils';
+import { fetchKaminoCdnData } from '../utils/readCdnData';
 
 export const kaminoVaultId = address('KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd');
 export const kaminoVaultStagingId = address('stKvQfwRsQiKnLtMNVLHKS3exFJmZFsgfzBPWHECUYK');
@@ -2581,7 +2582,10 @@ export class KaminoVaultClient {
     const deserializedReserves = await batchFetch(vaultReservesAddresses, (chunk) =>
       this.loadReserializedReserves(chunk)
     );
-    const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves, oracleAccounts);
+    const [reservesAndOracles, cdnResourcesData] = await Promise.all([
+      getTokenOracleData(this.getConnection(), deserializedReserves, oracleAccounts),
+      fetchKaminoCdnData(),
+    ]);
     const kaminoReserves = new Map<Address, KaminoReserve>();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
@@ -2596,7 +2600,8 @@ export class KaminoVaultClient {
         reserve,
         oracle,
         this.getConnection(),
-        this.recentSlotDurationMs
+        this.recentSlotDurationMs,
+        cdnResourcesData
       );
       kaminoReserves.set(kaminoReserve.address, kaminoReserve);
     });

package/src/utils/readCdnData.ts

@@ -0,0 +1,50 @@
+import { CDN_ENDPOINT } from './constants';
+
+/**
+ * CDN data structure containing Kamino resources for different networks
+ */
+export interface AllKaminoCdnData {
+  'mainnet-beta': KaminoCdnData;
+  devnet: KaminoCdnData;
+}
+
+/**
+ * Kamino CDN data structure
+ * This type can be extended with additional fields as needed
+ */
+export interface KaminoCdnData {
+  /**
+   * List of deprecated reserve addresses (pubkeys as strings)
+   * Note: This field is named 'deprecatedAssets' in the CDN but represents deprecated reserves
+   */
+  deprecatedAssets: string[];
+  // Additional fields can be added here as they become relevant
+  [key: string]: unknown;
+}
+
+/**
+ * Fetches Kamino CDN data from the resources endpoint
+ * @returns Promise resolving to the CDN data for the specified cluster or undefined if fetching/parsing fails
+ */
+export async function fetchKaminoCdnData(): Promise<KaminoCdnData | undefined> {
+  const url = `${CDN_ENDPOINT}/resources.json`;
+
+  try {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const text = await response.text();
+
+    try {
+      const data: AllKaminoCdnData = JSON.parse(text);
+      return data['mainnet-beta'];
+    } catch (parseError) {
+      throw new Error('Invalid JSON in response');
+    }
+  } catch (error) {
+    return undefined;
+  }
+}