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

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) }
   );
   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) }
   );
   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) }
   );
   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) },
     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[] {

package/src/leverage/operations.ts

@@ -1685,18 +1685,17 @@ export const getScopeRefreshIx = async (
           debtReserve.address,
         ]).toArray()
       : new PublicKeySet<PublicKey>([collReserve.address, debtReserve.address]).toArray();
-  const tokenIds = getTokenIdsForScopeRefresh(market, allReserves);
 
   const scopeRefreshIxs: TransactionInstruction[] = [];
-  if (tokenIds.length > 0 && scopeRefreshConfig) {
-    scopeRefreshIxs.push(
-      await scopeRefreshConfig.scope.refreshPriceListIx(
-        {
-          feed: scopeRefreshConfig.scopeFeed,
-        },
-        tokenIds
-      )
-    );
+  const scopeTokensMap = getTokenIdsForScopeRefresh(market, allReserves);
+
+  if (scopeTokensMap.size > 0 && scopeRefreshConfig) {
+    for (const [configPubkey, config] of scopeRefreshConfig.scopeConfigurations) {
+      const tokenIds = scopeTokensMap.get(config.oraclePrices);
+      if (tokenIds && tokenIds.length > 0) {
+        scopeRefreshIxs.push(await scopeRefreshConfig.scope.refreshPriceListIx({ config: configPubkey }, tokenIds));
+      }
+    }
   }
 
   return scopeRefreshIxs;

package/src/utils/managerTypes.ts

@@ -13,7 +13,7 @@ import {
   WithdrawalCaps,
 } from '../idl_codegen/types';
 import Decimal from 'decimal.js';
-import { Fraction, ZERO_FRACTION } from '../classes/fraction';
+import { Fraction, ZERO_FRACTION } from '../classes';
 import BN from 'bn.js';
 import { numberToLamportsDecimal } from '../classes';
 import { NULL_PUBKEY } from './pubkey';
@@ -21,7 +21,6 @@ import { OracleType, U16_MAX } from '@kamino-finance/scope-sdk';
 import { LendingMarket } from '../lib';
 
 export type ScopeOracleConfig = {
-  scopePriceConfigAddress: PublicKey;
   name: string;
   oracleType: string;
   oracleId: number;

package/src/utils/oracle.ts

@@ -1,6 +1,6 @@
 import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
 import Decimal from 'decimal.js';
-import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
+import { Configuration, OraclePrices, Scope } from '@kamino-finance/scope-sdk';
 import { isNotNullPubkey, PubkeyHashMap, PublicKeySet } from './pubkey';
 import { parseTokenSymbol } from '../classes';
 import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
@@ -37,7 +37,7 @@ export type CandidatePrice = {
 
 export type ScopePriceRefreshConfig = {
   scope: Scope;
-  scopeFeed: string;
+  scopeConfigurations: [PublicKey, Configuration][];
 };
 
 export function getTokenOracleDataSync(

package/src/utils/pubkey.ts

@@ -253,6 +253,15 @@ export class PubkeyHashMap<K extends PublicKey, V> implements Map<K, V> {
   }
 }
 
+export function setOrAppend<K, V>(map: Map<K, V[]>, key: K, value: V): void {
+  const existing = map.get(key);
+  if (existing) {
+    existing.push(value);
+  } else {
+    map.set(key, [value]);
+  }
+}
+
 export class HashablePublicKey extends PublicKey implements IEquality<HashablePublicKey> {
   // We only use the last 32 bits of the public key for hashing
   static MASK = new BN(1).shln(32).subn(1);