@kamino-finance/klend-sdk 7.4.0-beta.0 → 7.4.0-beta.2

package/src/utils/ObligationType.ts

@@ -11,6 +11,9 @@ export enum ObligationTypeTag {
   Multiply = 1,
   Lending = 2,
   Leverage = 3,
+  MultiplyFixedRate = 4,
+  LendingFixedRate = 5,
+  LeverageFixedRate = 6,
 }
 
 export type InitObligationArgsModel = {
@@ -76,6 +79,36 @@ export class MultiplyObligation {
   }
 }
 
+export class MultiplyObligationFixedRate {
+  readonly collReserveAddress: Address;
+  readonly debtReserveAddress: Address;
+  readonly programId: Address;
+  readonly id: number;
+  static tag = 4;
+
+  constructor(collReserveAddress: Address, debtReserveAddress: Address, programId: Address, id?: number) {
+    this.collReserveAddress = collReserveAddress;
+    this.debtReserveAddress = debtReserveAddress;
+    this.programId = programId;
+    this.id = id ?? 0;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: MultiplyObligationFixedRate.tag,
+      id: this.id,
+      seed1: this.collReserveAddress,
+      seed2: this.debtReserveAddress,
+    };
+
+    return initObligationArgs;
+  }
+
+  toPda(market: Address, user: Address) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
 export class LeverageObligation {
   readonly collToken: Address;
   readonly debtToken: Address;
@@ -106,6 +139,36 @@ export class LeverageObligation {
   }
 }
 
+export class LeverageObligationFixedRate {
+  readonly collReserveAddress: Address;
+  readonly debtReserveAddress: Address;
+  readonly programId: Address;
+  readonly id: number;
+  static tag = 6;
+
+  constructor(collReserveAddress: Address, debtReserveAddress: Address, programId: Address, id?: number) {
+    this.collReserveAddress = collReserveAddress;
+    this.debtReserveAddress = debtReserveAddress;
+    this.programId = programId;
+    this.id = id ?? 0;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: LeverageObligationFixedRate.tag,
+      id: this.id,
+      seed1: this.collReserveAddress,
+      seed2: this.debtReserveAddress,
+    };
+
+    return initObligationArgs;
+  }
+
+  toPda(market: Address, user: Address) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
 export class LendingObligation {
   readonly token: Address;
   readonly programId: Address;
@@ -121,7 +184,7 @@ export class LendingObligation {
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: LendingObligation.tag,
-      id: 0,
+      id: this.id,
       seed1: this.token,
       seed2: this.token,
     };
@@ -134,6 +197,34 @@ export class LendingObligation {
   }
 }
 
+export class LendingObligationFixedRate {
+  readonly reserveAddress: Address;
+  readonly programId: Address;
+  readonly id: number;
+  static tag = 5;
+
+  constructor(reserveAddress: Address, programId: Address, id?: number) {
+    this.reserveAddress = reserveAddress;
+    this.programId = programId;
+    this.id = id ?? 0;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: LendingObligationFixedRate.tag,
+      id: this.id,
+      seed1: this.reserveAddress,
+      seed2: this.reserveAddress,
+    };
+
+    return initObligationArgs;
+  }
+
+  toPda(market: Address, user: Address) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
 export async function getObligationPdaWithArgs(
   market: Address,
   user: Address,

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';

package/src/utils/userMetadata.ts

@@ -25,6 +25,8 @@ import {
   UserMetadata,
   obligationFarmStatePda,
   DEFAULT_PUBLIC_KEY,
+  MultiplyObligationFixedRate,
+  LeverageObligationFixedRate,
 } from '../lib';
 import { KaminoReserve } from '../classes/reserve';
 import { Buffer } from 'buffer';
@@ -42,8 +44,8 @@ export const getUserLutAddressAndSetupIxs = async (
   user: TransactionSigner,
   referrer: Option<Address> = none(),
   withExtendLut: boolean = true,
-  multiplyMints: { coll: Address; debt: Address }[] = [],
-  leverageMints: { coll: Address; debt: Address }[] = [],
+  multiplyReserveAddresses: { coll: Address; debt: Address }[] = [],
+  leverageReserveAddresses: { coll: Address; debt: Address }[] = [],
   repayWithCollObligation: KaminoObligation | undefined = undefined,
   payer: TransactionSigner = user
 ): Promise<[Address, Instruction[][]]> => {
@@ -89,8 +91,8 @@ export const getUserLutAddressAndSetupIxs = async (
       userLookupTableAddress,
       user.address,
       referrer,
-      multiplyMints,
-      leverageMints,
+      multiplyReserveAddresses,
+      leverageReserveAddresses,
       userMetadataState !== null,
       repayWithCollObligation
     );
@@ -110,8 +112,8 @@ const getDedupUserLookupTableAddresses = async (
   tableAddress: Address,
   user: Address,
   referrer: Option<Address>,
-  multiplyMints: { coll: Address; debt: Address }[] = [],
-  leverageMints: { coll: Address; debt: Address }[] = [],
+  multiplyReserveAddresses: { coll: Address; debt: Address }[] = [],
+  leverageReserveAddresses: { coll: Address; debt: Address }[] = [],
   tableExists: boolean,
   repayWithCollObligation: KaminoObligation | undefined = undefined
 ): Promise<Address[]> => {
@@ -119,8 +121,8 @@ const getDedupUserLookupTableAddresses = async (
     kaminoMarket,
     user,
     referrer,
-    multiplyMints,
-    leverageMints,
+    multiplyReserveAddresses,
+    leverageReserveAddresses,
     repayWithCollObligation
   );
 
@@ -148,8 +150,8 @@ const getUserLookupTableAddresses = async (
   kaminoMarket: KaminoMarket,
   user: Address,
   referrer: Option<Address>,
-  multiplyMints: { coll: Address; debt: Address }[] = [],
-  leverageMints: { coll: Address; debt: Address }[] = [],
+  multiplyReserveAddresses: { coll: Address; debt: Address }[] = [],
+  leverageReserveAddresses: { coll: Address; debt: Address }[] = [],
   repayWithCollObligation: KaminoObligation | undefined = undefined
 ): Promise<{ address: Address; log: string }[]> => {
   const addresses: { address: Address; log: string }[] = [];
@@ -158,13 +160,22 @@ const getUserLookupTableAddresses = async (
   addresses.push({ address: userMetadataAddress, log: 'userMetadata address' });
 
   const allMints: Address[] = [];
-  multiplyMints.forEach(({ coll: collMint, debt: debtMint }) => {
-    allMints.push(collMint);
-    allMints.push(debtMint);
+  const allReserves: Address[] = [];
+  multiplyReserveAddresses.forEach(({ coll: collReserveAddress, debt: debtReserveAddress }) => {
+    const collReserveMint = kaminoMarket.getExistingReserveByAddress(collReserveAddress)!.getLiquidityMint();
+    const debtReserveMint = kaminoMarket.getExistingReserveByAddress(debtReserveAddress)!.getLiquidityMint();
+    allMints.push(collReserveMint);
+    allMints.push(debtReserveMint);
+    allReserves.push(collReserveAddress);
+    allReserves.push(debtReserveAddress);
   });
-  leverageMints.forEach(({ coll: collMint, debt: debtMint }) => {
-    allMints.push(collMint);
-    allMints.push(debtMint);
+  leverageReserveAddresses.forEach(({ coll: collReserveAddress, debt: debtReserveAddress }) => {
+    const collReserveMint = kaminoMarket.getExistingReserveByAddress(collReserveAddress)!.getLiquidityMint();
+    const debtReserveMint = kaminoMarket.getExistingReserveByAddress(debtReserveAddress)!.getLiquidityMint();
+    allMints.push(collReserveMint);
+    allMints.push(debtReserveMint);
+    allReserves.push(collReserveAddress);
+    allReserves.push(debtReserveAddress);
   });
 
   if (repayWithCollObligation) {
@@ -178,9 +189,10 @@ const getUserLookupTableAddresses = async (
   }
 
   const dedupMints = [...new Set(allMints)];
+  const dedupReserveAddresses = [...new Set(allReserves)];
   const reserves: KaminoReserve[] = [];
-  dedupMints.forEach((mint) => {
-    const kaminoReserve = kaminoMarket.getReserveByMint(mint);
+  dedupReserveAddresses.forEach((reserveAddress) => {
+    const kaminoReserve = kaminoMarket.getReserveByAddress(reserveAddress);
     if (kaminoReserve) {
       reserves.push(kaminoReserve);
     }
@@ -226,13 +238,13 @@ const getUserLookupTableAddresses = async (
   }
 
   const [multiplyObligations, multiplyObligationsFarmUserStates] =
-    await getMultiplyObligationAndObligationFarmStateAddresses(kaminoMarket, user, multiplyMints);
+    await getMultiplyObligationAndObligationFarmStateAddresses(kaminoMarket, user, multiplyReserveAddresses);
 
   addresses.push(...multiplyObligations);
   addresses.push(...multiplyObligationsFarmUserStates);
 
   const [leverageObligations, leverageObligationsFarmUserStates] =
-    await getLeverageObligationAndObligationFarmStateAddresses(kaminoMarket, user, leverageMints);
+    await getLeverageObligationAndObligationFarmStateAddresses(kaminoMarket, user, leverageReserveAddresses);
 
   addresses.push(...leverageObligations);
   addresses.push(...leverageObligationsFarmUserStates);
@@ -252,14 +264,16 @@ const getUserLookupTableAddresses = async (
 async function getMultiplyObligationAndObligationFarmStateAddresses(
   kaminoMarket: KaminoMarket,
   user: Address,
-  mints: { coll: Address; debt: Address }[]
+  reserveAddresses: { coll: Address; debt: Address }[]
 ): Promise<[{ address: Address; log: string }[], { address: Address; log: string }[]]> {
   const obligationPdas: { address: Address; log: string }[] = [];
   const farmUserStates: { address: Address; log: string }[] = [];
 
-  for (const { coll: collMint, debt: debtMint } of mints) {
-    const collReserve = kaminoMarket.getReserveByMint(collMint);
-    const debtReserve = kaminoMarket.getReserveByMint(debtMint);
+  for (const { coll: collReserveAddress, debt: debtReserveAddress } of reserveAddresses) {
+    const collReserve = kaminoMarket.getReserveByAddress(collReserveAddress);
+    const debtReserve = kaminoMarket.getReserveByAddress(debtReserveAddress);
+    const collMint = collReserve!.getLiquidityMint();
+    const debtMint = debtReserve!.getLiquidityMint();
     const collMintString = collMint.toString();
     const debtMintString = debtMint.toString();
     if (collReserve && debtReserve) {
@@ -268,6 +282,15 @@ async function getMultiplyObligationAndObligationFarmStateAddresses(
         address: await multiplyObligation.toPda(kaminoMarket.getAddress(), user),
         log: 'multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
       });
+      const multiplyObligationFixedRate = new MultiplyObligationFixedRate(
+        collReserveAddress,
+        debtReserveAddress,
+        kaminoMarket.programId
+      );
+      obligationPdas.push({
+        address: await multiplyObligationFixedRate.toPda(kaminoMarket.getAddress(), user),
+        log: 'multiply obligation fixed rate coll: ' + collReserveAddress + ' debt: ' + debtReserveAddress,
+      });
       if (collReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
         farmUserStates.push({
           address: await obligationFarmStatePda(
@@ -295,14 +318,16 @@ async function getMultiplyObligationAndObligationFarmStateAddresses(
 async function getLeverageObligationAndObligationFarmStateAddresses(
   kaminoMarket: KaminoMarket,
   user: Address,
-  mints: { coll: Address; debt: Address }[]
+  reserveAddresses: { coll: Address; debt: Address }[]
 ): Promise<[{ address: Address; log: string }[], { address: Address; log: string }[]]> {
   const obligationPdas: { address: Address; log: string }[] = [];
   const farmUserStates: { address: Address; log: string }[] = [];
 
-  for (const { coll: collMint, debt: debtMint } of mints) {
-    const collReserve = kaminoMarket.getReserveByMint(collMint);
-    const debtReserve = kaminoMarket.getReserveByMint(debtMint);
+  for (const { coll: collReserveAddress, debt: debtReserveAddress } of reserveAddresses) {
+    const collReserve = kaminoMarket.getReserveByAddress(collReserveAddress);
+    const debtReserve = kaminoMarket.getReserveByAddress(debtReserveAddress);
+    const collMint = collReserve!.getLiquidityMint();
+    const debtMint = debtReserve!.getLiquidityMint();
     const collMintString = collMint.toString();
     const debtMintString = debtMint.toString();
     if (collReserve && debtReserve) {
@@ -311,6 +336,15 @@ async function getLeverageObligationAndObligationFarmStateAddresses(
         address: await leverageObligation.toPda(kaminoMarket.getAddress(), user),
         log: 'leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
       });
+      const leverageObligationFixedRate = new LeverageObligationFixedRate(
+        collReserveAddress,
+        debtReserveAddress,
+        kaminoMarket.programId
+      );
+      obligationPdas.push({
+        address: await leverageObligationFixedRate.toPda(kaminoMarket.getAddress(), user),
+        log: 'leverage obligation fixed rate coll: ' + collReserveAddress + ' debt: ' + debtReserveAddress,
+      });
       if (collReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
         farmUserStates.push({
           address: await obligationFarmStatePda(
@@ -343,7 +377,7 @@ async function getRepayWithCollObligationFarmStateAddresses(
   const obligationString = obligation.obligationAddress.toString();
 
   for (const borrow of obligation.getBorrows()) {
-    const borrowReserve = kaminoMarket.getReserveByMint(borrow.mintAddress)!;
+    const borrowReserve = kaminoMarket.getReserveByAddress(borrow.reserveAddress)!;
     if (borrowReserve.state.farmDebt !== DEFAULT_PUBLIC_KEY) {
       farmUserStates.push({
         address: await obligationFarmStatePda(borrowReserve.state.farmDebt!, obligation.obligationAddress),
@@ -353,7 +387,7 @@ async function getRepayWithCollObligationFarmStateAddresses(
   }
 
   for (const deposit of obligation.getDeposits()) {
-    const depositReserve = kaminoMarket.getReserveByMint(deposit.mintAddress)!;
+    const depositReserve = kaminoMarket.getReserveByAddress(deposit.reserveAddress)!;
     if (depositReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
       farmUserStates.push({
         address: await obligationFarmStatePda(depositReserve.state.farmCollateral!, obligation.obligationAddress),

package/src/utils/validations.ts

@@ -14,6 +14,11 @@ export function checkNotNull<T>(value: T | null, message: string = 'value null')
   return value as T;
 }
 
+export function checkArrayNotEmpty<T>(array: T[], message: string = 'array is empty'): T[] {
+  checkThat(array.length > 0, message);
+  return array;
+}
+
 export function getSingleElement<T>(iterable: Iterable<T>, nameWithinMessage: string = 'element'): T {
   const nothingReturnedMarker = {};
   let single: T | {} = nothingReturnedMarker;

package/src/utils/vault.ts

@@ -53,5 +53,7 @@ export function decodeVaultState(data: Buffer): VaultState {
     allowAllocationsInWhitelistedReservesOnly: dec.allowAllocationsInWhitelistedReservesOnly,
     allowInvestInWhitelistedReservesOnly: dec.allowInvestInWhitelistedReservesOnly,
     padding4: dec.padding4,
+    padding2: dec.padding2,
+    withdrawTicketRentBudget: dec.withdrawTicketRentBudget,
   });
 }