@kamino-finance/klend-sdk 6.0.5-beta.2 → 6.0.5-beta.21

package/src/classes/market.ts

@@ -22,6 +22,8 @@ import {
   CandidatePrice,
   PublicKeySet,
   DEPOSITS_LIMIT,
+  setOrAppend,
+  AllOracleAccounts,
 } from '../utils';
 import base58 from 'bs58';
 import { BN } from '@coral-xyz/anchor';
@@ -31,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';
@@ -62,9 +64,7 @@ export class KaminoMarket {
 
   private readonly recentSlotDurationMs: number;
 
-  // key = scope feed (oracle prices) pubkey
-  // value = reserve pubkey
-  private readonly reserveScopeFeeds: PubkeyHashMap<PublicKey, PublicKey>;
+  readonly scopeFeeds: PublicKeySet<PublicKey>;
 
   private constructor(
     connection: Connection,
@@ -74,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;
@@ -81,10 +85,10 @@ export class KaminoMarket {
     this.reservesActive = getReservesActive(this.reserves);
     this.programId = programId;
     this.recentSlotDurationMs = recentSlotDurationMs;
-    this.reserveScopeFeeds = new PubkeyHashMap(
+    this.scopeFeeds = new PublicKeySet(
       Array.from(this.reserves.values())
         .filter((r) => isNotNullPubkey(r.state.config.tokenInfo.scopeConfiguration.priceFeed))
-        .map((r) => [r.address, r.state.config.tokenInfo.scopeConfiguration.priceFeed])
+        .map((r) => r.state.config.tokenInfo.scopeConfiguration.priceFeed)
     );
   }
 
@@ -95,7 +99,6 @@ export class KaminoMarket {
    * @param recentSlotDurationMs
    * @param programId
    * @param withReserves
-   * @param setupLocalTest
    * @param withReserves
    */
   static async load(
@@ -111,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>();
@@ -133,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) {
@@ -373,19 +434,19 @@ export class KaminoMarket {
   /**
    * @returns The max borrowable amount for leverage positions
    */
-  async getMaxLeverageBorrowableAmount(
+  getMaxLeverageBorrowableAmount(
     collReserve: KaminoReserve,
     debtReserve: KaminoReserve,
     slot: number,
     requestElevationGroup: boolean,
     obligation?: KaminoObligation
-  ): Promise<Decimal> {
+  ): Decimal {
     return obligation
       ? obligation.getMaxBorrowAmount(this, debtReserve.getLiquidityMint(), slot, requestElevationGroup)
       : 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) => {
@@ -399,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) {
@@ -851,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: [
           {
@@ -1211,12 +1276,16 @@ export class KaminoMarket {
    */
   async getReserveOraclePrices(scope: Scope): Promise<PubkeyHashMap<PublicKey, OraclePrices>> {
     const reserveOraclePrices: PubkeyHashMap<PublicKey, OraclePrices> = new PubkeyHashMap();
-    const oraclePrices = await scope.getMultipleOraclePrices(Array.from(this.reserveScopeFeeds.values()));
-    for (const [feed, oraclePricesAccount] of oraclePrices) {
-      const reserve = this.reserveScopeFeeds.get(feed);
-      if (reserve) {
-        reserveOraclePrices.set(reserve, oraclePricesAccount);
-      }
+    const oraclePrices = await scope.getMultipleOraclePrices(this.scopeFeeds.toArray());
+    const oraclePriceMap = new PubkeyHashMap<PublicKey, OraclePrices>();
+    for (const [feed, account] of oraclePrices) {
+      oraclePriceMap.set(feed, account);
+    }
+    for (const [reserveAddress, reserve] of this.reserves) {
+      reserveOraclePrices.set(
+        reserveAddress,
+        oraclePriceMap.get(reserve.state.config.tokenInfo.scopeConfiguration.priceFeed)!
+      );
     }
     return reserveOraclePrices;
   }
@@ -1224,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()) {
@@ -1234,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 };
@@ -1250,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>();
@@ -1471,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: [
@@ -1499,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) {
@@ -1522,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);
 
@@ -1536,22 +1611,13 @@ 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) {
     throw Error(`Could not find oracle for ${parseTokenSymbol(reserveState.config.tokenInfo.name)} reserve`);
   }
-  const kaminoReserve = KaminoReserve.initialize(
-    reserve,
-    reservePk,
-    reserveState,
-    oracle,
-    connection,
-    recentSlotDurationMs
-  );
-
-  return kaminoReserve;
+  return KaminoReserve.initialize(reserve, reservePk, reserveState, oracle, connection, recentSlotDurationMs);
 }
 
 export function getReservesActive(reserves: Map<PublicKey, KaminoReserve>): Map<PublicKey, KaminoReserve> {
@@ -1564,8 +1630,11 @@ export function getReservesActive(reserves: Map<PublicKey, KaminoReserve>): Map<
   return reservesActive;
 }
 
-export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: PublicKey[]): number[] {
-  const tokenIds: number[] = [];
+export function getTokenIdsForScopeRefresh(
+  kaminoMarket: KaminoMarket,
+  reserves: PublicKey[]
+): PubkeyHashMap<PublicKey, number[]> {
+  const tokenIds = new PubkeyHashMap<PublicKey, number[]>();
 
   for (const reserveAddress of reserves) {
     const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
@@ -1573,22 +1642,33 @@ export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves:
       throw new Error(`Reserve not found for reserve ${reserveAddress.toBase58()}`);
     }
 
-    if (!reserve.state.config.tokenInfo.scopeConfiguration.priceFeed.equals(PublicKey.default)) {
+    const { scopeConfiguration } = reserve.state.config.tokenInfo;
+    if (!scopeConfiguration.priceFeed.equals(PublicKey.default)) {
       let x = 0;
 
-      while (reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x] !== U16_MAX) {
-        tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.priceChain[x]);
+      while (scopeConfiguration.priceChain[x] !== U16_MAX) {
+        setOrAppend(tokenIds, scopeConfiguration.priceFeed, scopeConfiguration.priceChain[x]);
         x++;
       }
 
       x = 0;
-      while (reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x] !== U16_MAX) {
-        tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x]);
+      while (scopeConfiguration.twapChain[x] !== U16_MAX) {
+        setOrAppend(tokenIds, scopeConfiguration.priceFeed, scopeConfiguration.twapChain[x]);
         x++;
       }
     }
   }
 
+  //TODO: remove code below
+  // - currently Scope program does not allow multiple refreshPricesList instructions in 1 ix
+  // - temporary fix is to only refresh one scope feed at this time
+  const firstFeed = tokenIds.entries().next();
+  tokenIds.clear();
+  if (!firstFeed.done) {
+    const [key, value] = firstFeed.value;
+    tokenIds.set(key, value);
+  }
+
   return tokenIds;
 }