@kamino-finance/klend-sdk 5.11.5-beta.0 → 5.11.6-beta.0

package/src/utils/lookupTable.ts

@@ -53,65 +53,3 @@ export const extendLookupTableIxs = (
 
   return extendLookupIxs;
 };
-
-/**
- * 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/utils/managerTypes.ts

@@ -397,17 +397,59 @@ export function getReserveOracleConfigs(priceFeed: PriceFeed | null): {
   };
 }
 
-const ORACLE_TYPE_MAP = Object.fromEntries(
-  Object.values(OracleType)
-    // Filter for oracle types that have a discriminator property
-    // This ensures we only include actual oracle implementations in the mapping
-    // Pyth is used as a type assertion here but actually any oracle type with a discriminator will pass
-    .filter((T): T is typeof OracleType.Pyth => 'discriminator' in T)
-    .map((T) => [T.discriminator, T.name])
-);
-
 export function parseOracleType(type: number): string {
-  return ORACLE_TYPE_MAP[type] || 'Unknown';
+  switch (type) {
+    case new OracleType.Pyth().discriminator:
+      return 'Pyth';
+    case new OracleType.SwitchboardV2().discriminator:
+      return 'SwitchboardV2';
+    case new OracleType.CToken().discriminator:
+      return 'CToken';
+    case new OracleType.KToken().discriminator:
+      return 'KToken';
+    case new OracleType.SplStake().discriminator:
+      return 'SplStake';
+    case new OracleType.PythEMA().discriminator:
+      return 'PythEMA';
+    case new OracleType.DeprecatedPlaceholder1().discriminator:
+      return 'DeprecatedPlaceholder1';
+    case new OracleType.DeprecatedPlaceholder2().discriminator:
+      return 'DeprecatedPlaceholder2';
+    case new OracleType.MsolStake().discriminator:
+      return 'MsolStake';
+    case new OracleType.KTokenToTokenA().discriminator:
+      return 'KTokenToTokenA';
+    case new OracleType.KTokenToTokenB().discriminator:
+      return 'KTokenToTokenB';
+    case new OracleType.JupiterLpFetch().discriminator:
+      return 'JupiterLpFetch';
+    case new OracleType.ScopeTwap().discriminator:
+      return 'ScopeTwap';
+    case new OracleType.OrcaWhirlpoolAtoB().discriminator:
+      return 'OrcaWhirlpoolAtoB';
+    case new OracleType.OrcaWhirlpoolBtoA().discriminator:
+      return 'OrcaWhirlpoolBtoA';
+    case new OracleType.RaydiumAmmV3AtoB().discriminator:
+      return 'RaydiumAmmV3AtoB';
+    case new OracleType.RaydiumAmmV3BtoA().discriminator:
+      return 'RaydiumAmmV3BtoA';
+    case new OracleType.JupiterLpCompute().discriminator:
+      return 'JupiterLpCompute';
+    case new OracleType.MeteoraDlmmAtoB().discriminator:
+      return 'MeteoraDlmmAtoB';
+    case new OracleType.MeteoraDlmmBtoA().discriminator:
+      return 'MeteoraDlmmBtoA';
+    case new OracleType.JupiterLpScope().discriminator:
+      return 'JupiterLpScope';
+    case new OracleType.PythPullBased().discriminator:
+      return 'PythPullBased';
+    case new OracleType.PythPullBasedEMA().discriminator:
+      return 'PythPullBasedEMA';
+    case new OracleType.FixedPrice().discriminator:
+      return 'FixedPrice';
+    default:
+      return 'Unknown';
+  }
 }
 
 export type MarketWithAddress = {

package/src/utils/oracle.ts

@@ -35,8 +35,8 @@ export type CandidatePrice = {
   valid: boolean;
 };
 
-export type ScopePriceRefreshConfig = {
-  scope: Scope;
+export type ScopeRefresh = {
+  includeScopeRefresh: boolean;
   scopeFeed: string;
 };
 
@@ -170,11 +170,10 @@ export function cacheOrGetPythPrices(
         const { price, exponent, conf: confidence, publishTime: timestamp, emaPrice } = priceMessage;
         if (price) {
           const px = new Decimal(price.toString()).div(10 ** Math.abs(exponent));
-          const conf = new Decimal(confidence.toString());
           prices.spot = {
             price: px,
             timestamp: BigInt(timestamp.toString()),
-            valid: validatePythPx(px, conf),
+            valid: validatePythPx(px, confidence.toNumber()),
           };
         }
         if (emaPrice !== undefined && emaPrice !== null) {
@@ -298,9 +297,9 @@ function isBetterPrice(current: CandidatePrice | undefined, next: CandidatePrice
   return next.timestamp > current.timestamp;
 }
 
-function validatePythPx(price: Decimal, confidence: Decimal): boolean {
-  const conf50x = confidence.mul(CONFIDENCE_FACTOR);
-  return !price.isZero() && price.gt(conf50x);
+function validatePythPx(price: Decimal, confidence: number | undefined): boolean {
+  const conf50x = new Decimal(confidence || 0).mul(CONFIDENCE_FACTOR);
+  return price.gt(conf50x);
 }
 
 function validateSwitchboardV2Px(agg: any): boolean {

package/src/utils/seeds.ts

@@ -38,10 +38,6 @@ export const BASE_SEED_REFERRER_STATE = 'ref_state';
  * Short url seed
  */
 export const BASE_SEED_SHORT_URL = 'short_url';
-/**
- * Farm user state seed
- */
-export const BASE_SEED_USER_STATE = 'user';
 
 /**
  * User farm state seed
@@ -192,15 +188,9 @@ export function shortUrlPda(shortUrl: string, programId: PublicKey = PROGRAM_ID)
   return PublicKey.findProgramAddressSync([Buffer.from(BASE_SEED_SHORT_URL), Buffer.from(shortUrl)], programId);
 }
 
-/**
- * Returns the PDA for the obligation farm state
- * @param farm
- * @param obligation
- * @returns pda
- */
-export function obligationFarmStatePda(farm: PublicKey, obligation: PublicKey) {
+export function obligationFarmStatePda(obligation: PublicKey, farm: PublicKey, programId: PublicKey = farmsId) {
   return PublicKey.findProgramAddressSync(
-    [Buffer.from(BASE_SEED_USER_STATE), farm.toBytes(), obligation.toBytes()],
-    farmsId
-  )[0];
+    [Buffer.from(BASE_SEED_FARM_USER_STATE), farm.toBuffer(), obligation.toBuffer()],
+    programId
+  );
 }

package/src/utils/userMetadata.ts

@@ -6,7 +6,6 @@ import {
   Connection,
   GetProgramAccountsFilter,
 } from '@solana/web3.js';
-import { NATIVE_MINT } from '@solana/spl-token';
 import { KaminoMarket, KaminoObligation } from '../classes';
 import {
   LeverageObligation,
@@ -259,7 +258,7 @@ function getMultiplyObligationAndObligationFarmStateAddresses(
     const collMintString = collMint.toString();
     const debtMintString = debtMint.toString();
     if (collReserve && debtReserve) {
-      const multiplyObligation = new MultiplyObligation(collMint, NATIVE_MINT, kaminoMarket.programId);
+      const multiplyObligation = new MultiplyObligation(collMint, debtMint, kaminoMarket.programId);
       obligationPdas.push({
         address: multiplyObligation.toPda(kaminoMarket.getAddress(), user),
         log: 'multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
@@ -267,18 +266,18 @@ function getMultiplyObligationAndObligationFarmStateAddresses(
       if (!collReserve.state.farmCollateral.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            collReserve.state.farmCollateral!,
-            multiplyObligation.toPda(kaminoMarket.getAddress(), user)
-          ),
+            multiplyObligation.toPda(kaminoMarket.getAddress(), user),
+            collReserve.state.farmCollateral!
+          )[0],
           log: 'collReserve farmState for multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
       if (!debtReserve.state.farmDebt.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            debtReserve.state.farmDebt!,
-            multiplyObligation.toPda(kaminoMarket.getAddress(), user)
-          ),
+            multiplyObligation.toPda(kaminoMarket.getAddress(), user),
+            debtReserve.state.farmDebt!
+          )[0],
           log: 'debtReserve farmState for multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
@@ -310,18 +309,18 @@ function getLeverageObligationAndObligationFarmStateAddresses(
       if (!collReserve.state.farmCollateral.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            collReserve.state.farmCollateral!,
-            leverageObligation.toPda(kaminoMarket.getAddress(), user)
-          ),
+            leverageObligation.toPda(kaminoMarket.getAddress(), user),
+            collReserve.state.farmCollateral!
+          )[0],
           log: 'collReserve farmState for leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
       if (!debtReserve.state.farmDebt.equals(PublicKey.default)) {
         farmUserStates.push({
           address: obligationFarmStatePda(
-            debtReserve.state.farmDebt!,
-            leverageObligation.toPda(kaminoMarket.getAddress(), user)
-          ),
+            leverageObligation.toPda(kaminoMarket.getAddress(), user),
+            debtReserve.state.farmDebt!
+          )[0],
           log: 'debtReserve farmState for leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
         });
       }
@@ -342,7 +341,7 @@ function getRepayWithCollObligationFarmStateAddresses(
     const borrowReserve = kaminoMarket.getReserveByMint(borrow.mintAddress)!;
     if (!borrowReserve.state.farmDebt.equals(PublicKey.default)) {
       farmUserStates.push({
-        address: obligationFarmStatePda(borrowReserve.state.farmDebt!, obligation.obligationAddress),
+        address: obligationFarmStatePda(obligation.obligationAddress, borrowReserve.state.farmDebt!)[0],
         log: 'debtReserve farmState for vanilla obligation: ' + obligationString,
       });
     }
@@ -352,7 +351,7 @@ function getRepayWithCollObligationFarmStateAddresses(
     const depositReserve = kaminoMarket.getReserveByMint(deposit.mintAddress)!;
     if (!depositReserve.state.farmCollateral.equals(PublicKey.default)) {
       farmUserStates.push({
-        address: obligationFarmStatePda(depositReserve.state.farmCollateral!, obligation.obligationAddress),
+        address: obligationFarmStatePda(obligation.obligationAddress, depositReserve.state.farmCollateral!)[0],
         log: 'collReserve farmState for vanilla obligation' + obligationString,
       });
     }