@kamino-finance/klend-sdk 6.0.5 → 7.0.0

package/src/@codegen/kvault/accounts/VaultState.ts

@@ -28,7 +28,7 @@ export interface VaultStateFields {
   tokenAvailable: BN
   sharesIssued: BN
   availableCrankFunds: BN
-  padding0: BN
+  unallocatedWeight: BN
   performanceFeeBps: BN
   managementFeeBps: BN
   lastFeeChargeTimestamp: BN
@@ -49,7 +49,7 @@ export interface VaultStateFields {
   vaultLookupTable: Address
   vaultFarm: Address
   creationTimestamp: BN
-  padding2: BN
+  unallocatedTokensCap: BN
   allocationAdmin: Address
   padding3: Array<BN>
 }
@@ -67,7 +67,7 @@ export interface VaultStateJSON {
   tokenAvailable: string
   sharesIssued: string
   availableCrankFunds: string
-  padding0: string
+  unallocatedWeight: string
   performanceFeeBps: string
   managementFeeBps: string
   lastFeeChargeTimestamp: string
@@ -88,7 +88,7 @@ export interface VaultStateJSON {
   vaultLookupTable: string
   vaultFarm: string
   creationTimestamp: string
-  padding2: string
+  unallocatedTokensCap: string
   allocationAdmin: string
   padding3: Array<string>
 }
@@ -106,7 +106,7 @@ export class VaultState {
   readonly tokenAvailable: BN
   readonly sharesIssued: BN
   readonly availableCrankFunds: BN
-  readonly padding0: BN
+  readonly unallocatedWeight: BN
   readonly performanceFeeBps: BN
   readonly managementFeeBps: BN
   readonly lastFeeChargeTimestamp: BN
@@ -127,7 +127,7 @@ export class VaultState {
   readonly vaultLookupTable: Address
   readonly vaultFarm: Address
   readonly creationTimestamp: BN
-  readonly padding2: BN
+  readonly unallocatedTokensCap: BN
   readonly allocationAdmin: Address
   readonly padding3: Array<BN>
 
@@ -148,7 +148,7 @@ export class VaultState {
     borsh.u64("tokenAvailable"),
     borsh.u64("sharesIssued"),
     borsh.u64("availableCrankFunds"),
-    borsh.u64("padding0"),
+    borsh.u64("unallocatedWeight"),
     borsh.u64("performanceFeeBps"),
     borsh.u64("managementFeeBps"),
     borsh.u64("lastFeeChargeTimestamp"),
@@ -169,7 +169,7 @@ export class VaultState {
     borshAddress("vaultLookupTable"),
     borshAddress("vaultFarm"),
     borsh.u64("creationTimestamp"),
-    borsh.u64("padding2"),
+    borsh.u64("unallocatedTokensCap"),
     borshAddress("allocationAdmin"),
     borsh.array(borsh.u128(), 242, "padding3"),
   ])
@@ -187,7 +187,7 @@ export class VaultState {
     this.tokenAvailable = fields.tokenAvailable
     this.sharesIssued = fields.sharesIssued
     this.availableCrankFunds = fields.availableCrankFunds
-    this.padding0 = fields.padding0
+    this.unallocatedWeight = fields.unallocatedWeight
     this.performanceFeeBps = fields.performanceFeeBps
     this.managementFeeBps = fields.managementFeeBps
     this.lastFeeChargeTimestamp = fields.lastFeeChargeTimestamp
@@ -210,7 +210,7 @@ export class VaultState {
     this.vaultLookupTable = fields.vaultLookupTable
     this.vaultFarm = fields.vaultFarm
     this.creationTimestamp = fields.creationTimestamp
-    this.padding2 = fields.padding2
+    this.unallocatedTokensCap = fields.unallocatedTokensCap
     this.allocationAdmin = fields.allocationAdmin
     this.padding3 = fields.padding3
   }
@@ -271,7 +271,7 @@ export class VaultState {
       tokenAvailable: dec.tokenAvailable,
       sharesIssued: dec.sharesIssued,
       availableCrankFunds: dec.availableCrankFunds,
-      padding0: dec.padding0,
+      unallocatedWeight: dec.unallocatedWeight,
       performanceFeeBps: dec.performanceFeeBps,
       managementFeeBps: dec.managementFeeBps,
       lastFeeChargeTimestamp: dec.lastFeeChargeTimestamp,
@@ -296,7 +296,7 @@ export class VaultState {
       vaultLookupTable: dec.vaultLookupTable,
       vaultFarm: dec.vaultFarm,
       creationTimestamp: dec.creationTimestamp,
-      padding2: dec.padding2,
+      unallocatedTokensCap: dec.unallocatedTokensCap,
       allocationAdmin: dec.allocationAdmin,
       padding3: dec.padding3,
     })
@@ -316,7 +316,7 @@ export class VaultState {
       tokenAvailable: this.tokenAvailable.toString(),
       sharesIssued: this.sharesIssued.toString(),
       availableCrankFunds: this.availableCrankFunds.toString(),
-      padding0: this.padding0.toString(),
+      unallocatedWeight: this.unallocatedWeight.toString(),
       performanceFeeBps: this.performanceFeeBps.toString(),
       managementFeeBps: this.managementFeeBps.toString(),
       lastFeeChargeTimestamp: this.lastFeeChargeTimestamp.toString(),
@@ -339,7 +339,7 @@ export class VaultState {
       vaultLookupTable: this.vaultLookupTable,
       vaultFarm: this.vaultFarm,
       creationTimestamp: this.creationTimestamp.toString(),
-      padding2: this.padding2.toString(),
+      unallocatedTokensCap: this.unallocatedTokensCap.toString(),
       allocationAdmin: this.allocationAdmin,
       padding3: this.padding3.map((item) => item.toString()),
     }
@@ -359,7 +359,7 @@ export class VaultState {
       tokenAvailable: new BN(obj.tokenAvailable),
       sharesIssued: new BN(obj.sharesIssued),
       availableCrankFunds: new BN(obj.availableCrankFunds),
-      padding0: new BN(obj.padding0),
+      unallocatedWeight: new BN(obj.unallocatedWeight),
       performanceFeeBps: new BN(obj.performanceFeeBps),
       managementFeeBps: new BN(obj.managementFeeBps),
       lastFeeChargeTimestamp: new BN(obj.lastFeeChargeTimestamp),
@@ -382,7 +382,7 @@ export class VaultState {
       vaultLookupTable: address(obj.vaultLookupTable),
       vaultFarm: address(obj.vaultFarm),
       creationTimestamp: new BN(obj.creationTimestamp),
-      padding2: new BN(obj.padding2),
+      unallocatedTokensCap: new BN(obj.unallocatedTokensCap),
       allocationAdmin: address(obj.allocationAdmin),
       padding3: obj.padding3.map((item) => new BN(item)),
     })

package/src/@codegen/kvault/errors/custom.ts

@@ -47,6 +47,7 @@ export type CustomError =
   | InvestTooSoon
   | WrongAdminOrAllocationAdmin
   | ReserveHasNonZeroAllocationOrCTokens
+  | DepositAmountGreaterThanRequestedAmount
 
 export class DepositAmountsZero extends Error {
   static readonly code = 7000
@@ -579,6 +580,17 @@ export class ReserveHasNonZeroAllocationOrCTokens extends Error {
   }
 }
 
+export class DepositAmountGreaterThanRequestedAmount extends Error {
+  static readonly code = 7048
+  readonly code = 7048
+  readonly name = "DepositAmountGreaterThanRequestedAmount"
+  readonly msg = "Deposit amount is greater than requested amount"
+
+  constructor(readonly logs?: string[]) {
+    super("7048: Deposit amount is greater than requested amount")
+  }
+}
+
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
     case 7000:
@@ -677,6 +689,8 @@ export function fromCode(code: number, logs?: string[]): CustomError | null {
       return new WrongAdminOrAllocationAdmin(logs)
     case 7047:
       return new ReserveHasNonZeroAllocationOrCTokens(logs)
+    case 7048:
+      return new DepositAmountGreaterThanRequestedAmount(logs)
   }
 
   return null

package/src/@codegen/kvault/types/VaultConfigField.ts

@@ -280,6 +280,52 @@ export class AllocationAdmin {
   }
 }
 
+export interface UnallocatedWeightJSON {
+  kind: "UnallocatedWeight"
+}
+
+export class UnallocatedWeight {
+  static readonly discriminator = 12
+  static readonly kind = "UnallocatedWeight"
+  readonly discriminator = 12
+  readonly kind = "UnallocatedWeight"
+
+  toJSON(): UnallocatedWeightJSON {
+    return {
+      kind: "UnallocatedWeight",
+    }
+  }
+
+  toEncodable() {
+    return {
+      UnallocatedWeight: {},
+    }
+  }
+}
+
+export interface UnallocatedTokensCapJSON {
+  kind: "UnallocatedTokensCap"
+}
+
+export class UnallocatedTokensCap {
+  static readonly discriminator = 13
+  static readonly kind = "UnallocatedTokensCap"
+  readonly discriminator = 13
+  readonly kind = "UnallocatedTokensCap"
+
+  toJSON(): UnallocatedTokensCapJSON {
+    return {
+      kind: "UnallocatedTokensCap",
+    }
+  }
+
+  toEncodable() {
+    return {
+      UnallocatedTokensCap: {},
+    }
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function fromDecoded(obj: any): types.VaultConfigFieldKind {
   if (typeof obj !== "object") {
@@ -322,6 +368,12 @@ export function fromDecoded(obj: any): types.VaultConfigFieldKind {
   if ("AllocationAdmin" in obj) {
     return new AllocationAdmin()
   }
+  if ("UnallocatedWeight" in obj) {
+    return new UnallocatedWeight()
+  }
+  if ("UnallocatedTokensCap" in obj) {
+    return new UnallocatedTokensCap()
+  }
 
   throw new Error("Invalid enum object")
 }
@@ -366,6 +418,12 @@ export function fromJSON(
     case "AllocationAdmin": {
       return new AllocationAdmin()
     }
+    case "UnallocatedWeight": {
+      return new UnallocatedWeight()
+    }
+    case "UnallocatedTokensCap": {
+      return new UnallocatedTokensCap()
+    }
   }
 }
 
@@ -383,6 +441,8 @@ export function layout(property?: string) {
     borsh.struct([], "LookupTable"),
     borsh.struct([], "Farm"),
     borsh.struct([], "AllocationAdmin"),
+    borsh.struct([], "UnallocatedWeight"),
+    borsh.struct([], "UnallocatedTokensCap"),
   ])
   if (property !== undefined) {
     return ret.replicate(property)

package/src/@codegen/kvault/types/index.ts

@@ -64,6 +64,8 @@ export type VaultConfigFieldKind =
   | VaultConfigField.LookupTable
   | VaultConfigField.Farm
   | VaultConfigField.AllocationAdmin
+  | VaultConfigField.UnallocatedWeight
+  | VaultConfigField.UnallocatedTokensCap
 export type VaultConfigFieldJSON =
   | VaultConfigField.PerformanceFeeBpsJSON
   | VaultConfigField.ManagementFeeBpsJSON
@@ -77,6 +79,8 @@ export type VaultConfigFieldJSON =
   | VaultConfigField.LookupTableJSON
   | VaultConfigField.FarmJSON
   | VaultConfigField.AllocationAdminJSON
+  | VaultConfigField.UnallocatedWeightJSON
+  | VaultConfigField.UnallocatedTokensCapJSON
 
 export { VaultAllocation } from "./VaultAllocation"
 export type {

package/src/classes/action.ts

@@ -428,12 +428,12 @@ export class KaminoAction {
     return axn;
   }
 
-  async addScopeRefreshIxs(scope: Scope, tokens: number[], feed: string = 'hubble') {
+  async addScopeRefreshIxs(scope: Scope, tokens: number[], scopeConfig: Address) {
     this.setupIxsLabels.unshift(`refreshScopePrices`);
     this.setupIxs.unshift(
       await scope.refreshPriceListIx(
         {
-          feed: feed,
+          config: scopeConfig,
         },
         tokens
       )
@@ -732,10 +732,15 @@ export class KaminoAction {
         ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
       ]),
     ];
-    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;
   }
@@ -924,10 +929,15 @@ export class KaminoAction {
         ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
       ]),
     ];
-    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;
   }
@@ -2623,10 +2633,15 @@ export class KaminoAction {
         ...(this.preLoadedDepositReservesSameTx ? this.preLoadedDepositReservesSameTx : []),
       ]),
     ];
-    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

@@ -57,6 +57,7 @@ import {
   Reserve,
   ReserveWithAddress,
   ScopeOracleConfig,
+  setOrAppend,
   updateEntireReserveConfigIx,
   updateLendingMarket,
   UpdateLendingMarketAccounts,
@@ -77,12 +78,14 @@ import {
   AcceptVaultOwnershipIxs,
   APYs,
   DepositIxs,
+  DisinvestAllReservesIxs,
   InitVaultIxs,
   ReserveAllocationOverview,
   SyncVaultLUTIxs,
   UpdateReserveAllocationIxs,
   UpdateVaultConfigIxs,
   UserSharesForVault,
+  VaultComputedAllocation,
   WithdrawAndBlockReserveIxs,
   WithdrawIxs,
 } from './vault_types';
@@ -96,6 +99,7 @@ import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import type { AccountInfoBase, AccountInfoWithJsonData, AccountInfoWithPubkey } from '@solana/rpc-types';
 import { arrayElementConfigItems, ConfigUpdater } from './configItems';
 import { getFarmIncentives, ReserveIncentives } from '@kamino-finance/farms-sdk/dist/utils/apy';
+import { OracleMappings } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts';
 
 const base58Decoder = getBase58Decoder();
 
@@ -267,6 +271,28 @@ export class KaminoManager {
     return this._vaultClient.updateReserveAllocationIxs(vault, reserveAllocationConfig, signer);
   }
 
+  /**
+   * This method updates the unallocated weight and cap of a vault (both are optional, if not provided the current values will be used)
+   * @param vault - the vault to update the unallocated weight and cap for
+   * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
+   * @param [unallocatedWeight] - the new unallocated weight to set. If not provided, the current unallocated weight will be used
+   * @param [unallocatedCap] - the new unallocated cap to set. If not provided, the current unallocated cap will be used
+   * @returns - a list of instructions to update the unallocated weight and cap
+   */
+  async updateVaultUnallocatedWeightAndCapIxs(
+    vault: KaminoVault,
+    vaultAdminAuthority?: TransactionSigner,
+    unallocatedWeight?: BN,
+    unallocatedCap?: BN
+  ): Promise<IInstruction[]> {
+    return this._vaultClient.updateVaultUnallocatedWeightAndCapIxs(
+      vault,
+      vaultAdminAuthority,
+      unallocatedWeight,
+      unallocatedCap
+    );
+  }
+
   /**
    * This method removes a reserve from the vault allocation strategy if already part of the allocation strategy
    * @param vault - vault to remove the reserve from
@@ -376,6 +402,21 @@ export class KaminoManager {
     return this._vaultClient.withdrawEverythingFromAllReservesAndBlockInvest(vault, vaultReservesMap, payer);
   }
 
+  /**
+   * This method disinvests all the funds from all the reserves and set their weight to 0; for vaults that are managed by external bot/crank, the bot can change the weight and invest in the reserves again
+   * @param vault - the vault to disinvest the invested funds from
+   * @param [vaultReservesMap] - optional parameter to pass a map of the vault reserves. If not provided, the reserves will be loaded from the vault
+   * @param [payer] - optional parameter to pass a different payer for the transaction. If not provided, the admin of the vault will be used; this is the payer for the invest ixs and it should have an ATA and some lamports (2x no_of_reserves) of the token vault
+   * @returns - a struct with an instruction to update the reserve allocations to 0 weight and a list of instructions to disinvest the funds in the reserves
+   */
+  async disinvestAllReservesIxs(
+    vault: KaminoVault,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    payer?: TransactionSigner
+  ): Promise<DisinvestAllReservesIxs> {
+    return this._vaultClient.disinvestAllReservesIxs(vault, vaultReservesMap, payer);
+  }
+
   // async closeVault(vault: KaminoVault): Promise<TransactionInstruction> {
   //   return this._vaultClient.closeVaultIx(vault);
   // }
@@ -398,6 +439,7 @@ export class KaminoManager {
    * @param lendingMarketOwner - market admin
    * @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
@@ -407,6 +449,7 @@ export class KaminoManager {
     lendingMarketOwner: TransactionSigner,
     market: MarketWithAddress,
     reserve: ReserveWithAddress,
+    oraclePrices: Address,
     scopeOracleConfig: ScopeOracleConfig,
     scopeTwapConfig?: ScopeOracleConfig,
     maxAgeBufferSeconds: number = 20
@@ -423,7 +466,7 @@ export class KaminoManager {
     }
 
     const { scopeConfiguration } = getReserveOracleConfigs({
-      scopePriceConfigAddress: scopeOracleConfig.scopePriceConfigAddress,
+      scopePriceConfigAddress: oraclePrices,
       scopeChain: [scopeOracleConfig.oracleId],
       scopeTwapChain: [scopeTwapId],
     });
@@ -1112,7 +1155,7 @@ export class KaminoManager {
     slot?: Slot,
     vaultReserves?: Map<Address, KaminoReserve>,
     currentSlot?: Slot
-  ): Promise<Map<Address, Decimal>> {
+  ): Promise<VaultComputedAllocation> {
     return this._vaultClient.getVaultComputedReservesAllocation(vaultState, slot, vaultReserves, currentSlot);
   }
 
@@ -1325,43 +1368,62 @@ 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<Map<Address, ScopeOracleConfig[]>> {
+    const scopeOracleConfigs = new Map<Address, ScopeOracleConfig[]>();
 
     const scope = new Scope(cluster, this._rpc);
-    const oracleMappings = await scope.getOracleMappings({ feed: feed });
-    const [, feedConfig] = await scope.getFeedConfiguration({ feed: feed });
-    const tokenMetadatas = await TokenMetadatas.fetch(this._rpc, feedConfig.tokensMetadata);
-    const decoder = new TextDecoder('utf-8');
+    const configs = (await scope.getAllConfigurations()).filter(([_, config]) =>
+      market.scopeFeeds.has(config.oraclePrices)
+    );
+    if (!configs || configs.length === 0) {
+      return scopeOracleConfigs;
+    }
+    const configOracleMappings = await OracleMappings.fetchMultiple(
+      this._rpc,
+      configs.map(([_, config]) => config.oracleMappings),
+      scope.config.programId
+    );
 
-    console.log('feedConfig.tokensMetadata', feedConfig.tokensMetadata);
+    const configTokenMetadatas = await TokenMetadatas.fetchMultiple(
+      this._rpc,
+      configs.map(([_, config]) => config.tokensMetadata),
+      scope.config.programId
+    );
 
-    if (tokenMetadatas === null) {
-      throw new Error('TokenMetadatas not found');
-    }
+    const decoder = new TextDecoder('utf-8');
 
-    for (let index = 0; index < oracleMappings.priceInfoAccounts.length; index++) {
-      if (oracleMappings.priceInfoAccounts[index] !== DEFAULT_PUBLIC_KEY) {
-        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(),
-        });
+    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] !== DEFAULT_PUBLIC_KEY) {
+          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(),
+          });
+        }
       }
     }
 

package/src/classes/market.ts

@@ -37,6 +37,7 @@ import {
   ObligationType,
   PythPrices,
   referrerTokenStatePda,
+  setOrAppend,
   userMetadataPda,
   VanillaObligation,
 } from '../utils';
@@ -88,7 +89,7 @@ export class KaminoMarket {
   private readonly recentSlotDurationMs: number;
 
   // scope feeds used by all market reserves
-  private readonly scopeFeeds: Set<Address>;
+  readonly scopeFeeds: Set<Address>;
 
   private constructor(
     rpc: Rpc<KaminoMarketRpcApi>,
@@ -1578,26 +1579,31 @@ export function getReservesActive(reserves: Map<Address, KaminoReserve>): Map<Ad
   return reservesActive;
 }
 
-export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: Address[]): number[] {
-  const tokenIds: number[] = [];
+/**
+ *
+ * @param kaminoMarket
+ * @param reserves
+ */
+export function getTokenIdsForScopeRefresh(kaminoMarket: KaminoMarket, reserves: Address[]): Map<Address, number[]> {
+  const tokenIds = new Map<Address, number[]>();
 
   for (const reserveAddress of reserves) {
     const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
     if (!reserve) {
       throw new Error(`Reserve not found for reserve ${reserveAddress}`);
     }
-
-    if (reserve.state.config.tokenInfo.scopeConfiguration.priceFeed !== DEFAULT_PUBLIC_KEY) {
+    const { scopeConfiguration } = reserve.state.config.tokenInfo;
+    if (scopeConfiguration.priceFeed !== DEFAULT_PUBLIC_KEY) {
       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++;
       }
     }