@kamino-finance/klend-sdk 6.0.5-beta.5 → 6.0.5-beta.8

package/src/classes/action.ts

@@ -75,7 +75,7 @@ import { KaminoReserve } from './reserve';
 import { ReserveFarmKind } from '../idl_codegen/types';
 import { farmsId } from '@kamino-finance/farms-sdk';
 import { Reserve } from '../idl_codegen/accounts';
-import { VanillaObligation } from '../utils/ObligationType';
+import { VanillaObligation } from '../utils';
 import { PROGRAM_ID } from '../lib';
 import { Scope } from '@kamino-finance/scope-sdk';
 import { ObligationOrderAtIndex } from './obligationOrder';
@@ -430,12 +430,12 @@ export class KaminoAction {
     return axn;
   }
 
-  async addScopeRefreshIxs(scope: Scope, tokens: number[], feed: string = 'hubble') {
+  async addScopeRefreshIxs(scope: Scope, tokens: number[], scopeConfig: PublicKey) {
     this.setupIxsLabels.unshift(`refreshScopePrices`);
     this.setupIxs.unshift(
       await scope.refreshPriceListIx(
         {
-          feed: feed,
+          config: scopeConfig,
         },
         tokens
       )
@@ -732,10 +732,16 @@ export class KaminoAction {
       ...(axn.outflowReserve ? [axn.outflowReserve.address] : []),
       ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
     ]).toArray();
-    const tokenIds = getTokenIdsForScopeRefresh(axn.kaminoMarket, allReserves);
 
-    if (tokenIds.length > 0 && scopeRefreshConfig) {
-      await axn.addScopeRefreshIxs(scopeRefreshConfig.scope, tokenIds, scopeRefreshConfig.scopeFeed);
+    const scopeTokensMap = getTokenIdsForScopeRefresh(axn.kaminoMarket, allReserves);
+
+    if (scopeTokensMap.size > 0 && scopeRefreshConfig) {
+      for (const [configPubkey, config] of scopeRefreshConfig.scopeConfigurations) {
+        const tokenIds = scopeTokensMap.get(config.oraclePrices);
+        if (tokenIds && tokenIds.length > 0) {
+          await axn.addScopeRefreshIxs(scopeRefreshConfig.scope, tokenIds, configPubkey);
+        }
+      }
     }
     return axn;
   }
@@ -922,10 +928,15 @@ export class KaminoAction {
       ...(axn.outflowReserve ? [axn.outflowReserve.address] : []),
       ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
     ]).toArray();
-    const tokenIds = getTokenIdsForScopeRefresh(axn.kaminoMarket, allReserves);
+    const scopeTokensMap = getTokenIdsForScopeRefresh(axn.kaminoMarket, allReserves);
 
-    if (tokenIds.length > 0 && scopeRefreshConfig) {
-      await axn.addScopeRefreshIxs(scopeRefreshConfig.scope, tokenIds, scopeRefreshConfig.scopeFeed);
+    if (scopeTokensMap.size > 0 && scopeRefreshConfig) {
+      for (const [configPubkey, config] of scopeRefreshConfig.scopeConfigurations) {
+        const tokenIds = scopeTokensMap.get(config.oraclePrices);
+        if (tokenIds && tokenIds.length > 0) {
+          await axn.addScopeRefreshIxs(scopeRefreshConfig.scope, tokenIds, configPubkey);
+        }
+      }
     }
     return axn;
   }
@@ -2748,10 +2759,15 @@ export class KaminoAction {
       ...(this.outflowReserve ? [this.outflowReserve.address] : []),
       ...(this.preLoadedDepositReservesSameTx ? this.preLoadedDepositReservesSameTx : []),
     ]).toArray();
-    const tokenIds = getTokenIdsForScopeRefresh(this.kaminoMarket, allReserves);
+    const scopeTokensMap = getTokenIdsForScopeRefresh(this.kaminoMarket, allReserves);
 
-    if (tokenIds.length > 0 && scopeRefreshConfig) {
-      await this.addScopeRefreshIxs(scopeRefreshConfig.scope, tokenIds, scopeRefreshConfig.scopeFeed);
+    if (scopeTokensMap.size > 0 && scopeRefreshConfig) {
+      for (const [configPubkey, config] of scopeRefreshConfig.scopeConfigurations) {
+        const tokenIds = scopeTokensMap.get(config.oraclePrices);
+        if (tokenIds && tokenIds.length > 0) {
+          await this.addScopeRefreshIxs(scopeRefreshConfig.scope, tokenIds, configPubkey);
+        }
+      }
     }
   }
 

package/src/classes/manager.ts

@@ -52,6 +52,7 @@ import {
   Reserve,
   ReserveWithAddress,
   ScopeOracleConfig,
+  setOrAppend,
   updateEntireReserveConfigIx,
   updateLendingMarket,
   UpdateLendingMarketAccounts,
@@ -60,7 +61,7 @@ import {
   UpdateLendingMarketOwnerAccounts,
 } from '../lib';
 import { PROGRAM_ID } from '../idl_codegen/programId';
-import { Scope, TokenMetadatas, U16_MAX } from '@kamino-finance/scope-sdk';
+import { OracleMappings, Scope, TokenMetadatas, U16_MAX } from '@kamino-finance/scope-sdk';
 import BN from 'bn.js';
 import { ReserveConfig, UpdateLendingMarketMode, UpdateLendingMarketModeKind } from '../idl_codegen/types';
 import Decimal from 'decimal.js';
@@ -69,7 +70,7 @@ import { VaultState } from '../idl_codegen_kamino_vault/accounts';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Data } from '@kamino-finance/kliquidity-sdk';
 import bs58 from 'bs58';
-import { getProgramAccounts } from '../utils/rpc';
+import { getProgramAccounts } from '../utils';
 import { VaultConfigField, VaultConfigFieldKind } from '../idl_codegen_kamino_vault/types';
 import {
   AcceptVaultOwnershipIxs,
@@ -317,6 +318,7 @@ export class KaminoManager {
    * This function enables the update of the scope oracle configuration. In order to get a list of scope prices, getScopeOracleConfigs can be used
    * @param market - lending market which owns the reserve
    * @param reserve - reserve which to be updated
+   * @param oraclePrices - scope OraclePrices account pubkey
    * @param scopeOracleConfig - new scope oracle config
    * @param scopeTwapConfig - new scope twap config
    * @param maxAgeBufferSeconds - buffer to be added to onchain max_age - if oracle price is older than that, txns interacting with the reserve will fail
@@ -325,6 +327,7 @@ export class KaminoManager {
   async updateReserveScopeOracleConfigurationIxs(
     market: MarketWithAddress,
     reserve: ReserveWithAddress,
+    oraclePrices: PublicKey,
     scopeOracleConfig: ScopeOracleConfig,
     scopeTwapConfig?: ScopeOracleConfig,
     maxAgeBufferSeconds: number = 20
@@ -341,7 +344,7 @@ export class KaminoManager {
     }
 
     const { scopeConfiguration } = getReserveOracleConfigs({
-      scopePriceConfigAddress: scopeOracleConfig.scopePriceConfigAddress,
+      scopePriceConfigAddress: oraclePrices,
       scopeChain: [scopeOracleConfig.oracleId],
       scopeTwapChain: [scopeTwapId],
     });
@@ -523,7 +526,6 @@ export class KaminoManager {
    * This method withdraws all the pending fees from the vault to the owner's token ATA
    * @param vault - vault for which the admin withdraws the pending fees
    * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
-   * @param [vaultReservesMap] - a 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
    * @returns - list of instructions to withdraw all pending fees, including the ATA creation instructions if needed
    */
   async withdrawPendingFeesIxs(vault: KaminoVault, slot: number): Promise<TransactionInstruction[]> {
@@ -533,7 +535,7 @@ export class KaminoManager {
   /**
    * This method inserts the missing keys from the provided keys into an existent lookup table
    * @param payer - payer wallet pubkey
-   * @param lookupTable - lookup table to insert the keys into
+   * @param lut
    * @param keys - keys to insert into the lookup table
    * @param [accountsInLUT] - the existent accounts in the lookup table. Optional. If provided, the function will not fetch the accounts in the lookup table
    * @returns - an array of instructions to insert the missing keys into the lookup table
@@ -551,7 +553,6 @@ export class KaminoManager {
    * Sync a vault for lookup table; create and set the LUT for the vault if needed and fill it with all the needed accounts
    * @param vault the vault to sync and set the LUT for if needed
    * @param vaultReserves optional; the state of the reserves in the vault allocation
-   * @param [vaultReservesMap] - optional parameter; a 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
    * @returns a struct that contains a list of ix to create the LUT and assign it to the vault if needed + a list of ixs to insert all the accounts in the LUT
    */
   async syncVaultLUTIxs(
@@ -632,8 +633,8 @@ export class KaminoManager {
 
   /**
    * This method returns the vault name
-   * @param vault - vault to retrieve the onchain name for
    * @returns - the vault name as string
+   * @param vaultState
    */
   getDecodedVaultName(vaultState: VaultState): string {
     return this._vaultClient.decodeVaultName(vaultState.name);
@@ -691,7 +692,7 @@ export class KaminoManager {
       }
     }
 
-    const combinedMarkets = lendingMarketPairs.map(([pubkey, market]) => {
+    return lendingMarketPairs.map(([pubkey, market]) => {
       const reserves = marketToReserve.get(pubkey);
       const reservesByAddress = new PubkeyHashMap<PublicKey, KaminoReserve>();
       if (!reserves) {
@@ -720,8 +721,6 @@ export class KaminoManager {
 
       return KaminoMarket.loadWithReserves(this.getConnection(), market, reservesByAddress, pubkey, slotDuration);
     });
-
-    return combinedMarkets;
   }
 
   /**
@@ -859,7 +858,7 @@ export class KaminoManager {
    * @param vault - the kamino vault to get available liquidity to withdraw for
    * @param price - the price of the token in the vault (e.g. USDC)
    * @param [slot] - the slot for which to calculate the holdings. 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 vaultReserves
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
    * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
    */
@@ -878,7 +877,7 @@ export class KaminoManager {
    * @param vault - the kamino vault to get available liquidity to withdraw for
    * @param price - the price of the token in the vault (e.g. USDC)
    * @param [slot] - the slot for which to retrieve the vault overview 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 vaultReserves
    * @param [kaminoMarkets] - a list of all kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
    * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD
@@ -938,7 +937,7 @@ export class KaminoManager {
    * This will return the APY of the vault under the assumption that all the available tokens in the vault are all the time invested in the reserves as ratio; for percentage it needs multiplication by 100
    * @param vault - the kamino vault to get APY for
    * @param slot - 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 vaultReserves
    * @returns a struct containing estimated gross APY and net APY (gross - vault fees) for the vault
    */
   async getVaultTheoreticalAPY(
@@ -953,7 +952,7 @@ export class KaminoManager {
    * This will return the APY of the vault based on the current invested amounts; for percentage it needs multiplication by 100
    * @param vault - the kamino vault to get APY for
    * @param slot - 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 vaultReserves
    * @returns a struct containing estimated gross APY and net APY (gross - vault fees) for the vault
    */
   async getVaultActualAPY(
@@ -976,8 +975,10 @@ export class KaminoManager {
   /**
    * Simulate the current holdings of the vault and the earned interest
    * @param vaultState the kamino vault state to get simulated holdings and earnings for
-   * @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 [currentSlot] - the current slot. Optional. If not provided it will fetch the current slot
+   * @param vaultReserves
+   * @param vaultReserves
+   * @param slot
+   * @param slot
    * @param [previousTotalAUM] - the previous AUM of the vault to compute the earned interest relative to this value. Optional. If not provided the function will estimate the total AUM at the slot of the last state update on chain
    * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
    * @returns a struct of simulated vault holdings and earned interest
@@ -1056,8 +1057,8 @@ export class KaminoManager {
 
   /**
    * This will load the onchain state for all the reserves that the vault has allocations for
-   * @param vaultState - the vault state to load reserves for
    * @returns a hashmap from each reserve pubkey to the reserve state
+   * @param vault
    */
   getVaultReserves(vault: VaultState): PublicKey[] {
     return this._vaultClient.getVaultReserves(vault);
@@ -1067,6 +1068,15 @@ export class KaminoManager {
    * This will retrieve all the tokens that can be use as collateral by the users who borrow the token in the vault alongside details about the min and max loan to value ratio
    * @param vaultState - the vault state to load reserves for
    *
+   * @param slot
+   * @param vaultReservesMap
+   * @param kaminoMarkets
+   * @param slot
+   * @param vaultReservesMap
+   * @param kaminoMarkets
+   * @param slot
+   * @param vaultReservesMap
+   * @param kaminoMarkets
    * @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(
@@ -1080,6 +1090,7 @@ export class KaminoManager {
 
   /**
    * This will trigger invest by balancing, based on weights, the reserve allocations of the vault. It can either withdraw or deposit into reserves to balance them. This is a function that should be cranked
+   * @param payer
    * @param kaminoVault - vault to invest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
@@ -1090,8 +1101,8 @@ export class KaminoManager {
   /**
    * This will trigger invest by balancing, based on weights, the reserve allocation of the vault. It can either withdraw or deposit into the given reserve to balance it
    * @param payer wallet pubkey
-   * @param vault - vault to invest from
-   * @param reserve - reserve to invest into or disinvest from
+   * @param kaminoVault
+   * @param reserveWithAddress
    * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
@@ -1124,7 +1135,7 @@ export class KaminoManager {
 
   /**
    * This will return the amount of token invested from the vault into the given reserve
-   * @param vault - the kamino vault to get invested amount in reserve for
+   * @param vaultState
    * @param slot - current slot
    * @param reserve - the reserve state to get vault invested amount in
    * @returns vault amount supplied in reserve in decimal
@@ -1135,43 +1146,63 @@ export class KaminoManager {
 
   /**
    * 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 market - kamino market
    * @param cluster - cluster to fetch from, this should be left unchanged unless working on devnet or locally
-   * @returns - an array of scope oracle configs
+   * @returns - a map with keys as scope OraclePrices pubkeys and values of scope oracle configs
    */
   async getScopeOracleConfigs(
-    feed: string = 'hubble',
+    market: KaminoMarket,
     cluster: ENV = 'mainnet-beta'
-  ): Promise<Array<ScopeOracleConfig>> {
-    const scopeOracleConfigs: Array<ScopeOracleConfig> = [];
+  ): Promise<PubkeyHashMap<PublicKey, ScopeOracleConfig[]>> {
+    const scopeOracleConfigs = new PubkeyHashMap<PublicKey, ScopeOracleConfig[]>();
 
     const scope = new Scope(cluster, this._connection);
-    const oracleMappings = await scope.getOracleMappings({ feed: feed });
-    const [, feedConfig] = await scope.getFeedConfiguration({ feed: feed });
-    const tokenMetadatas = await TokenMetadatas.fetch(this._connection, feedConfig.tokensMetadata);
-    const decoder = new TextDecoder('utf-8');
-
-    console.log('feedConfig.tokensMetadata', feedConfig.tokensMetadata);
 
-    if (tokenMetadatas === null) {
-      throw new Error('TokenMetadatas not found');
+    const configs = (await scope.getAllConfigurations()).filter(([_, config]) =>
+      market.scopeFeeds.contains(config.oraclePrices)
+    );
+    if (!configs || configs.length === 0) {
+      return scopeOracleConfigs;
     }
 
-    for (let index = 0; index < oracleMappings.priceInfoAccounts.length; index++) {
-      if (!oracleMappings.priceInfoAccounts[index].equals(PublicKey.default)) {
-        const name = decoder.decode(Uint8Array.from(tokenMetadatas.metadatasArray[index].name)).replace(/\0/g, '');
-        const oracleType = parseOracleType(oracleMappings.priceTypes[index]);
-
-        scopeOracleConfigs.push({
-          scopePriceConfigAddress: feedConfig.oraclePrices,
-          name: name,
-          oracleType: oracleType,
-          oracleId: index,
-          oracleAccount: oracleMappings.priceInfoAccounts[index],
-          twapEnabled: oracleMappings.twapEnabled[index] === 1,
-          twapSourceId: oracleMappings.twapSource[index],
-          max_age: tokenMetadatas.metadatasArray[index].maxAgePriceSlots.toNumber(),
-        });
+    const configOracleMappings = await OracleMappings.fetchMultiple(
+      this._connection,
+      configs.map(([_, config]) => config.oracleMappings),
+      scope.config.programId
+    );
+
+    const configTokenMetadatas = await TokenMetadatas.fetchMultiple(
+      this._connection,
+      configs.map(([_, config]) => config.tokensMetadata),
+      scope.config.programId
+    );
+    const decoder = new TextDecoder('utf-8');
+
+    for (let i = 0; i < configs.length; i++) {
+      const [configPubkey, config] = configs[i];
+      const oracleMappings = configOracleMappings[i];
+      const tokenMetadatas = configTokenMetadatas[i];
+      if (!oracleMappings) {
+        throw new Error(`OracleMappings account not found for config ${configPubkey}`);
+      }
+      if (!tokenMetadatas) {
+        throw new Error(`TokenMetadatas account not found for config ${configPubkey}`);
+      }
+
+      for (let j = 0; j < oracleMappings.priceInfoAccounts.length; j++) {
+        if (!oracleMappings.priceInfoAccounts[j].equals(PublicKey.default)) {
+          const name = decoder.decode(Uint8Array.from(tokenMetadatas.metadatasArray[j].name)).replace(/\0/g, '');
+          const oracleType = parseOracleType(oracleMappings.priceTypes[j]);
+          setOrAppend(scopeOracleConfigs, config.oraclePrices, {
+            name: name,
+            oracleType: oracleType,
+            oracleId: j,
+            oracleAccount: oracleMappings.priceInfoAccounts[j],
+            twapEnabled: oracleMappings.twapEnabled[j] === 1,
+            twapSourceId: oracleMappings.twapSource[j],
+            max_age: tokenMetadatas.metadatasArray[j].maxAgePriceSlots.toNumber(),
+          });
+        }
       }
     }
 
@@ -1329,7 +1360,5 @@ function updateMarketConfigIx(
     value: [...value, ...Array(72 - value.length).fill(0)],
   };
 
-  const ix = updateLendingMarket(args, accounts, programId);
-
-  return ix;
+  return updateLendingMarket(args, accounts, programId);
 }

package/src/classes/market.ts

@@ -22,6 +22,7 @@ import {
   CandidatePrice,
   PublicKeySet,
   DEPOSITS_LIMIT,
+  setOrAppend,
 } from '../utils';
 import base58 from 'bs58';
 import { BN } from '@coral-xyz/anchor';
@@ -62,7 +63,7 @@ export class KaminoMarket {
 
   private readonly recentSlotDurationMs: number;
 
-  private readonly scopeFeeds: PublicKeySet<PublicKey>;
+  readonly scopeFeeds: PublicKeySet<PublicKey>;
 
   private constructor(
     connection: Connection,
@@ -93,7 +94,6 @@ export class KaminoMarket {
    * @param recentSlotDurationMs
    * @param programId
    * @param withReserves
-   * @param setupLocalTest
    * @param withReserves
    */
   static async load(
@@ -1544,16 +1544,7 @@ export async function getSingleReserve(
   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> {
@@ -1566,8 +1557,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);
@@ -1575,17 +1569,18 @@ 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++;
       }
     }

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());