@kamino-finance/klend-sdk 7.4.0-beta.3 → 7.4.0-beta.4

package/src/classes/market.ts

@@ -40,8 +40,10 @@ import {
   MultiplyObligation,
   MultiplyObligationFixedRate,
   ObligationType,
+  FloatRateReserveKind,
   PythPrices,
   referrerTokenStatePda,
+  ReserveKind,
   setOrAppend,
   userMetadataPda,
   VanillaObligation,
@@ -571,6 +573,12 @@ export class KaminoMarket {
     return checkDefined(this.getReserveByAddress(address), `${description} reserve ${address} not found`);
   }
 
+  /**
+   * Returns all reserves for the given mint address (both float rate and fixed rate).
+   *
+   * @param mint The liquidity mint address
+   * @returns Array of all reserves for this mint
+   */
   getReservesByMint(address: Address): KaminoReserve[] {
     const reserves: KaminoReserve[] = [];
     for (const reserve of this.reserves.values()) {
@@ -581,14 +589,97 @@ export class KaminoMarket {
     return reserves;
   }
 
-  /**
-   * Returns this market's reserve of the given mint address, or throws an error (including the given description) if
-   * such reserve does not exist.
-   */
   getExistingReservesByMint(address: Address, description: string = 'Requested'): KaminoReserve[] {
     return checkArrayNotEmpty(this.getReservesByMint(address), `${description} reserve with mint ${address} not found`);
   }
 
+  /**
+   * Returns this market's reserve matching the given mint address and reserve kind.
+   * Since a market can have multiple reserves for the same mint (with different terms),
+   * the reserve kind specifies which reserve to select.
+   *
+   * Example for fixed-term reserves:
+   * const fixedReserveKind = new FixedReserveKind(new BN(30 * 24 * 60 * 60), 500); // 30 days, 5% borrow rate
+   * const fixedReserve = market.getReserveByMintAndKind(tokenMint, fixedReserveKind)!;
+
+   * @param mint The liquidity mint address
+   * @param reserveKind The reserve kind to match (e.g., FloatRateReserveKind or FixedRateReserveKind)
+   */
+  getReserveByMintAndKind(mint: Address, reserveKind: ReserveKind): KaminoReserve | undefined {
+    for (const reserve of this.reserves.values()) {
+      if (reserve.getLiquidityMint() === mint && reserveKind.matches(reserve)) {
+        return reserve;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Returns this market's reserve matching the given mint address and reserve kind,
+   * or throws an error if not found.
+   *
+   * @param mint The liquidity mint address
+   * @param reserveKind The reserve kind to match
+   * @param description Optional description for the error message
+   */
+  getExistingReserveByMintAndKind(
+    mint: Address,
+    reserveKind: ReserveKind,
+    description: string = 'Requested'
+  ): KaminoReserve {
+    return checkDefined(
+      this.getReserveByMintAndKind(mint, reserveKind),
+      `${description} reserve with mint ${mint} and kind ${reserveKind.toString()} not found`
+    );
+  }
+
+  /**
+   * Returns this market's float rate reserve for the given mint address.
+   * Float rate reserves are reserves without a fixed term (debtTermSeconds = 0).
+   *
+   * @param mint The liquidity mint address
+   * @returns The float rate reserve, or undefined if not found
+   */
+  getFloatRateReserveByMint(mint: Address): KaminoReserve | undefined {
+    return this.getReserveByMintAndKind(mint, new FloatRateReserveKind());
+  }
+
+  /**
+   * Returns this market's float rate reserve for the given mint address,
+   * or throws an error if not found.
+   *
+   * @param mint The liquidity mint address
+   * @param description Optional description for the error message
+   * @returns The float rate reserve
+   */
+  getExistingFloatRateReserveByMint(mint: Address, description: string = 'Requested'): KaminoReserve {
+    return checkDefined(this.getFloatRateReserveByMint(mint), `${description} float rate reserve with mint ${mint} not found`);
+  }
+
+  /**
+   * Returns all fixed rate reserves for the given mint address.
+   * Fixed rate reserves have a non-zero debt term (debtTermSeconds > 0).
+   *
+   * @param mint The liquidity mint address
+   * @returns Array of all fixed rate reserves for this mint
+   */
+  getFixedRateReservesByMint(mint: Address): KaminoReserve[] {
+    const fixedRateReserves: KaminoReserve[] = [];
+    const floatRateReserveKind = new FloatRateReserveKind();
+    for (const reserve of this.reserves.values()) {
+      if (reserve.getLiquidityMint() === mint && !floatRateReserveKind.matches(reserve)) {
+        fixedRateReserves.push(reserve);
+      }
+    }
+    return fixedRateReserves;
+  }
+
+  /**
+   * Returns all reserves for the given symbol (both float rate and fixed rate).
+   *
+   * @param symbol The reserve symbol
+   * @returns Array of all reserves for this symbol
+   */
   getReservesBySymbol(symbol: string): KaminoReserve[] {
     const reserves: KaminoReserve[] = [];
     for (const reserve of this.reserves.values()) {
@@ -599,10 +690,6 @@ export class KaminoMarket {
     return reserves;
   }
 
-  /**
-   * Returns this market's reserve of the given symbol, or throws an error (including the given description) if
-   * such reserve does not exist.
-   */
   getExistingReservesBySymbol(symbol: string, description: string = 'Requested'): KaminoReserve[] {
     return checkArrayNotEmpty(
       this.getReservesBySymbol(symbol),
@@ -610,6 +697,94 @@ export class KaminoMarket {
     );
   }
 
+  /**
+   * Returns this market's reserve matching the given symbol and reserve kind.
+   * Since a market can have multiple reserves for the same symbol (with different terms),
+   * the reserve kind specifies which reserve to select.
+   *
+   * @param symbol The reserve symbol
+   * @param reserveKind The reserve kind to match (e.g., FloatRateReserveKind or FixedRateReserveKind)
+   */
+  getReserveBySymbolAndKind(symbol: string, reserveKind: ReserveKind): KaminoReserve | undefined {
+    for (const reserve of this.reserves.values()) {
+      if (reserve.symbol === symbol && reserveKind.matches(reserve)) {
+        return reserve;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Returns this market's reserve matching the given symbol and reserve kind,
+   * or throws an error if not found.
+   *
+   * @param symbol The reserve symbol
+   * @param reserveKind The reserve kind to match
+   * @param description Optional description for the error message
+   */
+  getExistingReserveBySymbolAndKind(
+    symbol: string,
+    reserveKind: ReserveKind,
+    description: string = 'Requested'
+  ): KaminoReserve {
+    return checkDefined(
+      this.getReserveBySymbolAndKind(symbol, reserveKind),
+      `${description} reserve with symbol ${symbol} and kind ${reserveKind.toString()} not found`
+    );
+  }
+
+  /**
+   * Returns this market's float rate reserve for the given symbol.
+   * Float rate reserves are reserves without a fixed term (debtTermSeconds = 0).
+   *
+   * @param symbol The reserve symbol
+   * @returns The float rate reserve, or undefined if not found
+   */
+  getFloatRateReserveBySymbol(symbol: string): KaminoReserve | undefined {
+    return this.getReserveBySymbolAndKind(symbol, new FloatRateReserveKind());
+  }
+
+  /**
+   * Returns this market's float rate reserve for the given symbol,
+   * or throws an error if not found.
+   *
+   * @param symbol The reserve symbol
+   * @param description Optional description for the error message
+   * @returns The float rate reserve
+   */
+  getExistingFloatRateReserveBySymbol(symbol: string, description: string = 'Requested'): KaminoReserve {
+    return checkDefined(
+      this.getFloatRateReserveBySymbol(symbol),
+      `${description} float rate reserve with symbol ${symbol} not found`
+    );
+  }
+
+  /**
+   * Returns all fixed rate reserves for the given symbol.
+   * Fixed rate reserves have a non-zero debt term (debtTermSeconds > 0).
+   *
+   * @param symbol The reserve symbol
+   * @returns Array of all fixed rate reserves for this symbol
+   */
+  getFixedRateReservesBySymbol(symbol: string): KaminoReserve[] {
+    const fixedRateReserves: KaminoReserve[] = [];
+    const floatRateReserveKind = new FloatRateReserveKind();
+    for (const reserve of this.reserves.values()) {
+      if (reserve.symbol === symbol && !floatRateReserveKind.matches(reserve)) {
+        fixedRateReserves.push(reserve);
+      }
+    }
+    return fixedRateReserves;
+  }
+
+  getReserveMintBySymbol(symbol: string) {
+    const reserves = this.getReservesBySymbol(symbol);
+    if (reserves.length === 0) {
+      throw new Error(`No reserves found for symbol ${symbol}`);
+    }
+    return reserves[0].getLiquidityMint();
+  }
+
   async getReserveFarmInfo(
     reserveAddress: Address,
     getRewardPrice: (mint: Address) => Promise<number>

package/src/classes/reserve.ts

@@ -19,6 +19,7 @@ import Decimal from 'decimal.js';
 import {
   AllOracleAccounts,
   DEFAULT_PUBLIC_KEY,
+  FixedRateReserveKind,
   getTokenOracleData,
   globalConfigPda,
   INITIAL_COLLATERAL_RATE,
@@ -26,7 +27,9 @@ import {
   MarketWithAddress,
   MIN_INITIAL_DEPOSIT,
   ONE_HUNDRED_PCT_IN_BPS,
+  FloatRateReserveKind,
   reservePdas,
+  ReserveKind,
   SLOTS_PER_DAY,
   SLOTS_PER_SECOND,
   SLOTS_PER_YEAR,
@@ -76,6 +79,7 @@ export class KaminoReserve {
   private readonly recentSlotDurationMs: number;
 
   private metadata?: ScopeEntryMetadata[];
+  private reserveKind: ReserveKind;
 
   constructor(
     state: Reserve,
@@ -91,6 +95,7 @@ export class KaminoReserve {
     this.rpc = connection;
     this.symbol = parseTokenSymbol(state.config.tokenInfo.name);
     this.recentSlotDurationMs = recentSlotDurationMs;
+    this.reserveKind = KaminoReserve.createReserveKind(state);
   }
 
   static initialize(
@@ -130,6 +135,16 @@ export class KaminoReserve {
     return new KaminoReserve(reserve, address, tokenOracleData, rpc, recentSlotDurationMs);
   }
 
+  static createReserveKind(state: Reserve): ReserveKind {
+    const debtTermSeconds = state.config.debtTermSeconds;
+    if (debtTermSeconds.eqn(0)) {
+      return new FloatRateReserveKind();
+    } else {
+      const borrowRateBps = state.config.borrowRateCurve.points[0]?.borrowRateBps || 0;
+      return new FixedRateReserveKind(debtTermSeconds, borrowRateBps);
+    }
+  }
+
   /// GETTERS
 
   /**
@@ -733,6 +748,15 @@ export class KaminoReserve {
     return this.state.collateral.mintPubkey;
   }
 
+  /**
+   * Returns the reserve kind (FloatRateReserveKind or FixedRateReserveKind) for this reserve.
+   *
+   * @returns The reserve kind instance
+   */
+  getKind(): ReserveKind {
+    return this.reserveKind;
+  }
+
   calculateFees(
     amountLamports: Decimal,
     borrowFeeRate: Decimal,

package/src/utils/ReserveKind.ts

@@ -0,0 +1,94 @@
+import BN from 'bn.js';
+import { KaminoReserve } from '../classes/reserve';
+
+/**
+ * Base class for reserve kind identification.
+ * Since a market can have multiple reserves for the same mint (with different terms),
+ * this kind specifies which reserve to select.
+ */
+export abstract class ReserveKind {
+  /**
+   * Checks if a reserve matches this reserve kind's criteria
+   */
+  abstract matches(reserve: KaminoReserve): boolean;
+
+  /**
+   * Returns a human-readable string representation
+   */
+  abstract toString(): string;
+
+  /**
+   * Type check: returns true if this is an open-term reserve
+   */
+  abstract isFloatRate(): boolean;
+
+  /**
+   * Type check: returns true if this is a fixed-term reserve
+   */
+  abstract isFixedRate(): boolean;
+}
+
+/**
+ * Represents an open-term reserve with no fixed maturity.
+ */
+export class FloatRateReserveKind extends ReserveKind {
+  /**
+   * Checks if a reserve matches this open-term reserve kind (debtTermSeconds == 0)
+   */
+  matches(reserve: KaminoReserve): boolean {
+    return reserve.state.config.debtTermSeconds.eq(new BN(0));
+  }
+
+  toString(): string {
+    return 'FloatRate';
+  }
+
+  isFloatRate(): boolean {
+    return true;
+  }
+
+  isFixedRate(): boolean {
+    return false;
+  }
+}
+
+/**
+ * Represents a fixed-term reserve with specific loan parameters.
+ */
+export class FixedRateReserveKind extends ReserveKind {
+  /**
+   * @param debtTermSeconds The debt term in seconds (e.g., new BN(30 * 24 * 60 * 60) for 30 days)
+   * @param borrowRateBps The maximum borrow rate in basis points (e.g., 500 for 5%)
+   */
+  constructor(public readonly debtTermSeconds: BN, public readonly borrowRateBps: number) {
+    super();
+  }
+
+  /**
+   * Checks if a reserve matches this fixed-term reserve kind
+   */
+  matches(reserve: KaminoReserve): boolean {
+    // Check debt term matches
+    if (!reserve.state.config.debtTermSeconds.eq(this.debtTermSeconds)) {
+      return false;
+    }
+
+    // For fixed-term reserves, all points on the borrow rate curve should have the same rate
+    const curvePoints = reserve.state.config.borrowRateCurve.points;
+
+    // Check if all points have the expected borrow rate
+    return curvePoints.every((point) => point.borrowRateBps === this.borrowRateBps);
+  }
+
+  toString(): string {
+    return `FixedRate(term=${this.debtTermSeconds.toString()}s, rate=${this.borrowRateBps}bps)`;
+  }
+
+  isFloatRate(): boolean {
+    return false;
+  }
+
+  isFixedRate(): boolean {
+    return true;
+  }
+}

package/src/utils/index.ts

@@ -5,6 +5,7 @@ export * from './constants';
 export * from './idl';
 export * from './instruction';
 export * from './ObligationType';
+export * from './ReserveKind';
 export * from './seeds';
 export * from './slots';
 export * from './userMetadata';