@kamino-finance/klend-sdk 7.3.9 → 7.3.10-beta.1

package/src/classes/actionTypes.ts

@@ -0,0 +1,295 @@
+import { Address, Option, Slot, TransactionSigner } from '@solana/kit';
+import BN from 'bn.js';
+import { ObligationType, ScopePriceRefreshConfig } from '../utils';
+import { KaminoObligation } from './obligation';
+import { KaminoMarket } from './market';
+import { ActionType } from './action';
+
+/**
+ * Props for KaminoAction.initialize
+ */
+export interface InitializeActionProps {
+  kaminoMarket: KaminoMarket;
+  action: ActionType;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  payer?: TransactionSigner;
+}
+
+/**
+ * Props for KaminoAction.buildDepositTxns
+ */
+export interface BuildDepositTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  overrideElevationGroupRequest?: number;
+}
+
+/**
+ * Props for KaminoAction.buildBorrowTxns
+ */
+export interface BuildBorrowTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  overrideElevationGroupRequest?: number;
+}
+
+/**
+ * Props for KaminoAction.buildDepositReserveLiquidityTxns
+ */
+export interface BuildDepositReserveLiquidityTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildRedeemReserveCollateralTxns
+ */
+export interface BuildRedeemReserveCollateralTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildWithdrawTxns
+ */
+export interface BuildWithdrawTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  overrideElevationGroupRequest?: number;
+  obligationCustomizations?: {
+    addedDepositReserves?: Address[];
+  };
+}
+
+/**
+ * Props for KaminoAction.buildRepayTxns
+ */
+export interface BuildRepayTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  currentSlot: Slot;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  payer?: TransactionSigner;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildDepositAndBorrowTxns
+ */
+export interface BuildDepositAndBorrowTxnsProps {
+  kaminoMarket: KaminoMarket;
+  depositAmount: string | BN;
+  depositReserveAddress: Address;
+  borrowAmount: string | BN;
+  borrowReserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildRefreshObligationTxns
+ */
+export interface BuildRefreshObligationTxnsProps {
+  kaminoMarket: KaminoMarket;
+  payer: TransactionSigner;
+  obligation: KaminoObligation;
+  extraComputeBudget?: number;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildRequestElevationGroupTxns
+ */
+export interface BuildRequestElevationGroupTxnsProps {
+  kaminoMarket: KaminoMarket;
+  owner: TransactionSigner;
+  obligation: KaminoObligation;
+  elevationGroup: number;
+  extraComputeBudget?: number;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildDepositAndWithdrawV2Txns
+ */
+export interface BuildDepositAndWithdrawV2TxnsProps {
+  kaminoMarket: KaminoMarket;
+  depositAmount: string | BN;
+  depositReserveAddress: Address;
+  withdrawAmount: string | BN;
+  withdrawReserveAddress: Address;
+  owner: TransactionSigner;
+  currentSlot: Slot;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildRepayAndWithdrawTxns
+ */
+export interface BuildRepayAndWithdrawTxnsProps {
+  kaminoMarket: KaminoMarket;
+  repayAmount: string | BN;
+  repayReserveAddress: Address;
+  withdrawAmount: string | BN;
+  withdrawReserveAddress: Address;
+  payer: TransactionSigner;
+  currentSlot: Slot;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildRepayAndWithdrawV2Txns
+ */
+export interface BuildRepayAndWithdrawV2TxnsProps {
+  kaminoMarket: KaminoMarket;
+  repayAmount: string | BN;
+  repayReserveAddress: Address;
+  withdrawAmount: string | BN;
+  withdrawReserveAddress: Address;
+  payer: TransactionSigner;
+  currentSlot: Slot;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildLiquidateTxns
+ */
+export interface BuildLiquidateTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  minCollateralReceiveAmount: string | BN;
+  repayReserveAddress: Address;
+  withdrawReserveAddress: Address;
+  liquidator: TransactionSigner;
+  obligationOwner: Address;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig?: ScopePriceRefreshConfig;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  maxAllowedLtvOverridePercent?: number;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildWithdrawReferrerFeeTxns
+ */
+export interface BuildWithdrawReferrerFeeTxnsProps {
+  owner: TransactionSigner;
+  reserveAddress: Address;
+  kaminoMarket: KaminoMarket;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildDepositObligationCollateralTxns
+ */
+export interface BuildDepositObligationCollateralTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}

package/src/classes/market.ts

@@ -34,8 +34,11 @@ import {
   isNotNullPubkey,
   lendingMarketAuthPda,
   LendingObligation,
+  LendingObligationFixedRate,
   LeverageObligation,
+  LeverageObligationFixedRate,
   MultiplyObligation,
+  MultiplyObligationFixedRate,
   ObligationType,
   PythPrices,
   referrerTokenStatePda,
@@ -53,7 +56,7 @@ import { Fraction } from './fraction';
 import { batchFetch, chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import { ObligationZP } from '../@codegen/klend/zero_padding';
-import { checkDefined } from '../utils/validations';
+import { checkArrayNotEmpty, checkDefined } from '../utils/validations';
 import { Buffer } from 'buffer';
 import { ReserveStatus } from '../@codegen/klend/types';
 import { fetchKaminoCdnData } from '../utils/readCdnData';
@@ -121,6 +124,22 @@ export class KaminoMarket {
     );
   }
 
+  /**
+   * TESTING ONLY!
+   *
+   * Used to create mock markets for testing
+   */
+  static createMarket(
+    rpc: Rpc<KaminoMarketRpcApi>,
+    state: LendingMarket,
+    marketAddress: Address,
+    reserves: Map<Address, KaminoReserve>,
+    recentSlotDurationMs: number,
+    programId: Address = PROGRAM_ID
+  ) {
+    return new KaminoMarket(rpc, state, marketAddress, reserves, recentSlotDurationMs, programId);
+  }
+
   /**
    * Load a new market with all of its associated reserves
    * @param rpc
@@ -291,14 +310,22 @@ export class KaminoMarket {
     return parseZeroPaddedUtf8(this.state.name);
   }
 
-  async getObligationDepositByWallet(owner: Address, mint: Address, obligationType: ObligationType): Promise<Decimal> {
+  async getObligationDepositByWallet(
+    owner: Address,
+    depositReserveAddress: Address,
+    obligationType: ObligationType
+  ): Promise<Decimal> {
     const obligation = await this.getObligationByWallet(owner, obligationType);
-    return obligation?.getDepositByMint(mint)?.amount ?? new Decimal(0);
+    return obligation?.getDepositByReserve(depositReserveAddress)?.amount ?? new Decimal(0);
   }
 
-  async getObligationBorrowByWallet(owner: Address, mint: Address, obligationType: ObligationType): Promise<Decimal> {
+  async getObligationBorrowByWallet(
+    owner: Address,
+    borrowReserveAddress: Address,
+    obligationType: ObligationType
+  ): Promise<Decimal> {
     const obligation = await this.getObligationByWallet(owner, obligationType);
-    return obligation?.getBorrowByMint(mint)?.amount ?? new Decimal(0);
+    return obligation?.getBorrowByReserve(borrowReserveAddress)?.amount ?? new Decimal(0);
   }
 
   getTotalDepositTVL(): Decimal {
@@ -317,10 +344,10 @@ export class KaminoMarket {
     return tvl;
   }
 
-  getMaxLeverageForPair(collTokenMint: Address, debtTokenMint: Address): number {
+  getMaxLeverageForPair(collReserveAddress: Address, debtReserveAddress: Address): number {
     const { maxLtv: maxCollateralLtv, borrowFactor } = this.getMaxAndLiquidationLtvAndBorrowFactorForPair(
-      collTokenMint,
-      debtTokenMint
+      collReserveAddress,
+      debtReserveAddress
     );
 
     const maxLeverage =
@@ -345,12 +372,11 @@ export class KaminoMarket {
   }
 
   getMaxAndLiquidationLtvAndBorrowFactorForPair(
-    collTokenMint: Address,
-    debtTokenMint: Address
+    collReserveAddress: Address,
+    debtReserveAddress: Address
   ): { maxLtv: number; liquidationLtv: number; borrowFactor: number } {
-    const collReserve: KaminoReserve | undefined = this.getReserveByMint(collTokenMint);
-    const debtReserve: KaminoReserve | undefined = this.getReserveByMint(debtTokenMint);
-
+    const collReserve: KaminoReserve | undefined = this.getReserveByAddress(collReserveAddress);
+    const debtReserve: KaminoReserve | undefined = this.getReserveByAddress(debtReserveAddress);
     if (!collReserve || !debtReserve) {
       throw Error('Could not find one of the reserves.');
     }
@@ -405,6 +431,22 @@ export class KaminoMarket {
         );
         break;
       }
+      case LendingObligationFixedRate.tag: {
+        const reserveAddress = productType.toArgs().seed1;
+        obligations = obligations.filter((obligation) => obligation.getDepositByReserve(reserveAddress) !== undefined);
+        break;
+      }
+      case LeverageObligationFixedRate.tag:
+      case MultiplyObligationFixedRate.tag: {
+        const collReserveAddress = productType.toArgs().seed1;
+        const debtReserveAddress = productType.toArgs().seed2;
+        obligations = obligations.filter((obligation) => {
+          const collDeposit = obligation.getDepositByReserve(collReserveAddress);
+          const debtBorrow = obligation.getBorrowByReserve(debtReserveAddress);
+          return collDeposit !== undefined && debtBorrow !== undefined;
+        });
+        break;
+      }
       default:
         throw new Error('Invalid obligation type');
     }
@@ -457,7 +499,7 @@ export class KaminoMarket {
     obligation?: KaminoObligation
   ): Decimal {
     return obligation
-      ? obligation.getMaxBorrowAmount(this, debtReserve.getLiquidityMint(), slot, requestElevationGroup)
+      ? obligation.getMaxBorrowAmount(this, debtReserve.address, slot, requestElevationGroup)
       : debtReserve.getMaxBorrowAmountWithCollReserve(this, collReserve, slot);
   }
 
@@ -529,46 +571,47 @@ export class KaminoMarket {
     return checkDefined(this.getReserveByAddress(address), `${description} reserve ${address} not found`);
   }
 
-  getReserveByMint(address: Address): KaminoReserve | undefined {
+  getReservesByMint(address: Address): KaminoReserve[] {
+    const reserves: KaminoReserve[] = [];
     for (const reserve of this.reserves.values()) {
       if (reserve.getLiquidityMint() === address) {
-        return reserve;
+        reserves.push(reserve);
       }
     }
-    return undefined;
+    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.
    */
-  getExistingReserveByMint(address: Address, description: string = 'Requested'): KaminoReserve {
-    return checkDefined(this.getReserveByMint(address), `${description} reserve with mint ${address} not found`);
+  getExistingReservesByMint(address: Address, description: string = 'Requested'): KaminoReserve[] {
+    return checkArrayNotEmpty(this.getReservesByMint(address), `${description} reserve with mint ${address} not found`);
   }
 
-  getReserveBySymbol(symbol: string) {
+  getReservesBySymbol(symbol: string): KaminoReserve[] {
+    const reserves: KaminoReserve[] = [];
     for (const reserve of this.reserves.values()) {
       if (reserve.symbol === symbol) {
-        return reserve;
+        reserves.push(reserve);
       }
     }
-    return undefined;
+    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.
    */
-  getExistingReserveBySymbol(symbol: string, description: string = 'Requested'): KaminoReserve {
-    return checkDefined(this.getReserveBySymbol(symbol), `${description} reserve with symbol ${symbol} not found`);
-  }
-
-  getReserveMintBySymbol(symbol: string) {
-    return this.getReserveBySymbol(symbol)?.getLiquidityMint();
+  getExistingReservesBySymbol(symbol: string, description: string = 'Requested'): KaminoReserve[] {
+    return checkArrayNotEmpty(
+      this.getReservesBySymbol(symbol),
+      `${description} reserve with symbol ${symbol} not found`
+    );
   }
 
   async getReserveFarmInfo(
-    mint: Address,
+    reserveAddress: Address,
     getRewardPrice: (mint: Address) => Promise<number>
   ): Promise<{ borrowingRewards: ReserveRewardInfo; depositingRewards: ReserveRewardInfo }> {
     const { address } = this;
@@ -580,10 +623,10 @@ export class KaminoMarket {
     }
 
     // Find the reserve
-    const kaminoReserve = this.getReserveByMint(mint);
+    const kaminoReserve = this.getReserveByAddress(reserveAddress);
 
     if (!kaminoReserve) {
-      throw Error(`Could not find reserve. ${mint}`);
+      throw Error(`Could not find reserve ${reserveAddress}`);
     }
 
     const totalDepositAmount = lamportsToNumberDecimal(