@kamino-finance/klend-sdk 5.10.6 → 5.10.8

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/manager.ts

@@ -66,7 +66,7 @@ import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Data } from '@kamino-finance/kliquidity-sdk';
 import bs58 from 'bs58';
 import { getProgramAccounts } from '../utils/rpc';
-import { VaultConfigFieldKind } from '../idl_codegen_kamino_vault/types';
+import { VaultConfigField, VaultConfigFieldKind } from '../idl_codegen_kamino_vault/types';
 import {
   AcceptVaultOwnershipIxs,
   DepositIxs,
@@ -369,9 +369,14 @@ export class KaminoManager {
    */
   async updateVaultConfigIxs(
     vault: KaminoVault,
-    mode: VaultConfigFieldKind,
+    mode: VaultConfigFieldKind | string,
     value: string
   ): Promise<UpdateVaultConfigIxs> {
+    if (typeof mode === 'string') {
+      const field = VaultConfigField.fromDecoded({ [mode]: '' });
+      return this._vaultClient.updateVaultConfigIxs(vault, field, value);
+    }
+
     return this._vaultClient.updateVaultConfigIxs(vault, mode, value);
   }
 
@@ -465,21 +470,26 @@ export class KaminoManager {
   /**
    * This method calculates the token per share value. This will always change based on interest earned from the vault, but calculating it requires a bunch of rpc requests. Caching this for a short duration would be optimal
    * @param vault - vault to calculate tokensPerShare for
-   * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+   * @param [slot] - the slot at which we retrieve the tokens per share. Optional. If not provided, the function will fetch the current slot
+   * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @returns - token per share value
    */
-  async getTokensPerShareSingleVault(vault: KaminoVault, slot: number): Promise<Decimal> {
-    return this._vaultClient.getTokensPerShareSingleVault(vault, slot);
+  async getTokensPerShareSingleVault(
+    vault: KaminoVault,
+    slot?: number,
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+  ): Promise<Decimal> {
+    return this._vaultClient.getTokensPerShareSingleVault(vault, slot, vaultReservesMap);
   }
 
   /**
    * This method calculates the price of one vault share(kToken)
    * @param vault - vault to calculate sharePrice for
-   * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
    * @param tokenPrice - the price of the vault token (e.g. SOL) in USD
+   * @param [slot] - the slot at which we retrieve the tokens per share. Optional. If not provided, the function will fetch the current slot
    * @returns - share value in USD
    */
-  async getSharePriceInUSD(vault: KaminoVault, slot: number, tokenPrice: Decimal): Promise<Decimal> {
+  async getSharePriceInUSD(vault: KaminoVault, tokenPrice: Decimal, slot?: number): Promise<Decimal> {
     const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
     return tokensPerShare.mul(tokenPrice);
   }
@@ -638,13 +648,13 @@ export class KaminoManager {
   /**
    * This will return an VaultHoldings object which contains the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve
    * @param vault - the kamino vault to get available liquidity to withdraw for
-   * @param slot - current slot
-   * @param vaultReserves - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @param [slot] - the slot for which to calculate the holdings. Optional. If not provided the function will fetch the current slot
+   * @param [vaultReserves] - a hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @returns an VaultHoldings object
    */
   async getVaultHoldings(
     vault: VaultState,
-    slot: number,
+    slot?: number,
     vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
   ): Promise<VaultHoldings> {
     return this._vaultClient.getVaultHoldings(vault, slot, vaultReserves);
@@ -653,37 +663,37 @@ export class KaminoManager {
   /**
    * This will return an VaultHoldingsWithUSDValue object which contains an holdings field representing the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve and additional fields for the total USD value of the available and invested amounts
    * @param vault - the kamino vault to get available liquidity to withdraw for
-   * @param slot - current slot
-   * @param vaultReserves - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param price - the price of the token in the vault (e.g. USDC)
+   * @param [slot] - the slot for which to calculate the holdings. Optional. If not provided the function will fetch the current slot
+   * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
    */
   async getVaultHoldingsWithPrice(
     vault: VaultState,
-    slot: number,
     price: Decimal,
+    slot?: number,
     vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
   ): Promise<VaultHoldingsWithUSDValue> {
-    return this._vaultClient.getVaultHoldingsWithPrice(vault, slot, price, vaultReserves);
+    return this._vaultClient.getVaultHoldingsWithPrice(vault, price, slot, vaultReserves);
   }
 
   /**
    * This will return an VaultOverview object that encapsulates all the information about the vault, including the holdings, reserves details, theoretical APY, utilization ratio and total borrowed amount
    * @param vault - the kamino vault to get available liquidity to withdraw for
-   * @param slot - current slot
    * @param price - the price of the token in the vault (e.g. USDC)
-   * @param vaultReserves - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
-   * @param kaminoMarkets - optional parameter; a list of all kamino markets. If provided the function will be significantly faster as it will not have to fetch the markets
-   * @returns an VaultHoldingsWithUSDValue object with details about the tokens available and invested in the vault, denominated in tokens and USD
+   * @param [slot] - the slot for which to retrieve the vault overview for. Optional. If not provided the function will fetch the current slot
+   * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @param [kaminoMarkets] - a list of all kamino markets. Optional. If provided the function will be significantly faster as it will not have to fetch the markets
+   * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD
    */
   async getVaultOverview(
     vault: VaultState,
-    slot: number,
     price: Decimal,
+    slot?: number,
     vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>,
     kaminoMarkets?: KaminoMarket[]
   ): Promise<VaultOverview> {
-    return this._vaultClient.getVaultOverview(vault, slot, price, vaultReserves, kaminoMarkets);
+    return this._vaultClient.getVaultOverview(vault, price, slot, vaultReserves, kaminoMarkets);
   }
 
   /**
@@ -743,16 +753,23 @@ export class KaminoManager {
   /**
    * Simulate the current holdings of the vault and the earned interest
    * @param vaultState the kamino vault state to get simulated holdings and earnings for
-   * @param vaultReserves optional; the state of the reserves in the vault allocation
+   * @param [vaultReservesMap] - hashmap from each reserve pubkey to the reserve state. Optional. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @param [currentSlot] - the current slot. Optional. If not provided it will fetch the current slot
+   * @param [previousTotalAUM] - the previous AUM of the vault to compute the earned interest relative to this value. Optional. If not provided the function will estimate the total AUM at the slot of the last state update on chain
    * @returns a struct of simulated vault holdings and earned interest
    */
   async calculateSimulatedHoldingsWithInterest(
     vaultState: VaultState,
     vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>,
-    currentSlot?: number
+    currentSlot?: number,
+    previousTotalAUM?: Decimal
   ): Promise<SimulatedVaultHoldingsWithEarnedInterest> {
-    return this._vaultClient.calculateSimulatedHoldingsWithInterest(vaultState, vaultReserves, currentSlot);
+    return this._vaultClient.calculateSimulatedHoldingsWithInterest(
+      vaultState,
+      vaultReserves,
+      currentSlot,
+      previousTotalAUM
+    );
   }
 
   /**

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/classes/types_utils.ts

@@ -0,0 +1,19 @@
+import { pubkeyHashMapToJson } from './utils';
+import { VaultHoldings } from './vault';
+
+export function holdingsToJson(holdings: VaultHoldings) {
+  return {
+    available: holdings.available.toString(),
+    invested: holdings.invested.toString(),
+    total: holdings.total.toString(),
+    investedInReserves: pubkeyHashMapToJson(holdings.investedInReserves),
+  };
+}
+
+export function printHoldings(holdings: VaultHoldings) {
+  console.log('Holdings:');
+  console.log('  Available:', holdings.available.toString());
+  console.log('  Invested:', holdings.invested.toString());
+  console.log('  Total:', holdings.total.toString());
+  console.log('  Invested in reserves:', pubkeyHashMapToJson(holdings.investedInReserves));
+}

package/src/classes/utils.ts

@@ -1,4 +1,4 @@
-import { SLOTS_PER_SECOND, SLOTS_PER_YEAR } from '../utils';
+import { PubkeyHashMap, SLOTS_PER_SECOND, SLOTS_PER_YEAR } from '../utils';
 import Decimal from 'decimal.js';
 import { AccountInfo, PublicKey } from '@solana/web3.js';
 import { SOL_MINTS } from '../lib';
@@ -250,3 +250,24 @@ export function truncateDecimals(num: Decimal.Value, maxDecimals: number): Decim
   const factor = new Decimal(10).pow(maxDecimals);
   return new Decimal(num).times(factor).floor().dividedBy(factor);
 }
+
+/**Convert an u8 array to a string */
+export function decodeVaultName(token: number[]): string {
+  const maxArray = new Uint8Array(token);
+  let s: string = new TextDecoder().decode(maxArray);
+  // Remove trailing zeros and spaces
+  s = s.replace(/[\0 ]+$/, '');
+  return s;
+}
+
+export function pubkeyHashMapToJson(map: PubkeyHashMap<PublicKey, any>): { [key: string]: string } {
+  const obj: { [key: string]: any } = {};
+  map.forEach((value, key) => {
+    obj[key.toBase58()] = value.toString();
+  });
+  return obj;
+}
+
+export function printPubkeyHashMap<V>(map: PubkeyHashMap<PublicKey, V>) {
+  console.log(pubkeyHashMapToJson(map));
+}