@kamino-finance/klend-sdk 7.0.11 → 7.0.13

package/src/classes/market.ts

@@ -17,7 +17,7 @@ import {
   Slot,
 } from '@solana/kit';
 import { KaminoObligation } from './obligation';
-import { KaminoReserve, KaminoReserveRpcApi } from './reserve';
+import { KaminoReserve, KaminoReserveRpcApi, ReserveWithAddress } from './reserve';
 import { LendingMarket, Obligation, ReferrerTokenState, Reserve, UserMetadata } from '../@codegen/klend/accounts';
 import {
   AllOracleAccounts,
@@ -446,13 +446,13 @@ export class KaminoMarket {
   /**
    * @returns The max borrowable amount for leverage positions
    */
-  async getMaxLeverageBorrowableAmount(
+  getMaxLeverageBorrowableAmount(
     collReserve: KaminoReserve,
     debtReserve: KaminoReserve,
     slot: Slot,
     requestElevationGroup: boolean,
     obligation?: KaminoObligation
-  ): Promise<Decimal> {
+  ): Decimal {
     return obligation
       ? obligation.getMaxBorrowAmount(this, debtReserve.getLiquidityMint(), slot, requestElevationGroup)
       : debtReserve.getMaxBorrowAmountWithCollReserve(this, collReserve, slot);
@@ -463,7 +463,7 @@ export class KaminoMarket {
     const reserveAccounts = await this.rpc
       .getMultipleAccounts(addresses, { commitment: 'processed', encoding: 'base64' })
       .send();
-    const deserializedReserves = reserveAccounts.value.map((reserve, i) => {
+    const deserializedReserves: ReserveWithAddress[] = reserveAccounts.value.map((reserve, i) => {
       if (reserve === null) {
         // maybe reuse old here
         throw new Error(`Reserve account ${addresses[i]} was not found`);
@@ -472,13 +472,20 @@ export class KaminoMarket {
       if (!reserveAccount) {
         throw Error(`Could not parse reserve ${addresses[i]}`);
       }
-      return reserveAccount;
+      return {
+        address: addresses[i],
+        state: reserveAccount,
+      };
     });
     const reservesAndOracles = await getTokenOracleData(this.getRpc(), deserializedReserves, oracleAccounts);
     const kaminoReserves = new Map<Address, KaminoReserve>();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
-        throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
+        throw Error(
+          `Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} (${
+            addresses[index]
+          }) reserve in market ${reserve.lendingMarket}`
+        );
       }
       const kaminoReserve = KaminoReserve.initialize(
         addresses[index],
@@ -1020,7 +1027,7 @@ export class KaminoMarket {
     obligationAddresses.push(await new VanillaObligation(this.programId).toPda(this.getAddress(), user));
     const targetReserve = new Map<Address, KaminoReserve>(Array.from(this.reserves.entries())).get(reserve);
     if (!targetReserve) {
-      throw Error('Could not find reserve.');
+      throw Error(`Could not find reserve ${reserve}`);
     }
     for (const [key, kaminoReserve] of this.reserves) {
       if (targetReserve.address === key) {
@@ -1087,7 +1094,7 @@ export class KaminoMarket {
     const obligation = await this.getObligationByAddress(vanillaObligationAddress);
 
     if (!obligation) {
-      throw new Error('Could not find vanilla obligation.');
+      throw new Error(`Could not find vanilla obligation ${vanillaObligationAddress}`);
     }
 
     return obligation;
@@ -1594,7 +1601,7 @@ export async function getReservesForMarket(
       encoding: 'base64',
     })
     .send();
-  const deserializedReserves = reserves.map((reserve) => {
+  const deserializedReserves: ReserveWithAddress[] = reserves.map((reserve) => {
     if (reserve.account === null) {
       throw new Error(`Reserve account ${reserve.pubkey} does not exist`);
     }
@@ -1604,13 +1611,20 @@ export async function getReservesForMarket(
     if (!reserveAccount) {
       throw Error(`Could not parse reserve ${reserve.pubkey}`);
     }
-    return reserveAccount;
+    return {
+      address: reserve.pubkey,
+      state: reserveAccount,
+    };
   });
   const reservesAndOracles = await getTokenOracleData(rpc, deserializedReserves, oracleAccounts);
   const reservesByAddress = new Map<Address, KaminoReserve>();
   reservesAndOracles.forEach(([reserve, oracle], index) => {
     if (!oracle) {
-      throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
+      throw Error(
+        `Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} (${
+          reserves[index].pubkey
+        }) reserve in market ${reserve.lendingMarket}`
+      );
     }
     const kaminoReserve = KaminoReserve.initialize(reserves[index].pubkey, reserve, oracle, rpc, recentSlotDurationMs);
     reservesByAddress.set(kaminoReserve.address, kaminoReserve);
@@ -1630,11 +1644,15 @@ export async function getSingleReserve(
   if (reserve === null) {
     throw new Error(`Reserve account ${reservePk} does not exist`);
   }
-  const reservesAndOracles = await getTokenOracleData(rpc, [reserve], oracleAccounts);
+  const reservesAndOracles = await getTokenOracleData(rpc, [{ address: reservePk, state: reserve }], oracleAccounts);
   const [, oracle] = reservesAndOracles[0];
 
   if (!oracle) {
-    throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
+    throw Error(
+      `Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} (${reservePk}) reserve in market ${
+        reserve.lendingMarket
+      }`
+    );
   }
   return KaminoReserve.initialize(reservePk, reserve, oracle, rpc, recentSlotDurationMs);
 }

package/src/classes/reserve.ts

@@ -112,7 +112,11 @@ export class KaminoReserve {
       throw new Error(`Reserve account ${address} does not exist`);
     }
 
-    const tokenOracleDataWithReserve = await getTokenOracleData(rpc, [reserve], oracleAccounts);
+    const tokenOracleDataWithReserve = await getTokenOracleData(
+      rpc,
+      [{ address: address, state: reserve }],
+      oracleAccounts
+    );
     if (!tokenOracleDataWithReserve[0]) {
       throw new Error('Token oracle data not found');
     }

package/src/classes/vault.ts

@@ -2386,7 +2386,10 @@ export class KaminoVaultClient {
       if (!reserveAccount) {
         throw Error(`Could not parse reserve ${vaultReservesAddresses[i]}`);
       }
-      return reserveAccount;
+      return {
+        address: vaultReservesAddresses[i],
+        state: reserveAccount,
+      };
     });
 
     const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves, oracleAccounts);
@@ -2395,7 +2398,11 @@ export class KaminoVaultClient {
 
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
-        throw Error(`Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} reserve`);
+        throw Error(
+          `Could not find oracle for ${parseTokenSymbol(reserve.config.tokenInfo.name)} (${
+            vaultReservesAddresses[index]
+          }) reserve in market ${reserve.lendingMarket}`
+        );
       }
       const kaminoReserve = KaminoReserve.initialize(
         vaultReservesAddresses[index],
@@ -2445,9 +2452,18 @@ export class KaminoVaultClient {
     });
 
     // read missing reserves
-    const missingReservesStates = (await Reserve.fetchMultiple(this.getConnection(), [...missingReserves])).filter(
-      (reserve) => reserve !== null
-    );
+    const missingReserveAddresses = [...missingReserves];
+    const missingReservesStates = (await Reserve.fetchMultiple(this.getConnection(), missingReserveAddresses))
+      .map((reserve, index) => {
+        if (!reserve) {
+          return null;
+        }
+        return {
+          address: missingReserveAddresses[index],
+          state: reserve,
+        };
+      })
+      .filter((state) => state !== null);
     const missingReservesAndOracles = await getTokenOracleData(
       this.getConnection(),
       missingReservesStates,
@@ -2456,7 +2472,7 @@ export class KaminoVaultClient {
     missingReservesAndOracles.forEach(([reserve, oracle], index) => {
       const fetchedReserve = new KaminoReserve(
         reserve,
-        [...missingReserves][index]!, // Set maintains order
+        missingReserveAddresses[index]!, // Set maintains order
         oracle!,
         this.getConnection(),
         this.recentSlotDurationMs

package/src/utils/oracle.ts

@@ -3,7 +3,7 @@ import Decimal from 'decimal.js';
 import { Scope } from '@kamino-finance/scope-sdk';
 import { OraclePrices } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/OraclePrices';
 import { isNotNullPubkey } from './pubkey';
-import { parseTokenSymbol } from '../classes';
+import { parseTokenSymbol, ReserveWithAddress } from '../classes';
 import { Reserve } from '../lib';
 import { batchFetch } from '@kamino-finance/kliquidity-sdk';
 import BN from 'bn.js';
@@ -43,12 +43,12 @@ export type ScopePriceRefreshConfig = {
   scopeConfigurations: [Address, Configuration][];
 };
 
-export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, reserves: Reserve[]) {
+export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, reserves: ReserveWithAddress[]) {
   const tokenOracleDataForReserves: Array<[Reserve, TokenOracleData | undefined]> = [];
   const pythCache = new Map<Address, PythPrices>();
   const switchboardCache = new Map<Address, CandidatePrice>();
   const scopeCache = new Map<Address, OraclePrices>();
-  for (const reserve of reserves) {
+  for (const { address, state: reserve } of reserves) {
     let currentBest: CandidatePrice | undefined = undefined;
     const oracle = {
       pythAddress: reserve.config.tokenInfo.pythConfiguration.price,
@@ -86,7 +86,10 @@ export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, res
     }
 
     if (!currentBest) {
-      console.error(`No price found for reserve: ${parseTokenSymbol(reserve.config.tokenInfo.name)}`);
+      const reserveSymbol = parseTokenSymbol(reserve.config.tokenInfo.name);
+      console.error(
+        `No price found for reserve: ${reserveSymbol ?? 'unknown'} (${address}) in market: ${reserve.lendingMarket}`
+      );
       tokenOracleDataForReserves.push([reserve, undefined]);
       continue;
     }
@@ -105,10 +108,15 @@ export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, res
 // TODO: Add freshness of the latest price to match sc logic
 export async function getTokenOracleData(
   rpc: Rpc<GetMultipleAccountsApi>,
-  reserves: Reserve[],
+  reserves: ReserveWithAddress[],
   oracleAccounts?: AllOracleAccounts
 ): Promise<Array<[Reserve, TokenOracleData | undefined]>> {
-  const allOracleAccounts = oracleAccounts ?? (await getAllOracleAccounts(rpc, reserves));
+  const allOracleAccounts =
+    oracleAccounts ??
+    (await getAllOracleAccounts(
+      rpc,
+      reserves.map((r) => r.state)
+    ));
   return getTokenOracleDataSync(allOracleAccounts, reserves);
 }