@kamino-finance/klend-sdk 5.10.6 → 5.10.7

package/src/classes/action.ts

@@ -411,7 +411,7 @@ export class KaminoAction {
     obligation: KaminoObligation | ObligationType,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
-    requestElevationGroup: boolean = false,
+    requestElevationGroup: boolean = false, // to be requested *before* the deposit
     includeUserMetadata: boolean = true, // if true it includes user metadata
     referrer: PublicKey = PublicKey.default,
     currentSlot: number = 0,
@@ -855,11 +855,17 @@ export class KaminoAction {
     obligation: KaminoObligation | ObligationType,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
-    requestElevationGroup: boolean = false,
+    requestElevationGroup: boolean = false, // to be requested *after* the withdraw
     includeUserMetadata: boolean = true, // if true it includes user metadata
     referrer: PublicKey = PublicKey.default,
     currentSlot: number = 0,
-    scopeRefresh: ScopeRefresh = { includeScopeRefresh: false, scopeFeed: 'hubble' }
+    scopeRefresh: ScopeRefresh | undefined = undefined,
+    overrideElevationGroupRequest?: number,
+    // Optional customizations which may be needed if the obligation was mutated by some previous ixn.
+    obligationCustomizations?: {
+      // Any newly-added deposit reserves.
+      addedDepositReserves?: PublicKey[];
+    }
   ) {
     const axn = await KaminoAction.initialize(
       'withdraw',
@@ -877,6 +883,8 @@ export class KaminoAction {
       axn.addComputeBudgetIxn(extraComputeBudget);
     }
 
+    axn.depositReserves.push(...(obligationCustomizations?.addedDepositReserves || []));
+
     const allReserves = new PublicKeySet<PublicKey>([
       ...axn.depositReserves,
       ...axn.borrowReserves,
@@ -884,7 +892,7 @@ export class KaminoAction {
     ]).toArray();
     const tokenIds = axn.getTokenIdsForScopeRefresh(kaminoMarket, allReserves);
 
-    if (tokenIds.length > 0 && scopeRefresh.includeScopeRefresh) {
+    if (tokenIds.length > 0 && scopeRefresh && scopeRefresh.includeScopeRefresh) {
       await axn.addScopeRefreshIxs(tokenIds, scopeRefresh.scopeFeed);
     }
 
@@ -893,7 +901,9 @@ export class KaminoAction {
       includeAtaIxns,
       requestElevationGroup,
       includeUserMetadata,
-      addInitObligationForFarm
+      addInitObligationForFarm,
+      false,
+      overrideElevationGroupRequest
     );
     await axn.addWithdrawIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
@@ -1827,6 +1837,16 @@ export class KaminoAction {
           this.addRefreshReserveIxs(allReservesExcludingCurrent, addAsSupportIx);
           this.addRefreshReserveIxs(currentReserveAddresses.toArray(), addAsSupportIx);
           this.addRefreshObligationIx(addAsSupportIx);
+        } else if (
+          action === 'withdraw' &&
+          overrideElevationGroupRequest !== undefined
+          // Note: contrary to the 'deposit' case above, we allow requesting the same group as in the [stale, cached] obligation state, since our current use-case is "deposit X, withdraw Y"
+        ) {
+          console.log('Withdraw: Requesting elevation group', overrideElevationGroupRequest);
+          // Skip the withdrawn reserve if we are in the process of closing it:
+          const skipReserveIfClosing = this.amount.eq(new BN(U64_MAX)) ? [this.reserve.address] : [];
+          this.addRefreshObligationIx('cleanup', skipReserveIfClosing);
+          this.addRequestElevationIx(overrideElevationGroupRequest, 'cleanup', skipReserveIfClosing);
         }
       }
 
@@ -1996,7 +2016,7 @@ export class KaminoAction {
     });
   }
 
-  private addRefreshObligationIx(addAsSupportIx: AuxiliaryIx = 'setup', borrowReservesToSkip: PublicKey[] = []) {
+  private addRefreshObligationIx(addAsSupportIx: AuxiliaryIx = 'setup', skipReserves: PublicKey[] = []) {
     const marketAddress = this.kaminoMarket.getAddress();
     const obligationPda = this.getObligationPda();
     const refreshObligationIx = refreshObligation(
@@ -2007,15 +2027,16 @@ export class KaminoAction {
       this.kaminoMarket.programId
     );
 
-    const depositReservesList = this.getAdditionalDepositReservesList();
+    const skipReservesSet = new PublicKeySet(skipReserves);
 
+    const depositReservesList = this.getAdditionalDepositReservesList().filter(
+      (reserve) => !skipReservesSet.contains(reserve)
+    );
     const depositReserveAccountMetas = depositReservesList.map((reserve) => {
       return { pubkey: reserve, isSigner: false, isWritable: true };
     });
 
-    const skipBorrowsSet = new PublicKeySet(borrowReservesToSkip);
-    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipBorrowsSet.contains(reserve));
-
+    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipReservesSet.contains(reserve));
     const borrowReserveAccountMetas = borrowReservesList.map((reserve) => {
       return { pubkey: reserve, isSigner: false, isWritable: true };
     });
@@ -2048,11 +2069,7 @@ export class KaminoAction {
     }
   }
 
-  private addRequestElevationIx(
-    elevationGroup: number,
-    addAsSupportIx: AuxiliaryIx,
-    skipBorrowReserves: PublicKey[] = []
-  ) {
+  private addRequestElevationIx(elevationGroup: number, addAsSupportIx: AuxiliaryIx, skipReserves: PublicKey[] = []) {
     const obligationPda = this.getObligationPda();
     const args: RequestElevationGroupArgs = {
       elevationGroup,
@@ -2065,15 +2082,16 @@ export class KaminoAction {
 
     const requestElevationGroupIx = requestElevationGroup(args, accounts, this.kaminoMarket.programId);
 
-    const depositReservesList = this.getAdditionalDepositReservesList();
+    const skipReservesSet = new PublicKeySet<PublicKey>(skipReserves);
 
+    const depositReservesList = this.getAdditionalDepositReservesList().filter(
+      (reserve) => !skipReservesSet.contains(reserve)
+    );
     const depositReserveAccountMetas = depositReservesList.map((reserve) => {
       return { pubkey: reserve, isSigner: false, isWritable: true };
     });
 
-    const skipBorrowReservesSet = new PublicKeySet<PublicKey>(skipBorrowReserves);
-    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipBorrowReservesSet.contains(reserve));
-
+    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipReservesSet.contains(reserve));
     const borrowReserveAccountMetas = borrowReservesList.map((reserve) => {
       return { pubkey: reserve, isSigner: false, isWritable: true };
     });

package/src/classes/market.ts

@@ -169,6 +169,26 @@ export class KaminoMarket {
     return this.state.elevationGroups[elevationGroup - 1];
   }
 
+  /**
+   * Returns this market's elevation group of the given ID, or `null` for the default group `0`, or throws an error
+   * (including the given description) if the requested group does not exist.
+   */
+  getExistingElevationGroup(
+    elevationGroupId: number,
+    description: string = 'Requested'
+  ): ElevationGroupDescription | null {
+    if (elevationGroupId === 0) {
+      return null;
+    }
+    const elevationGroup = this.getMarketElevationGroupDescriptions().find(
+      (candidate) => candidate.elevationGroup === elevationGroupId
+    );
+    if (elevationGroup === undefined) {
+      throw new Error(`${description} elevation group ${elevationGroupId} not found in market ${this.getAddress()}`);
+    }
+    return elevationGroup;
+  }
+
   getMinNetValueObligation(): Decimal {
     return new Fraction(this.state.minNetValueInObligationSf).toDecimal();
   }
@@ -399,7 +419,7 @@ export class KaminoMarket {
     return this.reserves.get(address);
   }
 
-  getReserveByMint(address: PublicKey) {
+  getReserveByMint(address: PublicKey): KaminoReserve | undefined {
     for (const reserve of this.reserves.values()) {
       if (reserve.getLiquidityMint().equals(address)) {
         return reserve;
@@ -408,6 +428,18 @@ export class KaminoMarket {
     return undefined;
   }
 
+  /**
+   * 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: PublicKey, description: string = 'Requested'): KaminoReserve {
+    const reserve = this.getReserveByMint(address);
+    if (!reserve) {
+      throw new Error(`${description} reserve with mint ${address} not found in market ${this.getAddress()}`);
+    }
+    return reserve;
+  }
+
   getReserveBySymbol(symbol: string) {
     for (const reserve of this.reserves.values()) {
       if (reserve.symbol === symbol) {
@@ -1297,6 +1329,7 @@ export class KaminoMarket {
         debtReserve: elevationGroup.debtReserve,
         debtLiquidityMint: PublicKey.default,
         elevationGroup: elevationGroup.id,
+        maxReservesAsCollateral: elevationGroup.maxReservesAsCollateral,
       });
     }
 
@@ -1392,6 +1425,7 @@ export type ElevationGroupDescription = {
   debtReserve: PublicKey;
   debtLiquidityMint: PublicKey;
   elevationGroup: number;
+  maxReservesAsCollateral: number;
 };
 
 export type KlendPrices = {

package/src/classes/obligation.ts

@@ -262,6 +262,11 @@ export class KaminoObligation {
     return undefined;
   }
 
+  getBorrowAmountByReserve(reserve: KaminoReserve): Decimal {
+    const amountLamports = this.getBorrowByMint(reserve.getLiquidityMint())?.amount ?? new Decimal(0);
+    return amountLamports.div(reserve.getMintFactor());
+  }
+
   getDepositByMint(mint: PublicKey): Position | undefined {
     for (const value of this.deposits.values()) {
       if (value.mintAddress.equals(mint)) {
@@ -271,6 +276,11 @@ export class KaminoObligation {
     return undefined;
   }
 
+  getDepositAmountByReserve(reserve: KaminoReserve): Decimal {
+    const amountLamports = this.getDepositByMint(reserve.getLiquidityMint())?.amount ?? new Decimal(0);
+    return amountLamports.div(reserve.getMintFactor());
+  }
+
   /**
    *
    * @returns Market value of the borrow in the specified obligation liquidity/borrow asset (USD) (no borrow factor weighting)
@@ -652,6 +662,71 @@ export class KaminoObligation {
     };
   }
 
+  /**
+   * Calculates the stats of the obligation after a hypothetical collateral swap.
+   */
+  getPostSwapCollObligationStats(params: {
+    withdrawAmountLamports: Decimal;
+    withdrawReserveAddress: PublicKey;
+    depositAmountLamports: Decimal;
+    depositReserveAddress: PublicKey;
+    newElevationGroup: number;
+    market: KaminoMarket;
+    slot: number;
+  }): ObligationStats {
+    const {
+      withdrawAmountLamports,
+      withdrawReserveAddress,
+      depositAmountLamports,
+      depositReserveAddress,
+      newElevationGroup,
+      market,
+      slot,
+    } = params;
+
+    const additionalReserves = [withdrawReserveAddress, depositReserveAddress].filter(
+      (reserveAddress) => !market.isReserveInObligation(this, reserveAddress)
+    );
+
+    const { collateralExchangeRates } = KaminoObligation.getRatesForObligation(
+      market,
+      this.state,
+      slot,
+      additionalReserves
+    );
+
+    let newObligationDeposits = this.state.deposits;
+    newObligationDeposits = this.simulateDepositChange(
+      newObligationDeposits,
+      withdrawAmountLamports.neg().toNumber(),
+      withdrawReserveAddress,
+      collateralExchangeRates
+    );
+    newObligationDeposits = this.simulateDepositChange(
+      newObligationDeposits,
+      depositAmountLamports.toNumber(),
+      depositReserveAddress,
+      collateralExchangeRates
+    );
+
+    const { refreshedStats } = this.calculatePositions(
+      market,
+      newObligationDeposits,
+      this.state.borrows,
+      newElevationGroup,
+      collateralExchangeRates,
+      null
+    );
+
+    const newStats = refreshedStats;
+    newStats.netAccountValue = newStats.userTotalDeposit.minus(newStats.userTotalBorrow);
+    newStats.loanToValue = valueOrZero(
+      newStats.userTotalBorrowBorrowFactorAdjusted.dividedBy(newStats.userTotalCollateralDeposit)
+    );
+    newStats.leverage = valueOrZero(newStats.userTotalDeposit.dividedBy(newStats.netAccountValue));
+    return newStats;
+  }
+
   estimateObligationInterestRate = (
     market: KaminoMarket,
     reserve: KaminoReserve,

package/src/lending_operations/index.ts

@@ -1,2 +1,3 @@
 export * from './repay_with_collateral_operations';
+export * from './swap_collateral_operations';
 export * from './repay_with_collateral_calcs';

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -3,8 +3,8 @@ import {
   getFlashLoanInstructions,
   SwapInputs,
   SwapQuote,
-  SwapQuoteIxs,
-  SwapQuoteIxsProvider,
+  SwapIxs,
+  SwapIxsProvider,
   SwapQuoteProvider,
 } from '../leverage';
 import {
@@ -23,10 +23,10 @@ export type RepayWithCollIxsResponse<QuoteResponse> = {
   ixs: TransactionInstruction[];
   lookupTables: AddressLookupTableAccount[];
   swapInputs: SwapInputs;
-  initialInputs: InitialInputs<QuoteResponse>;
+  initialInputs: RepayWithCollInitialInputs<QuoteResponse>;
 };
 
-export type InitialInputs<QuoteResponse> = {
+export type RepayWithCollInitialInputs<QuoteResponse> = {
   debtRepayAmountLamports: Decimal;
   flashRepayAmountLamports: Decimal;
   /**
@@ -69,15 +69,15 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   scopeRefresh,
 }: RepayWithCollSwapInputsProps<QuoteResponse>): Promise<{
   swapInputs: SwapInputs;
-  initialInputs: InitialInputs<QuoteResponse>;
+  initialInputs: RepayWithCollInitialInputs<QuoteResponse>;
 }> {
   const collReserve = kaminoMarket.getReserveByMint(collTokenMint);
   const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint);
   if (!collReserve) {
-    throw new Error(`Collateral reserve with mint ${collReserve} not found in market ${kaminoMarket.getAddress()}`);
+    throw new Error(`Collateral reserve with mint ${collTokenMint} not found in market ${kaminoMarket.getAddress()}`);
   }
   if (!debtReserve) {
-    throw new Error(`Debt reserve with mint ${debtReserve} not found in market ${kaminoMarket.getAddress()}`);
+    throw new Error(`Debt reserve with mint ${debtTokenMint} not found in market ${kaminoMarket.getAddress()}`);
   }
 
   const {
@@ -172,7 +172,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
 }
 
 interface RepayWithCollIxsProps<QuoteResponse> extends RepayWithCollSwapInputsProps<QuoteResponse> {
-  swapper: SwapQuoteIxsProvider<QuoteResponse>;
+  swapper: SwapIxsProvider<QuoteResponse>;
   logger?: (msg: string, ...extra: any[]) => void;
 }
 
@@ -263,7 +263,7 @@ async function buildRepayWithCollateralIxs(
   currentSlot: number,
   budgetAndPriorityFeeIxs: TransactionInstruction[] | undefined,
   scopeRefresh: ScopeRefresh | undefined,
-  swapQuoteIxs: SwapQuoteIxs,
+  swapQuoteIxs: SwapIxs,
   isClosingPosition: boolean,
   debtRepayAmountLamports: Decimal,
   collWithdrawLamports: Decimal
@@ -288,6 +288,7 @@ async function buildRepayWithCollateralIxs(
     reserve: debtReserve,
     amountLamports: debtRepayAmountLamports,
     destinationAta: debtTokenAta,
+    // TODO(referrals): once we support referrals, we will have to replace the placeholder args below:
     referrerAccount: market.programId,
     referrerTokenState: market.programId,
     programId: market.programId,