@kamino-finance/klend-sdk 6.0.5-beta.10 → 6.0.5-beta.11

package/src/classes/market.ts

@@ -23,6 +23,7 @@ import {
   PublicKeySet,
   DEPOSITS_LIMIT,
   setOrAppend,
+  AllOracleAccounts,
 } from '../utils';
 import base58 from 'bs58';
 import { BN } from '@coral-xyz/anchor';
@@ -32,7 +33,7 @@ import { PROGRAM_ID } from '../idl_codegen/programId';
 import bs58 from 'bs58';
 import { OraclePrices, Scope, U16_MAX } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
-import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
+import { batchFetch, chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
 import { ObligationZP } from '../idl_codegen/zero_padding';
@@ -73,6 +74,10 @@ export class KaminoMarket {
     recentSlotDurationMs: number,
     programId: PublicKey = PROGRAM_ID
   ) {
+    if (recentSlotDurationMs <= 0) {
+      throw new Error('Recent slot duration cannot be 0 or less');
+    }
+
     this.address = marketAddress;
     this.connection = connection;
     this.state = state;
@@ -109,10 +114,6 @@ export class KaminoMarket {
       return null;
     }
 
-    if (recentSlotDurationMs <= 0) {
-      throw new Error('Recent slot duration cannot be 0');
-    }
-
     const reserves = withReserves
       ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs)
       : new Map<PublicKey, KaminoReserve>();
@@ -131,6 +132,68 @@ export class KaminoMarket {
     return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
   }
 
+  static async loadMultiple(
+    connection: Connection,
+    markets: PublicKey[],
+    recentSlotDurationMs: number,
+    programId: PublicKey = PROGRAM_ID,
+    withReserves: boolean = true,
+    oracleAccounts?: AllOracleAccounts
+  ) {
+    const marketStates = await batchFetch(markets, (market) =>
+      LendingMarket.fetchMultiple(connection, market, programId)
+    );
+    const kaminoMarkets = new PubkeyHashMap<PublicKey, KaminoMarket>();
+    for (let i = 0; i < markets.length; i++) {
+      const market = marketStates[i];
+      const marketAddress = markets[i];
+      if (market === null) {
+        throw Error(`Could not fetch LendingMarket account state for market ${marketAddress}`);
+      }
+
+      const marketReserves = withReserves
+        ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs, oracleAccounts)
+        : new PubkeyHashMap<PublicKey, KaminoReserve>();
+
+      kaminoMarkets.set(
+        marketAddress,
+        new KaminoMarket(connection, market, marketAddress.toString(), marketReserves, recentSlotDurationMs, programId)
+      );
+    }
+    return kaminoMarkets;
+  }
+
+  static async loadMultipleWithReserves(
+    connection: Connection,
+    markets: PublicKey[],
+    reserves: PubkeyHashMap<PublicKey, PubkeyHashMap<PublicKey, KaminoReserve>>,
+    recentSlotDurationMs: number,
+    programId: PublicKey = PROGRAM_ID
+  ) {
+    const marketStates = await batchFetch(markets, (market) =>
+      LendingMarket.fetchMultiple(connection, market, programId)
+    );
+    const kaminoMarkets = new PubkeyHashMap<PublicKey, KaminoMarket>();
+    for (let i = 0; i < markets.length; i++) {
+      const market = marketStates[i];
+      const marketAddress = markets[i];
+      if (market === null) {
+        throw Error(`Could not fetch LendingMarket account state for market ${marketAddress}`);
+      }
+      const marketReserves = reserves.get(marketAddress);
+      if (!marketReserves) {
+        throw Error(
+          `Could not get reserves for market ${marketAddress} from the reserves map argument supplied to this method`
+        );
+      }
+      kaminoMarkets.set(
+        marketAddress,
+        new KaminoMarket(connection, market, marketAddress.toString(), marketReserves, recentSlotDurationMs, programId)
+      );
+    }
+    return kaminoMarkets;
+  }
+
   async reload(): Promise<void> {
     const market = await LendingMarket.fetch(this.connection, this.getAddress(), this.programId);
     if (market === null) {
@@ -383,7 +446,7 @@ export class KaminoMarket {
       : debtReserve.getMaxBorrowAmountWithCollReserve(this, collReserve, slot);
   }
 
-  async loadReserves() {
+  async loadReserves(oracleAccounts?: AllOracleAccounts) {
     const addresses = [...this.reserves.keys()];
     const reserveAccounts = await this.connection.getMultipleAccountsInfo(addresses, 'processed');
     const deserializedReserves = reserveAccounts.map((reserve, i) => {
@@ -397,7 +460,7 @@ export class KaminoMarket {
       }
       return reserveAccount;
     });
-    const reservesAndOracles = await getTokenOracleData(this.connection, deserializedReserves);
+    const reservesAndOracles = await getTokenOracleData(this.connection, deserializedReserves, oracleAccounts);
     const kaminoReserves = new PubkeyHashMap<PublicKey, KaminoReserve>();
     reservesAndOracles.forEach(([reserve, oracle], index) => {
       if (!oracle) {
@@ -849,9 +912,13 @@ export class KaminoMarket {
     return finalObligations;
   }
 
-  async getAllUserObligations(user: PublicKey, commitment = this.connection.commitment): Promise<KaminoObligation[]> {
+  async getAllUserObligations(
+    user: PublicKey,
+    commitment = this.connection.commitment,
+    slot?: number
+  ): Promise<KaminoObligation[]> {
     const [currentSlot, obligations] = await Promise.all([
-      this.connection.getSlot(),
+      slot !== undefined ? Promise.resolve(slot) : this.connection.getSlot(),
       this.connection.getProgramAccounts(this.programId, {
         filters: [
           {
@@ -1226,8 +1293,10 @@ export class KaminoMarket {
   /**
    * Get all Scope prices used by all the market reserves
    */
-  async getAllScopePrices(scope: Scope): Promise<KaminoPrices> {
-    const allOraclePrices = await this.getReserveOraclePrices(scope);
+  async getAllScopePrices(
+    scope: Scope,
+    allOraclePrices: PubkeyHashMap<PublicKey, OraclePrices>
+  ): Promise<KaminoPrices> {
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
     for (const reserve of this.reserves.values()) {
@@ -1236,7 +1305,7 @@ export class KaminoMarket {
       const oracle = reserve.state.config.tokenInfo.scopeConfiguration.priceFeed;
       const chain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
       const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
-      const oraclePrices = allOraclePrices.get(reserve.address);
+      const oraclePrices = allOraclePrices.get(oracle);
       if (oraclePrices && oracle && isNotNullPubkey(oracle) && chain && Scope.isScopeChainValid(chain)) {
         const spotPrice = await scope.getPriceFromChain(chain, oraclePrices);
         spot[tokenMint] = { price: spotPrice.price, name: tokenName };
@@ -1252,16 +1321,18 @@ export class KaminoMarket {
   /**
    * Get all Scope/Pyth/Switchboard prices used by all the market reserves
    */
-  async getAllPrices(): Promise<KlendPrices> {
+  async getAllPrices(oracleAccounts?: AllOracleAccounts): Promise<KlendPrices> {
     const klendPrices: KlendPrices = {
       scope: { spot: {}, twap: {} },
       pyth: { spot: {}, twap: {} },
       switchboard: { spot: {}, twap: {} },
     };
-    const allOracleAccounts = await getAllOracleAccounts(
-      this.connection,
-      this.getReserves().map((x) => x.state)
-    );
+    const allOracleAccounts =
+      oracleAccounts ??
+      (await getAllOracleAccounts(
+        this.connection,
+        this.getReserves().map((x) => x.state)
+      ));
     const pythCache = new PubkeyHashMap<PublicKey, PythPrices>();
     const switchboardCache = new PubkeyHashMap<PublicKey, CandidatePrice>();
     const scopeCache = new PubkeyHashMap<PublicKey, OraclePrices>();
@@ -1473,7 +1544,8 @@ export async function getReservesForMarket(
   marketAddress: PublicKey,
   connection: Connection,
   programId: PublicKey,
-  recentSlotDurationMs: number
+  recentSlotDurationMs: number,
+  oracleAccounts?: AllOracleAccounts
 ): Promise<Map<PublicKey, KaminoReserve>> {
   const reserves = await connection.getProgramAccounts(programId, {
     filters: [
@@ -1501,7 +1573,7 @@ export async function getReservesForMarket(
     return reserveAccount;
   });
   const allBuffers = reserves.map((reserve) => reserve.account);
-  const reservesAndOracles = await getTokenOracleData(connection, deserializedReserves);
+  const reservesAndOracles = await getTokenOracleData(connection, deserializedReserves, oracleAccounts);
   const reservesByAddress = new PubkeyHashMap<PublicKey, KaminoReserve>();
   reservesAndOracles.forEach(([reserve, oracle], index) => {
     if (!oracle) {
@@ -1524,7 +1596,8 @@ export async function getSingleReserve(
   reservePk: PublicKey,
   connection: Connection,
   recentSlotDurationMs: number,
-  accountData?: AccountInfo<Buffer>
+  accountData?: AccountInfo<Buffer>,
+  oracleAccounts?: AllOracleAccounts
 ): Promise<KaminoReserve> {
   const reserve = accountData ? accountData : await connection.getAccountInfo(reservePk);
 
@@ -1538,7 +1611,7 @@ export async function getSingleReserve(
     throw Error(`Could not parse reserve ${reservePk.toBase58()}`);
   }
 
-  const reservesAndOracles = await getTokenOracleData(connection, [reserveAccount]);
+  const reservesAndOracles = await getTokenOracleData(connection, [reserveAccount], oracleAccounts);
   const [reserveState, oracle] = reservesAndOracles[0];
 
   if (!oracle) {

package/src/classes/vault.ts

@@ -28,6 +28,7 @@ import {
   PubkeyHashMap,
   Reserve,
   UserState,
+  AllOracleAccounts,
 } from '../lib';
 import {
   DepositAccounts,
@@ -2324,9 +2325,13 @@ export class KaminoVaultClient {
   /**
    * This will load the onchain state for all the reserves that the vaults have allocations for, deduplicating the reserves
    * @param vaults - the vault states to load reserves for
+   * @param oracleAccounts
    * @returns a hashmap from each reserve pubkey to the reserve state
    */
-  async loadVaultsReserves(vaults: VaultState[]): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
+  async loadVaultsReserves(
+    vaults: VaultState[],
+    oracleAccounts?: AllOracleAccounts
+  ): Promise<PubkeyHashMap<PublicKey, KaminoReserve>> {
     const vaultReservesAddressesSet = new PublicKeySet(vaults.flatMap((vault) => this.getVaultReserves(vault)));
     const vaultReservesAddresses = vaultReservesAddressesSet.toArray();
     const reserveAccounts = await this.getConnection().getMultipleAccountsInfo(vaultReservesAddresses, 'processed');
@@ -2343,7 +2348,7 @@ export class KaminoVaultClient {
       return reserveAccount;
     });
 
-    const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves);
+    const reservesAndOracles = await getTokenOracleData(this.getConnection(), deserializedReserves, oracleAccounts);
 
     const kaminoReserves = new PubkeyHashMap<PublicKey, KaminoReserve>();
 
@@ -2371,13 +2376,15 @@ export class KaminoVaultClient {
    * @param [slot] - the slot for which to retrieve the vault collaterals for. Optional. If not provided the function will fetch the current slot
    * @param [vaultReservesMap] - 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 [kaminoMarkets] - a list of all the kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
+   * @param oracleAccounts
    * @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,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
-    kaminoMarkets?: KaminoMarket[]
+    kaminoMarkets?: KaminoMarket[],
+    oracleAccounts?: AllOracleAccounts
   ): Promise<PubkeyHashMap<PublicKey, MarketOverview>> {
     const vaultReservesStateMap = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
     const vaultReservesState: KaminoReserve[] = [];
@@ -2401,7 +2408,11 @@ export class KaminoVaultClient {
     const missingReservesStates = (await Reserve.fetchMultiple(this.getConnection(), missingReserves.toArray())).filter(
       (reserve) => reserve !== null
     );
-    const missingReservesAndOracles = await getTokenOracleData(this.getConnection(), missingReservesStates);
+    const missingReservesAndOracles = await getTokenOracleData(
+      this.getConnection(),
+      missingReservesStates,
+      oracleAccounts
+    );
     missingReservesAndOracles.forEach(([reserve, oracle], index) => {
       const fetchedReserve = new KaminoReserve(
         reserve,

package/src/utils/oracle.ts

@@ -107,9 +107,10 @@ export function getTokenOracleDataSync(
 // TODO: Add freshness of the latest price to match sc logic
 export async function getTokenOracleData(
   connection: Connection,
-  reserves: Reserve[]
+  reserves: Reserve[],
+  oracleAccounts?: AllOracleAccounts
 ): Promise<Array<[Reserve, TokenOracleData | undefined]>> {
-  const allOracleAccounts = await getAllOracleAccounts(connection, reserves);
+  const allOracleAccounts = oracleAccounts ?? (await getAllOracleAccounts(connection, reserves));
   const switchboardV2 = await SwitchboardProgram.loadMainnet(connection);
   return getTokenOracleDataSync(allOracleAccounts, switchboardV2, reserves);
 }