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

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;
 }
 

package/src/classes/vault.ts

@@ -28,6 +28,7 @@ import {
   PubkeyHashMap,
   Reserve,
   UserState,
+  AllOracleAccounts,
 } from '../lib';
 import {
   DepositAccounts,
@@ -838,7 +839,7 @@ export class KaminoVaultClient {
     const [{ ata: adminTokenAta, createAtaIx }] = createAtasIdempotent(vaultState.vaultAdminAuthority, [
       {
         mint: vaultState.tokenMint,
-        tokenProgram: TOKEN_PROGRAM_ID,
+        tokenProgram: vaultState.tokenProgram,
       },
     ]);
 
@@ -1635,7 +1636,7 @@ export class KaminoVaultClient {
       baseVaultAuthority: vaultState.baseVaultAuthority,
       tokenAta: adminTokenAta,
       tokenMint: vaultState.tokenMint,
-      tokenProgram: TOKEN_PROGRAM_ID,
+      tokenProgram: vaultState.tokenProgram,
       /** CPI accounts */
       lendingMarket: marketAddress,
       lendingMarketAuthority: lendingMarketAuth,
@@ -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/client.ts

@@ -362,7 +362,7 @@ async function deposit(connection: Connection, wallet: Keypair, token: string, d
     wallet.publicKey,
     new VanillaObligation(STAGING_LENDING_MARKET),
     true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
+    { scope: new Scope('mainnet-beta', connection), scopeConfigurations: [] }
   );
   console.log('User obligation', kaminoAction.getObligationPda().toString());
 
@@ -384,7 +384,7 @@ async function withdraw(connection: Connection, wallet: Keypair, token: string,
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
     true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
+    { scope: new Scope('mainnet-beta', connection), scopeConfigurations: [] }
   );
   console.log('User obligation', kaminoAction.getObligationPda().toString());
 
@@ -406,7 +406,7 @@ async function borrow(connection: Connection, wallet: Keypair, token: string, bo
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
     true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
+    { scope: new Scope('mainnet-beta', connection), scopeConfigurations: [] }
   );
   console.log('User obligation', kaminoAction.getObligationPda().toString());
 
@@ -428,7 +428,7 @@ async function repay(connection: Connection, wallet: Keypair, token: string, bor
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
     true,
-    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' },
+    { scope: new Scope('mainnet-beta', connection), scopeConfigurations: [] },
     await connection.getSlot()
   );
   console.log('User obligation', kaminoAction.getObligationPda().toString());

package/src/client_kamino_manager.ts

@@ -52,18 +52,18 @@ import {
   TokenInfo,
   WithdrawalCaps,
 } from './idl_codegen/types';
-import { Fraction } from './classes/fraction';
+import { Fraction } from './classes';
 import Decimal from 'decimal.js';
 import { BN } from '@coral-xyz/anchor';
 import { PythConfiguration, SwitchboardConfiguration } from './idl_codegen_kamino_vault/types';
 import * as fs from 'fs';
-import { MarketWithAddress } from './utils/managerTypes';
+import { MarketWithAddress } from './utils';
 import {
   ManagementFeeBps,
   PendingVaultAdmin,
   PerformanceFeeBps,
 } from './idl_codegen_kamino_vault/types/VaultConfigField';
-import { getAccountOwner } from './utils/rpc';
+import { getAccountOwner } from './utils';
 import { getAssociatedTokenAddressSync } from '@solana/spl-token';
 
 dotenv.config({
@@ -157,12 +157,12 @@ async function main() {
 
       console.log('reserve: ', reserve.publicKey);
 
-      const _createReserveSig = await processTxn(env.client, env.payer, txnIxs[0], mode, 2500, [reserve]);
+      await processTxn(env.client, env.payer, txnIxs[0], mode, 2500, [reserve]);
 
       const [lut, createLutIxs] = await createUpdateReserveConfigLutIxs(env, marketAddress, reserve.publicKey);
       await processTxn(env.client, env.payer, createLutIxs, mode, 2500, []);
 
-      const _updateSig = await processTxn(env.client, env.payer, txnIxs[1], mode, 2500, [], 400_000, 1000, [lut]);
+      await processTxn(env.client, env.payer, txnIxs[1], mode, 2500, [], 400_000, 1000, [lut]);
 
       mode === 'execute' &&
         console.log(
@@ -224,7 +224,7 @@ async function main() {
         updateEntireConfig
       );
 
-      const _updateReserveSig = await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
+      await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
 
       mode === 'execute' && console.log('Reserve Updated with config -> ', JSON.parse(JSON.stringify(reserveConfig)));
     });
@@ -296,7 +296,7 @@ async function main() {
 
       const { vault: vaultKp, initVaultIxs: instructions } = await kaminoManager.createVaultIxs(kaminoVaultConfig);
 
-      const _createVaultSig = await processTxn(
+      await processTxn(
         env.client,
         env.payer,
         [...instructions.createAtaIfNeededIxs, ...instructions.initVaultIxs, instructions.createLUTIx],
@@ -305,7 +305,7 @@ async function main() {
         [vaultKp]
       );
       await sleep(2000);
-      const _populateLUTSig = await processTxn(
+      await processTxn(
         env.client,
         env.payer,
         [...instructions.populateLUTIxs, ...instructions.cleanupIxs],
@@ -314,14 +314,7 @@ async function main() {
         []
       );
 
-      const _setSharesMetadataSig = await processTxn(
-        env.client,
-        env.payer,
-        [instructions.initSharesMetadataIx],
-        mode,
-        2500,
-        []
-      );
+      await processTxn(env.client, env.payer, [instructions.initSharesMetadataIx], mode, 2500, []);
       mode === 'execute' && console.log('Vault created:', vaultKp.publicKey.toBase58());
     });
 
@@ -1173,19 +1166,33 @@ async function main() {
       }
     });
 
-  commands.command('get-oracle-mappings').action(async () => {
-    const env = initializeClient(false, false);
-    const kaminoManager = new KaminoManager(
-      env.connection,
-      DEFAULT_RECENT_SLOT_DURATION_MS,
-      env.kLendProgramId,
-      env.kVaultProgramId
-    );
+  commands
+    .command('get-oracle-mappings')
+    .requiredOption('--lending-market <string>', 'Lending Market Address')
+    .action(async ({ lendingMarket }) => {
+      const env = initializeClient(false, false);
+      const kaminoManager = new KaminoManager(
+        env.connection,
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.kLendProgramId,
+        env.kVaultProgramId
+      );
+      const market = await KaminoMarket.load(
+        env.connection,
+        new PublicKey(lendingMarket),
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.kLendProgramId
+      );
+      if (!market) {
+        throw Error(`Lending market ${lendingMarket} not found`);
+      }
 
-    console.log('Getting  oracle mappings');
-    const oracleConfigs = await kaminoManager.getScopeOracleConfigs();
-    console.log('oracleConfigs', JSON.parse(JSON.stringify(oracleConfigs)));
-  });
+      console.log('Getting  oracle mappings');
+      const oracleConfigs = await kaminoManager.getScopeOracleConfigs(market);
+      for (const [oraclePrices, configs] of oracleConfigs.entries()) {
+        console.log(`OraclePrices pubkey: ${oraclePrices.toString()}`, 'Configs:', JSON.parse(JSON.stringify(configs)));
+      }
+    });
 
   commands.command('get-all-vaults').action(async () => {
     const env = initializeClient(false, false);
@@ -1370,7 +1377,7 @@ async function main() {
       // executing 6 ixs in a txn to make sure they fit
       for (let ixnIndex = 0; ixnIndex < ixs.length; ixnIndex += 6) {
         const ixnToExecute = ixs.slice(ixnIndex, ixnIndex + 6);
-        const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixnToExecute, mode, 2500, [], 400_000);
+        await processTxn(env.client, env.payer, ixnToExecute, mode, 2500, [], 400_000);
       }
 
       mode === 'execute' &&
@@ -1410,7 +1417,7 @@ async function main() {
 
       const ix = kaminoManager.updateLendingMarketOwnerIxs(marketWithAddress);
 
-      const _updateLendingMarketSig = await processTxn(env.client, env.payer, [ix], mode, 2500, [], 400_000);
+      await processTxn(env.client, env.payer, [ix], mode, 2500, [], 400_000);
 
       mode === 'execute' &&
         console.log(
@@ -1465,7 +1472,7 @@ async function main() {
 
       const ixs = kaminoManager.updateLendingMarketIxs(marketWithAddress, newLendingMarket);
 
-      const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
+      await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
 
       mode === 'execute' &&
         console.log(
@@ -1520,7 +1527,7 @@ async function main() {
 
       const ixs = await kaminoManager.updateReserveIxs(marketWithAddress, reserveAddress, newReserveConfig);
 
-      const _updateLendingMarketSig = await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
+      await processTxn(env.client, env.payer, ixs, mode, 2500, [], 400_000);
 
       mode === 'execute' &&
         console.log(
@@ -1811,9 +1818,7 @@ function parseBorrowRateCurve(reserveConfigFromFile: any): BorrowRateCurve {
 
   curvePoints.forEach((curvePoint, index) => (finalCurvePoints[index] = curvePoint));
 
-  const borrowRateCurve = new BorrowRateCurve({ points: finalCurvePoints });
-
-  return borrowRateCurve;
+  return new BorrowRateCurve({ points: finalCurvePoints });
 }
 
 function parseReserveBorrowLimitAgainstCollInEmode(reserveConfigFromFile: any): BN[] {