@kamino-finance/klend-sdk 5.11.2-beta.0 → 5.11.3-beta.0

package/src/classes/lut_utils.ts

@@ -0,0 +1,63 @@
+import { AddressLookupTableProgram, Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
+
+/**
+ * This method retuns an instruction that creates a lookup table, alongside the pubkey of the lookup table
+ * @param payer - the owner of the lookup table
+ * @param slot - the current slot
+ * @returns - the instruction to create the lookup table and its address
+ */
+export function initLookupTableIx(payer: PublicKey, slot: number): [TransactionInstruction, PublicKey] {
+  const [ixn, address] = AddressLookupTableProgram.createLookupTable({
+    authority: payer,
+    payer,
+    recentSlot: slot,
+  });
+
+  return [ixn, address];
+}
+
+/**
+ * This method retuns an instruction that deactivates a lookup table, which is needed to close it
+ * @param payer - the owner of the lookup table
+ * @param lookupTable - the lookup table to deactivate
+ * @returns - the instruction to deactivate the lookup table
+ */
+export function deactivateLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ixn = AddressLookupTableProgram.deactivateLookupTable({
+    authority: payer,
+    lookupTable: lookupTable,
+  });
+
+  return ixn;
+}
+
+/**
+ * This method returns an instruction that closes a lookup table. That lookup table needs to be disabled at least 500 blocks before closing it.
+ * @param payer - the owner of the lookup table
+ * @param lookupTable - the lookup table to close
+ * @returns - the instruction to close the lookup table
+ */
+/// this require the LUT to be deactivated at least 500 blocks before
+export function closeLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ixn = AddressLookupTableProgram.closeLookupTable({
+    authority: payer,
+    recipient: payer,
+    lookupTable: lookupTable,
+  });
+
+  return ixn;
+}
+
+/**
+ * Returns the accounts in a lookup table
+ * @param lookupTable - lookup table to get the accounts from
+ * @returns - an array of accounts in the lookup table
+ */
+export async function getAccountsInLUT(connection: Connection, lookupTable: PublicKey): Promise<PublicKey[]> {
+  const lutState = await connection.getAddressLookupTable(lookupTable);
+  if (!lutState || !lutState.value) {
+    throw new Error(`Lookup table ${lookupTable} not found`);
+  }
+
+  return lutState.value.state.addresses;
+}

package/src/classes/manager.ts

@@ -949,7 +949,7 @@ export class KaminoManager {
   }
 
   /**
-   * This retruns an array of scope oracle configs to be used to set the scope price and twap oracles for a reserve
+   * This returns an array of scope oracle configs to be used to set the scope price and twap oracles for a reserve
    * @param feed - scope feed to fetch prices from
    * @param cluster - cluster to fetch from, this should be left unchanged unless working on devnet or locally
    * @returns - an array of scope oracle configs

package/src/classes/market.ts

@@ -29,7 +29,7 @@ import Decimal from 'decimal.js';
 import { FarmState } from '@kamino-finance/farms-sdk';
 import { PROGRAM_ID } from '../idl_codegen/programId';
 import bs58 from 'bs58';
-import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
+import { OraclePrices, Scope, U16_MAX } from '@kamino-finance/scope-sdk';
 import { Fraction } from './fraction';
 import { chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
@@ -59,8 +59,6 @@ export class KaminoMarket {
 
   readonly programId: PublicKey;
 
-  scope: Scope;
-
   private readonly recentSlotDurationMs: number;
 
   private constructor(
@@ -68,7 +66,6 @@ export class KaminoMarket {
     state: LendingMarket,
     marketAddress: string,
     reserves: Map<PublicKey, KaminoReserve>,
-    scope: Scope,
     recentSlotDurationMs: number,
     programId: PublicKey = PROGRAM_ID
   ) {
@@ -78,7 +75,6 @@ export class KaminoMarket {
     this.reserves = reserves;
     this.reservesActive = getReservesActive(this.reserves);
     this.programId = programId;
-    this.scope = scope;
     this.recentSlotDurationMs = recentSlotDurationMs;
   }
 
@@ -97,7 +93,6 @@ export class KaminoMarket {
     marketAddress: PublicKey,
     recentSlotDurationMs: number,
     programId: PublicKey = PROGRAM_ID,
-    setupLocalTest: boolean = false,
     withReserves: boolean = true
   ) {
     const market = await LendingMarket.fetch(connection, marketAddress, programId);
@@ -105,26 +100,12 @@ export class KaminoMarket {
     if (market === null) {
       return null;
     }
-    let scope: Scope;
-    if (!setupLocalTest) {
-      scope = new Scope('mainnet-beta', connection);
-    } else {
-      scope = new Scope('localnet', connection);
-    }
 
     const reserves = withReserves
       ? await getReservesForMarket(marketAddress, connection, programId, recentSlotDurationMs)
       : new Map<PublicKey, KaminoReserve>();
 
-    return new KaminoMarket(
-      connection,
-      market,
-      marketAddress.toString(),
-      reserves,
-      scope,
-      recentSlotDurationMs,
-      programId
-    );
+    return new KaminoMarket(connection, market, marketAddress.toString(), reserves, recentSlotDurationMs, programId);
   }
 
   async reload(): Promise<void> {
@@ -1186,9 +1167,9 @@ export class KaminoMarket {
   /**
    * Get all Scope prices used by all the market reserves
    */
-  async getAllScopePrices(oraclePrices?: OraclePrices): Promise<KaminoPrices> {
+  async getAllScopePrices(scope: Scope, oraclePrices?: OraclePrices): Promise<KaminoPrices> {
     if (!oraclePrices) {
-      oraclePrices = await this.scope.getOraclePrices();
+      oraclePrices = await scope.getOraclePrices();
     }
     const spot: MintToPriceMap = {};
     const twaps: MintToPriceMap = {};
@@ -1199,11 +1180,11 @@ export class KaminoMarket {
       const chain = reserve.state.config.tokenInfo.scopeConfiguration.priceChain;
       const twapChain = reserve.state.config.tokenInfo.scopeConfiguration.twapChain.filter((x) => x > 0);
       if (oracle && isNotNullPubkey(oracle) && chain && Scope.isScopeChainValid(chain)) {
-        const spotPrice = await this.scope.getPriceFromChain(chain, oraclePrices);
+        const spotPrice = await scope.getPriceFromChain(chain, oraclePrices);
         spot[tokenMint] = { price: spotPrice.price, name: tokenName };
       }
       if (oracle && isNotNullPubkey(oracle) && twapChain && Scope.isScopeChainValid(twapChain)) {
-        const twap = await this.scope.getPriceFromChain(twapChain, oraclePrices);
+        const twap = await scope.getPriceFromChain(twapChain, oraclePrices);
         twaps[tokenMint] = { price: twap.price, name: tokenName };
       }
     }
@@ -1527,6 +1508,34 @@ export function getReservesActive(reserves: Map<PublicKey, KaminoReserve>): Map<
   return reservesActive;
 }
 
+export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: PublicKey[]): number[] {
+  const tokenIds: number[] = [];
+
+  for (const reserveAddress of reserves) {
+    const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
+    if (!reserve) {
+      throw new Error(`Reserve not found for reserve ${reserveAddress.toBase58()}`);
+    }
+
+    if (!reserve.state.config.tokenInfo.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]);
+        x++;
+      }
+
+      x = 0;
+      while (reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x] !== U16_MAX) {
+        tokenIds.push(reserve.state.config.tokenInfo.scopeConfiguration.twapChain[x]);
+        x++;
+      }
+    }
+  }
+
+  return tokenIds;
+}
+
 export async function getReserveFromMintAndMarket(
   connection: Connection,
   market: KaminoMarket,

package/src/classes/obligation.ts

@@ -17,6 +17,7 @@ import {
   getObligationPdaWithArgs,
   getObligationType,
   isNotNullPubkey,
+  ObligationType,
   PubkeyHashMap,
   TOTAL_NUMBER_OF_IDS_TO_CHECK,
   U64_MAX,
@@ -266,7 +267,7 @@ export class KaminoObligation {
   /**
    * @returns total borrow power of the obligation, relative to max LTV of each asset's reserve
    */
-  getMaxAllowedBorrowValue(): Decimal {
+  getAllowedBorrowValue(): Decimal {
     return new Fraction(this.state.allowedBorrowValueSf).toDecimal();
   }
 
@@ -1593,3 +1594,8 @@ export class KaminoObligation {
     }
   }
 }
+
+// Create a function that checks if an obligation is of type obligation or obligationType
+export function isKaminoObligation(obligation: KaminoObligation | ObligationType): obligation is KaminoObligation {
+  return 'obligationAddress' in obligation;
+}

package/src/classes/vault.ts

@@ -82,7 +82,7 @@ import {
 import { batchFetch, collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
 import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
 import { FarmState } from '@kamino-finance/farms-sdk/dist';
-import { getAccountsInLUT, initLookupTableIx } from '../utils/lookupTable';
+import { getAccountsInLUT, initLookupTableIx } from './lut_utils';
 import {
   getFarmStakeIxs,
   getFarmUnstakeAndWithdrawIxs,

package/src/client.ts

@@ -22,6 +22,7 @@ import { VanillaObligation } from './utils/ObligationType';
 import { parseTokenSymbol } from './classes/utils';
 import { Env, initEnv } from '../tests/runner/setup_utils';
 import { initializeFarmsForReserve } from '../tests/runner/farms/farms_operations';
+import { Scope } from '@kamino-finance/scope-sdk';
 
 const STAGING_LENDING_MARKET = new PublicKey('6WVSwDQXrBZeQVnu6hpnsRZhodaJTZBUaC334SiiBKdb');
 const MAINNET_LENDING_MARKET = new PublicKey('7u3HeHxYDLhnCoErrtycNokbQYbWGzLs6JSDqGAv5PfF');
@@ -309,7 +310,8 @@ async function deposit(connection: Connection, wallet: Keypair, token: string, d
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(STAGING_LENDING_MARKET),
-    true
+    true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -330,7 +332,8 @@ async function withdraw(connection: Connection, wallet: Keypair, token: string,
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
-    true
+    true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -351,7 +354,8 @@ async function borrow(connection: Connection, wallet: Keypair, token: string, bo
     kaminoMarket.getReserveBySymbol(token)!.getLiquidityMint(),
     wallet.publicKey,
     new VanillaObligation(new PublicKey(STAGING_LENDING_MARKET)),
-    true
+    true,
+    { scope: new Scope('mainnet-beta', connection), scopeFeed: 'hubble' }
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());
 
@@ -373,6 +377,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' },
     await connection.getSlot()
   );
   console.log('User obligation', kaminoAction.obligation!.obligationAddress.toString());

package/src/lending_operations/repay_with_collateral_calcs.ts

@@ -2,7 +2,6 @@ import Decimal from 'decimal.js';
 import { KaminoMarket, KaminoObligation, KaminoReserve, numberToLamportsDecimal } from '../classes';
 import { PublicKey } from '@solana/web3.js';
 import { lamportsToDecimal } from '../classes/utils';
-import { MaxWithdrawLtvCheck, getMaxWithdrawLtvCheck } from './repay_with_collateral_operations';
 
 export function calcRepayAmountWithSlippage(
   kaminoMarket: KaminoMarket,
@@ -103,7 +102,6 @@ export function calcMaxWithdrawCollateral(
       .filter((p) => !p.reserveAddress.equals(borrow.reserveAddress))
       .reduce((acc, b) => acc.add(b.marketValueRefreshed), new Decimal('0'));
   }
-  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(obligation);
 
   let remainingDepositsValueWithLtv = new Decimal('0');
   if (obligation.getDeposits().length > 1) {
@@ -111,13 +109,8 @@ export function calcMaxWithdrawCollateral(
       .getDeposits()
       .filter((p) => !p.reserveAddress.equals(deposit.reserveAddress))
       .reduce((acc, d) => {
-        const { maxLtv, liquidationLtv } = obligation.getLtvForReserve(
-          market,
-          market.getReserveByAddress(d.reserveAddress)!
-        );
-        const maxWithdrawLtv =
-          maxWithdrawLtvCheck === MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD ? liquidationLtv : maxLtv;
-        return acc.add(d.marketValueRefreshed.mul(maxWithdrawLtv));
+        const { maxLtv } = obligation.getLtvForReserve(market, market.getReserveByAddress(d.reserveAddress)!);
+        return acc.add(d.marketValueRefreshed.mul(maxLtv));
       }, new Decimal('0'));
   }
 
@@ -130,18 +123,16 @@ export function calcMaxWithdrawCollateral(
       repayingAllDebt: repayAmountLamports.gte(borrow.amount),
     };
   } else {
-    const { maxLtv: collMaxLtv, liquidationLtv: collLiquidationLtv } = obligation.getLtvForReserve(
+    const { maxLtv: collMaxLtv } = obligation.getLtvForReserve(
       market,
       market.getReserveByAddress(depositReserve.address)!
     );
-    const maxWithdrawLtv =
-      maxWithdrawLtvCheck === MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD ? collLiquidationLtv : collMaxLtv;
     const numerator = deposit.marketValueRefreshed
-      .mul(maxWithdrawLtv)
+      .mul(collMaxLtv)
       .add(remainingDepositsValueWithLtv)
       .sub(remainingBorrowsValue);
 
-    const denominator = depositReserve.getOracleMarketPrice().mul(maxWithdrawLtv);
+    const denominator = depositReserve.getOracleMarketPrice().mul(collMaxLtv);
     const maxCollWithdrawAmount = numerator.div(denominator);
     const withdrawableCollLamports = maxCollWithdrawAmount.mul(depositReserve.getMintFactor()).floor();
 

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -6,12 +6,13 @@ import {
   SwapIxs,
   SwapIxsProvider,
   SwapQuoteProvider,
+  getScopeRefreshIx,
 } from '../leverage';
 import {
   createAtasIdempotent,
   getComputeBudgetAndPriorityFeeIxns,
   removeBudgetAndAtaIxns,
-  ScopeRefresh,
+  ScopePriceRefreshConfig,
   U64_MAX,
   uniqueAccounts,
 } from '../utils';
@@ -51,16 +52,11 @@ interface RepayWithCollSwapInputsProps<QuoteResponse> {
   repayAmount: Decimal;
   isClosingPosition: boolean;
   budgetAndPriorityFeeIxs?: TransactionInstruction[];
-  scopeRefresh?: ScopeRefresh;
+  scopeRefreshConfig?: ScopePriceRefreshConfig;
   useV2Ixs: boolean;
   quoter: SwapQuoteProvider<QuoteResponse>;
 }
 
-export enum MaxWithdrawLtvCheck {
-  MAX_LTV,
-  LIQUIDATION_THRESHOLD,
-}
-
 export async function getRepayWithCollSwapInputs<QuoteResponse>({
   collTokenMint,
   currentSlot,
@@ -72,7 +68,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   repayAmount,
   isClosingPosition,
   budgetAndPriorityFeeIxs,
-  scopeRefresh,
+  scopeRefreshConfig,
   useV2Ixs,
 }: RepayWithCollSwapInputsProps<QuoteResponse>): Promise<{
   swapInputs: SwapInputs;
@@ -131,7 +127,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     referrer,
     currentSlot,
     budgetAndPriorityFeeIxs,
-    scopeRefresh,
+    scopeRefreshConfig,
     {
       preActionIxs: [],
       swapIxs: [],
@@ -196,7 +192,7 @@ export async function getRepayWithCollIxs<QuoteResponse>({
   quoter,
   swapper,
   referrer,
-  scopeRefresh,
+  scopeRefreshConfig,
   useV2Ixs,
   logger = console.log,
 }: RepayWithCollIxsProps<QuoteResponse>): Promise<RepayWithCollIxsResponse<QuoteResponse>> {
@@ -211,23 +207,14 @@ export async function getRepayWithCollIxs<QuoteResponse>({
     repayAmount,
     isClosingPosition,
     budgetAndPriorityFeeIxs,
-    scopeRefresh,
+    scopeRefreshConfig,
     useV2Ixs,
   });
   const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
-  const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
-
-  if (!collReserve) {
-    throw new Error(`Collateral reserve with mint ${collTokenMint} not found in market ${kaminoMarket.getAddress()}`);
-  }
-
-  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
-
-  if (!debtReserve) {
-    throw new Error(`Debt reserve with mint ${debtTokenMint} not found in market ${kaminoMarket.getAddress()}`);
-  }
+  const collReserve = kaminoMarket.getReserveByMint(collTokenMint)!;
+  const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint)!;
 
   // the client should use these values to prevent this input, but the tx may succeed, so we don't want to fail
   // there is also a chance that the tx will consume debt token from the user's ata which they would not expect
@@ -258,7 +245,7 @@ export async function getRepayWithCollIxs<QuoteResponse>({
     referrer,
     currentSlot,
     budgetAndPriorityFeeIxs,
-    scopeRefresh,
+    scopeRefreshConfig,
     swapResponse,
     isClosingPosition,
     debtRepayAmountLamports,
@@ -282,7 +269,7 @@ async function buildRepayWithCollateralIxs(
   referrer: PublicKey,
   currentSlot: number,
   budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
-  scopeRefresh: ScopeRefresh | undefined,
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
   swapQuoteIxs: SwapIxs,
   isClosingPosition: boolean,
   debtRepayAmountLamports: Decimal,
@@ -300,9 +287,11 @@ async function buildRepayWithCollateralIxs(
   const atasAndIxs = createAtasIdempotent(obligation.state.owner, atas);
   const [, { ata: debtTokenAta }] = atasAndIxs;
 
+  const scopeRefreshIxn = await getScopeRefreshIx(market, collReserve, debtReserve, obligation, scopeRefreshConfig);
+
   // 2. Flash borrow & repay the debt to repay amount needed
   const { flashBorrowIxn, flashRepayIxn } = getFlashLoanInstructions({
-    borrowIxnIndex: budgetIxns.length + atasAndIxs.length,
+    borrowIxnIndex: budgetIxns.length + atasAndIxs.length + (scopeRefreshIxn.length > 0 ? 1 : 0),
     walletPublicKey: obligation.state.owner,
     lendingMarketAuthority: market.getLendingMarketAuthority(),
     lendingMarketAddress: market.getAddress(),
@@ -317,54 +306,32 @@ async function buildRepayWithCollateralIxs(
 
   const requestElevationGroup = !isClosingPosition && obligation.state.elevationGroup !== 0;
 
-  const maxWithdrawLtvCheck = getMaxWithdrawLtvCheck(obligation);
-
   // 3. Repay using the flash borrowed funds & withdraw collateral to swap and pay the flash loan
-  let repayAndWithdrawAction;
-  if (maxWithdrawLtvCheck === MaxWithdrawLtvCheck.MAX_LTV) {
-    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
-      market,
-      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-      debtReserve.getLiquidityMint(),
-      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-      collReserve.getLiquidityMint(),
-      obligation.state.owner,
-      currentSlot,
-      obligation,
-      useV2Ixs,
-      0,
-      false,
-      requestElevationGroup,
-      undefined,
-      undefined,
-      referrer,
-      scopeRefresh
-    );
-  } else {
-    repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawV2Txns(
-      market,
-      isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
-      debtReserve.getLiquidityMint(),
-      isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
-      collReserve.getLiquidityMint(),
-      obligation.state.owner,
-      currentSlot,
-      obligation,
-      0,
-      false,
-      requestElevationGroup,
-      undefined,
-      undefined,
-      referrer,
-      scopeRefresh
-    );
-  }
+  const repayAndWithdrawAction = await KaminoAction.buildRepayAndWithdrawTxns(
+    market,
+    isClosingPosition ? U64_MAX : debtRepayAmountLamports.toString(),
+    debtReserve.getLiquidityMint(),
+    isClosingPosition ? U64_MAX : collWithdrawLamports.toString(),
+    collReserve.getLiquidityMint(),
+    obligation.state.owner,
+    currentSlot,
+    obligation,
+    useV2Ixs,
+    undefined,
+    0,
+    false,
+    requestElevationGroup,
+    undefined,
+    undefined,
+    referrer
+  );
 
   // 4. Swap collateral to debt to repay flash loan
   const { preActionIxs, swapIxs } = swapQuoteIxs;
   const swapInstructions = removeBudgetAndAtaIxns(swapIxs, []);
 
   return [
+    ...scopeRefreshIxn,
     ...budgetIxns,
     ...atasAndIxs.map((x) => x.createAtaIx),
     flashBorrowIxn,
@@ -374,9 +341,3 @@ async function buildRepayWithCollateralIxs(
     flashRepayIxn,
   ];
 }
-
-export const getMaxWithdrawLtvCheck = (obligation: KaminoObligation) => {
-  return obligation.refreshedStats.userTotalBorrowBorrowFactorAdjusted.gte(obligation.refreshedStats.borrowLimit)
-    ? MaxWithdrawLtvCheck.LIQUIDATION_THRESHOLD
-    : MaxWithdrawLtvCheck.MAX_LTV;
-};

package/src/lending_operations/swap_collateral_operations.ts

@@ -6,14 +6,14 @@ import {
   KaminoObligation,
   KaminoReserve,
 } from '../classes';
-import { getFlashLoanInstructions, SwapIxsProvider, SwapQuoteProvider } from '../leverage';
+import { getFlashLoanInstructions, getScopeRefreshIx, SwapIxsProvider, SwapQuoteProvider } from '../leverage';
 import {
   createAtasIdempotent,
   DEFAULT_MAX_COMPUTE_UNITS,
   getAssociatedTokenAddress,
   getComputeBudgetAndPriorityFeeIxns,
   PublicKeySet,
-  ScopeRefresh,
+  ScopePriceRefreshConfig,
   U64_MAX,
   uniqueAccounts,
 } from '../utils';
@@ -61,7 +61,7 @@ export interface SwapCollIxnsInputs<QuoteResponse> {
   referrer: PublicKey;
   currentSlot: number;
   budgetAndPriorityFeeIxns?: TransactionInstruction[];
-  scopeRefresh?: ScopeRefresh;
+  scopeRefreshConfig?: ScopePriceRefreshConfig;
   useV2Ixs: boolean;
   quoter: SwapQuoteProvider<QuoteResponse>;
   swapper: SwapIxsProvider<QuoteResponse>;
@@ -205,7 +205,7 @@ type SwapCollContext<QuoteResponse> = {
   referrer: PublicKey;
   currentSlot: number;
   useV2Ixs: boolean;
-  scopeRefresh: ScopeRefresh | undefined;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
   logger: (msg: string, ...extra: any[]) => void;
 };
 
@@ -235,7 +235,7 @@ function extractArgsAndContext<QuoteResponse>(
       quoter: inputs.quoter,
       swapper: inputs.swapper,
       referrer: inputs.referrer,
-      scopeRefresh: inputs.scopeRefresh,
+      scopeRefreshConfig: inputs.scopeRefreshConfig,
       currentSlot: inputs.currentSlot,
       useV2Ixs: inputs.useV2Ixs,
     },
@@ -264,6 +264,18 @@ async function getKlendIxns(
   const { ataCreationIxns, targetCollAta } = getAtaCreationIxns(context);
   const setupIxns = [...context.budgetAndPriorityFeeIxns, ...ataCreationIxns];
 
+  const scopeRefreshIxn = await getScopeRefreshIx(
+    context.market,
+    context.sourceCollReserve,
+    context.targetCollReserve,
+    context.obligation,
+    context.scopeRefreshConfig
+  );
+
+  if (scopeRefreshIxn) {
+    setupIxns.unshift(...scopeRefreshIxn);
+  }
+
   const targetCollFlashBorrowedAmount = calculateTargetCollFlashBorrowedAmount(targetCollSwapOutAmount, context);
   const { targetCollFlashBorrowIxn, targetCollFlashRepayIxn } = getTargetCollFlashLoanIxns(
     targetCollFlashBorrowedAmount,
@@ -380,6 +392,7 @@ async function getDepositTargetCollIxns(
     context.obligation.state.owner,
     context.obligation,
     context.useV2Ixs,
+    undefined, // we create the scope refresh ixn outside of KaminoAction
     0, // no extra compute budget
     false, // we do not need ATA ixns here (we construct and close them ourselves)
     removesElevationGroup, // we may need to (temporarily) remove the elevation group; the same or a different one will be set on withdraw, if requested
@@ -387,7 +400,6 @@ async function getDepositTargetCollIxns(
     false, // we do not need to create a lookup table, dealing with an existing obligation
     context.referrer,
     context.currentSlot,
-    context.scopeRefresh,
     removesElevationGroup ? 0 : undefined // only applicable when removing the group
   );
   return {
@@ -430,6 +442,7 @@ async function getWithdrawSourceCollIxns(
     context.obligation.state.owner,
     context.obligation,
     context.useV2Ixs,
+    undefined, // we create the scope refresh ixn outside of KaminoAction
     0, // no extra compute budget
     false, // we do not need ATA ixns here (we construct and close them ourselves)
     requestedElevationGroup !== undefined, // the `elevationGroupIdToRequestAfterWithdraw()` has already decided on this
@@ -437,7 +450,6 @@ async function getWithdrawSourceCollIxns(
     false, // we do not need to create a lookup table, dealing with an existing obligation
     context.referrer,
     context.currentSlot,
-    undefined, // we have refreshed scope already, during depositing
     requestedElevationGroup,
     context.obligation.deposits.has(context.targetCollReserve.address) // if our obligation already had the target coll...
       ? undefined // ... then we need no customizations here, but otherwise...