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

package/src/classes/obligation.ts

@@ -39,6 +39,11 @@ export type Position = {
   marketValueRefreshed: Decimal;
 };
 
+export type PositionChange = {
+  reserveAddress: PublicKey;
+  amountChangeLamports: Decimal;
+};
+
 export type ObligationStats = {
   userTotalDeposit: Decimal;
   userTotalCollateralDeposit: Decimal;
@@ -491,19 +496,20 @@ export class KaminoObligation {
 
   simulateDepositChange(
     obligationDeposits: ObligationCollateral[],
-    changeInLamports: number,
-    changeReserve: PublicKey,
+    depositChange: PositionChange,
     collateralExchangeRates: Map<PublicKey, Decimal>
   ): ObligationCollateral[] {
     const newDeposits: ObligationCollateral[] = [];
-    const depositIndex = obligationDeposits.findIndex((deposit) => deposit.depositReserve.equals(changeReserve));
+    const depositIndex = obligationDeposits.findIndex((deposit) =>
+      deposit.depositReserve.equals(depositChange.reserveAddress)
+    );
 
     // Always copy the previous deposits and modify the changeReserve one if it exists
     for (let i = 0; i < obligationDeposits.length; i++) {
-      if (obligationDeposits[i].depositReserve.equals(changeReserve)) {
+      if (obligationDeposits[i].depositReserve.equals(depositChange.reserveAddress)) {
         const coll: ObligationCollateralFields = { ...obligationDeposits[i] };
-        const exchangeRate = collateralExchangeRates.get(changeReserve)!;
-        const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
+        const exchangeRate = collateralExchangeRates.get(depositChange.reserveAddress)!;
+        const changeInCollateral = new Decimal(depositChange.amountChangeLamports).mul(exchangeRate).toFixed(0);
         const updatedDeposit = new Decimal(obligationDeposits[i].depositedAmount.toNumber()).add(changeInCollateral);
         coll.depositedAmount = new BN(positiveOrZero(updatedDeposit).toString());
         newDeposits.push(new ObligationCollateral(coll));
@@ -523,10 +529,10 @@ export class KaminoObligation {
       }
 
       const coll: ObligationCollateralFields = { ...obligationDeposits[firstBorrowIndexAvailable] };
-      const exchangeRate = collateralExchangeRates.get(changeReserve)!;
-      const changeInCollateral = new Decimal(changeInLamports).mul(exchangeRate).toFixed(0);
+      const exchangeRate = collateralExchangeRates.get(depositChange.reserveAddress)!;
+      const changeInCollateral = new Decimal(depositChange.amountChangeLamports).mul(exchangeRate).toFixed(0);
       coll.depositedAmount = new BN(positiveOrZero(new Decimal(changeInCollateral)).toString());
-      coll.depositReserve = changeReserve;
+      coll.depositReserve = depositChange.reserveAddress;
 
       newDeposits[firstBorrowIndexAvailable] = new ObligationCollateral(coll);
     }
@@ -536,18 +542,21 @@ export class KaminoObligation {
 
   simulateBorrowChange(
     obligationBorrows: ObligationLiquidity[],
-    changeInLamports: number,
-    changeReserve: PublicKey,
+    borrowChange: PositionChange,
     cumulativeBorrowRate: Decimal
   ): ObligationLiquidity[] {
     const newBorrows: ObligationLiquidity[] = [];
-    const borrowIndex = obligationBorrows.findIndex((borrow) => borrow.borrowReserve.equals(changeReserve));
+    const borrowIndex = obligationBorrows.findIndex((borrow) =>
+      borrow.borrowReserve.equals(borrowChange.reserveAddress)
+    );
 
     // Always copy the previous borrows and modify the changeReserve one if it exists
     for (let i = 0; i < obligationBorrows.length; i++) {
-      if (obligationBorrows[i].borrowReserve.equals(changeReserve)) {
+      if (obligationBorrows[i].borrowReserve.equals(borrowChange.reserveAddress)) {
         const borrow: ObligationLiquidityFields = { ...obligationBorrows[borrowIndex] };
-        const newBorrowedAmount: Decimal = new Fraction(borrow.borrowedAmountSf).toDecimal().add(changeInLamports);
+        const newBorrowedAmount: Decimal = new Fraction(borrow.borrowedAmountSf)
+          .toDecimal()
+          .add(borrowChange.amountChangeLamports);
         const newBorrowedAmountSf = Fraction.fromDecimal(positiveOrZero(newBorrowedAmount)).getValue();
         borrow.borrowedAmountSf = newBorrowedAmountSf;
 
@@ -568,8 +577,8 @@ export class KaminoObligation {
       }
 
       const borrow: ObligationLiquidityFields = { ...obligationBorrows[firstBorrowIndexAvailable] };
-      borrow.borrowedAmountSf = Fraction.fromDecimal(new Decimal(changeInLamports)).getValue();
-      borrow.borrowReserve = changeReserve;
+      borrow.borrowedAmountSf = Fraction.fromDecimal(new Decimal(borrowChange.amountChangeLamports)).getValue();
+      borrow.borrowReserve = borrowChange.reserveAddress;
       borrow.cumulativeBorrowRateBsf = {
         padding: [],
         value: [Fraction.fromDecimal(cumulativeBorrowRate).getValue(), new BN(0), new BN(0), new BN(0)],
@@ -643,8 +652,10 @@ export class KaminoObligation {
         }
         newObligationDeposits = this.simulateDepositChange(
           this.state.deposits,
-          amountCollateral.toNumber(),
-          collateralReservePk!,
+          {
+            reserveAddress: collateralReservePk!,
+            amountChangeLamports: amountCollateral,
+          },
           collateralExchangeRates
         );
         break;
@@ -656,8 +667,10 @@ export class KaminoObligation {
 
         newObligationBorrows = this.simulateBorrowChange(
           this.state.borrows,
-          amountDebt.toNumber(),
-          debtReservePk!,
+          {
+            reserveAddress: debtReservePk!,
+            amountChangeLamports: amountDebt,
+          },
           debtReserveCumulativeBorrowRate!
         );
         break;
@@ -669,8 +682,10 @@ export class KaminoObligation {
 
         newObligationBorrows = this.simulateBorrowChange(
           this.state.borrows,
-          amountDebt.neg().toNumber(),
-          debtReservePk!,
+          {
+            reserveAddress: debtReservePk!,
+            amountChangeLamports: amountDebt.neg(),
+          },
           debtReserveCumulativeBorrowRate!
         );
 
@@ -683,8 +698,10 @@ export class KaminoObligation {
         }
         newObligationDeposits = this.simulateDepositChange(
           this.state.deposits,
-          amountCollateral.neg().toNumber(),
-          collateralReservePk!,
+          {
+            reserveAddress: collateralReservePk!,
+            amountChangeLamports: amountCollateral.neg(),
+          },
           collateralExchangeRates
         );
         break;
@@ -700,15 +717,19 @@ export class KaminoObligation {
         }
         newObligationDeposits = this.simulateDepositChange(
           this.state.deposits,
-          amountCollateral.toNumber(),
-          collateralReservePk!,
+          {
+            reserveAddress: collateralReservePk!,
+            amountChangeLamports: amountCollateral,
+          },
           collateralExchangeRates
         );
 
         newObligationBorrows = this.simulateBorrowChange(
           this.state.borrows,
-          amountDebt.toNumber(),
-          debtReservePk!,
+          {
+            reserveAddress: debtReservePk!,
+            amountChangeLamports: amountDebt,
+          },
           debtReserveCumulativeBorrowRate!
         );
         break;
@@ -724,14 +745,18 @@ export class KaminoObligation {
         }
         newObligationDeposits = this.simulateDepositChange(
           this.state.deposits,
-          amountCollateral.neg().toNumber(),
-          collateralReservePk!,
+          {
+            reserveAddress: collateralReservePk!,
+            amountChangeLamports: amountCollateral.neg(),
+          },
           collateralExchangeRates
         );
         newObligationBorrows = this.simulateBorrowChange(
           this.state.borrows,
-          amountDebt.neg().toNumber(),
-          debtReservePk!,
+          {
+            reserveAddress: debtReservePk!,
+            amountChangeLamports: amountDebt.neg(),
+          },
           debtReserveCumulativeBorrowRate!
         );
         break;
@@ -803,14 +828,18 @@ export class KaminoObligation {
     let newObligationDeposits = this.state.deposits;
     newObligationDeposits = this.simulateDepositChange(
       newObligationDeposits,
-      withdrawAmountLamports.neg().toNumber(),
-      withdrawReserveAddress,
+      {
+        reserveAddress: withdrawReserveAddress,
+        amountChangeLamports: withdrawAmountLamports.neg(),
+      },
       collateralExchangeRates
     );
     newObligationDeposits = this.simulateDepositChange(
       newObligationDeposits,
-      depositAmountLamports.toNumber(),
-      depositReserveAddress,
+      {
+        reserveAddress: depositReserveAddress,
+        amountChangeLamports: depositAmountLamports,
+      },
       collateralExchangeRates
     );
 
@@ -947,6 +976,7 @@ export class KaminoObligation {
       } else {
         exchangeRate = reserve.getCollateralExchangeRate();
       }
+
       const supplyAmount = new Decimal(deposit.depositedAmount.toString()).div(exchangeRate);
 
       const depositValueUsd = supplyAmount.mul(getPx(reserve)).div(reserve.getMintFactor());
@@ -1074,6 +1104,73 @@ export class KaminoObligation {
     return borrowLimit.div(userTotalCollateralDeposit);
   }
 
+  /**
+   * Creates a new KaminoObligation with simulated position changes applied.
+   * This allows you to model what the obligation would look like with deposits/borrows
+   * without actually executing those transactions.
+   *
+   * @param market - The KaminoMarket instance
+   * @param slot - The slot number for rate calculations
+   * @param depositChanges - Optional array of deposit changes to apply
+   * @param borrowChanges - Optional array of borrow changes to apply
+   * @returns A new KaminoObligation instance with the changes applied
+   */
+  withPositionChanges(
+    market: KaminoMarket,
+    slot: number,
+    depositChanges?: PositionChange[],
+    borrowChanges?: PositionChange[]
+  ): KaminoObligation {
+    const reservesToRefresh: PublicKey[] = [];
+
+    if (depositChanges) {
+      reservesToRefresh.push(...depositChanges.map((change) => change.reserveAddress));
+    }
+    if (borrowChanges) {
+      reservesToRefresh.push(...borrowChanges.map((change) => change.reserveAddress));
+    }
+
+    const { collateralExchangeRates, cumulativeBorrowRates } = KaminoObligation.getRatesForObligation(
+      market,
+      this.state,
+      slot,
+      reservesToRefresh
+    );
+
+    let newDeposits: ObligationCollateral[] = this.state.deposits;
+    if (depositChanges) {
+      for (const depositChange of depositChanges) {
+        newDeposits = this.simulateDepositChange(newDeposits, depositChange, collateralExchangeRates);
+      }
+    }
+
+    let newBorrows: ObligationLiquidity[] = this.state.borrows;
+    if (borrowChanges) {
+      for (const borrowChange of borrowChanges) {
+        const reserve = market.getReserveByAddress(borrowChange.reserveAddress);
+        if (!reserve) {
+          throw new Error(`Reserve not found: ${borrowChange.reserveAddress}`);
+        }
+        newBorrows = this.simulateBorrowChange(newBorrows, borrowChange, reserve.getCumulativeBorrowRate());
+      }
+    }
+
+    // Create a deep copy of the obligation state and override deposits/borrows
+    const newObligationState = new Obligation({
+      ...this.state,
+      deposits: newDeposits,
+      borrows: newBorrows,
+    });
+
+    return new KaminoObligation(
+      market,
+      this.obligationAddress,
+      newObligationState,
+      collateralExchangeRates,
+      cumulativeBorrowRates
+    );
+  }
+
   /*
     How much of a given token can a user borrow extra given an elevation group,
     regardless of caps and liquidity or assuming infinite liquidity and infinite caps,
@@ -1196,6 +1293,36 @@ export class KaminoObligation {
     }
   }
 
+  /*
+    Same as getMaxBorrowAmountV2 but assumes a deposit is made first, calculating
+    the new borrow power after the deposit, without overriding the obligation itself.
+
+    * @param market - The KaminoMarket instance.
+    * @param liquidityMint - The liquidity mint Address.
+    * @param slot - The slot number.
+    * @param elevationGroup - The elevation group number (default: this.state.elevationGroup).
+    * @returns The maximum borrow amount as a Decimal.
+    * @throws Error if the reserve is not found.
+  */
+  getMaxBorrowAmountV2WithDeposit(
+    market: KaminoMarket,
+    liquidityMint: PublicKey,
+    slot: number,
+    elevationGroup: number = this.state.elevationGroup,
+    depositAmountLamports: Decimal,
+    depositReserveAddress: PublicKey
+  ): Decimal {
+    const depositChanges = [
+      {
+        reserveAddress: depositReserveAddress,
+        amountChangeLamports: depositAmountLamports,
+      },
+    ];
+    const obligationWithDeposit = this.withPositionChanges(market, slot, depositChanges);
+
+    return obligationWithDeposit.getMaxBorrowAmountV2(market, liquidityMint, slot, elevationGroup);
+  }
+
   /*
     Returns true if the loan is eligible for the elevation group, including for the default one.
     * @param market - The KaminoMarket object representing the market.
@@ -1447,6 +1574,44 @@ export class KaminoObligation {
     );
   }
 
+  /**
+   * Same as getMaxWithdrawAmount but assumes a repay is made first, calculating
+   * the new withdraw power after the repay, without overriding the obligation itself.
+   *
+   * @param market - The KaminoMarket instance.
+   * @param tokenMint - The liquidity mint Address.
+   * @param slot - The slot number.
+   * @param repayAmountLamports - The amount to repay in lamports (use U64_MAX for full repay).
+   * @param repayReserveAddress - The reserve address of the borrow being repaid.
+   * @returns The maximum withdraw amount as a Decimal.
+   * @throws Error if the reserve is not found.
+   */
+  getMaxWithdrawAmountWithRepay(
+    market: KaminoMarket,
+    tokenMint: PublicKey,
+    slot: number,
+    repayAmountLamports: Decimal,
+    repayReserveAddress: PublicKey
+  ): Decimal {
+    const repayReserve = market.getReserveByAddress(repayReserveAddress);
+    if (!repayReserve) {
+      throw new Error('Reserve not found');
+    }
+
+    const repayAmount = repayAmountLamports.equals(U64_MAX)
+      ? this.getBorrowAmountByReserve(repayReserve)
+      : repayAmountLamports;
+    const borrowChanges = [
+      {
+        reserveAddress: repayReserveAddress,
+        amountChangeLamports: repayAmount.neg(), // as it's a repay
+      },
+    ];
+    const obligationWithRepay = this.withPositionChanges(market, slot, undefined, borrowChanges);
+
+    return obligationWithRepay.getMaxWithdrawAmount(market, tokenMint, slot);
+  }
+
   getObligationLiquidityByReserve(reserveAddress: PublicKey): ObligationLiquidity {
     const obligationLiquidity = this.state.borrows.find((borrow) => borrow.borrowReserve.equals(reserveAddress));
 

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[] {