@kamino-finance/klend-sdk 5.10.12 → 5.10.14

package/src/classes/reserve.ts

@@ -541,7 +541,7 @@ export class KaminoReserve {
 
     maxBorrowAmount = maxBorrowAmount.sub(borrowFee);
 
-    const utilizationRatioLimit = this.state.config.utilizationLimitBlockBorrowingAbove / 100;
+    const utilizationRatioLimit = this.state.config.utilizationLimitBlockBorrowingAbovePct / 100;
     const currentUtilizationRatio = this.calculateUtilizationRatio();
 
     if (utilizationRatioLimit > 0 && currentUtilizationRatio > utilizationRatioLimit) {
@@ -988,7 +988,7 @@ export class KaminoReserve {
 
   getBorrowCapForReserve(market: KaminoMarket): BorrowCapsAndCounters {
     // Utilization cap
-    const utilizationCap = this.state.config.utilizationLimitBlockBorrowingAbove;
+    const utilizationCap = this.state.config.utilizationLimitBlockBorrowingAbovePct;
     const utilizationCurrentValue = this.calculateUtilizationRatio();
 
     // Daily borrow cap
@@ -1215,7 +1215,7 @@ export function updateEntireReserveConfigIx(
   const args: UpdateReserveConfigArgs = {
     mode: new anchor.BN(25),
     value: value,
-    skipValidation: true,
+    skipValidation: false,
   };
 
   const accounts: UpdateReserveConfigAccounts = {
@@ -1458,23 +1458,23 @@ export function parseForChangesReserveConfigAndGetIxs(
           ),
         });
       }
-    } else if (key === 'utilizationLimitBlockBorrowingAbove') {
+    } else if (key === 'utilizationLimitBlockBorrowingAbovePct') {
       if (reserve === undefined) {
         updateReserveIxnsArgs.push({
-          mode: UpdateConfigMode.UpdateBlockBorrowingAboveUtilization.discriminator,
+          mode: UpdateConfigMode.UpdateBlockBorrowingAboveUtilizationPct.discriminator,
           value: updateReserveConfigEncodedValue(
-            UpdateConfigMode.UpdateBlockBorrowingAboveUtilization.discriminator,
-            reserveConfig.utilizationLimitBlockBorrowingAbove
+            UpdateConfigMode.UpdateBlockBorrowingAboveUtilizationPct.discriminator,
+            reserveConfig.utilizationLimitBlockBorrowingAbovePct
           ),
         });
       } else if (
-        reserve.config.utilizationLimitBlockBorrowingAbove !== reserveConfig.utilizationLimitBlockBorrowingAbove
+        reserve.config.utilizationLimitBlockBorrowingAbovePct !== reserveConfig.utilizationLimitBlockBorrowingAbovePct
       ) {
         updateReserveIxnsArgs.push({
-          mode: UpdateConfigMode.UpdateBlockBorrowingAboveUtilization.discriminator,
+          mode: UpdateConfigMode.UpdateBlockBorrowingAboveUtilizationPct.discriminator,
           value: updateReserveConfigEncodedValue(
-            UpdateConfigMode.UpdateBlockBorrowingAboveUtilization.discriminator,
-            reserveConfig.utilizationLimitBlockBorrowingAbove
+            UpdateConfigMode.UpdateBlockBorrowingAboveUtilizationPct.discriminator,
+            reserveConfig.utilizationLimitBlockBorrowingAbovePct
           ),
         });
       }
@@ -1958,7 +1958,7 @@ export function updateReserveConfigEncodedValue(
     case UpdateConfigMode.UpdateAssetTier.discriminator:
     case UpdateConfigMode.UpdateReserveStatus.discriminator:
     case UpdateConfigMode.UpdateDisableUsageAsCollateralOutsideEmode.discriminator:
-    case UpdateConfigMode.UpdateBlockBorrowingAboveUtilization.discriminator:
+    case UpdateConfigMode.UpdateBlockBorrowingAboveUtilizationPct.discriminator:
     case UpdateConfigMode.UpdateBlockPriceUsage.discriminator:
       buffer = Buffer.alloc(1);
       buffer.writeUIntLE(value as number, 0, 1);

package/src/classes/types_utils.ts

@@ -1,12 +1,13 @@
 import { pubkeyHashMapToJson } from './utils';
-import { VaultHoldings } from './vault';
+import { VaultHoldings, VaultHoldingsWithUSDValue, VaultOverview } from './vault';
 
 export function holdingsToJson(holdings: VaultHoldings) {
   return {
     available: holdings.available.toString(),
     invested: holdings.invested.toString(),
-    total: holdings.total.toString(),
+    totalAUMIncludingFees: holdings.totalAUMIncludingFees.toString(),
     investedInReserves: pubkeyHashMapToJson(holdings.investedInReserves),
+    pendingFees: holdings.pendingFees.toString(),
   };
 }
 
@@ -14,6 +15,35 @@ 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('  Total AUM including fees:', holdings.totalAUMIncludingFees.toString());
+  console.log('  Pending fees:', holdings.pendingFees.toString());
   console.log('  Invested in reserves:', pubkeyHashMapToJson(holdings.investedInReserves));
 }
+
+export function printHoldingsWithUSDValue(holdings: VaultHoldingsWithUSDValue) {
+  console.log('Holdings with USD value:');
+  console.log('  Available:', holdings.availableUSD.toString());
+  console.log('  Invested:', holdings.investedUSD.toString());
+  console.log('  Total including pending fees:', holdings.totalUSDIncludingFees.toString());
+  console.log('  Pending fees:', holdings.pendingFeesUSD.toString());
+  console.log('  Invested in reserves:', pubkeyHashMapToJson(holdings.investedInReservesUSD));
+}
+
+export function printVaultOverview(vaultOverview: VaultOverview) {
+  console.log('Vault overview:');
+  printHoldingsWithUSDValue(vaultOverview.holdingsUSD);
+  console.log('  Theoretical Supply APY:', vaultOverview.theoreticalSupplyAPY.toString());
+  console.log('  Utilization ratio:', vaultOverview.utilizationRatio.toString());
+  console.log('  Total supplied:', vaultOverview.totalSupplied.toString());
+  console.log('  Borrowed amount:', vaultOverview.totalBorrowed.toString());
+
+  vaultOverview.reservesOverview.forEach((reserveOverview, pubkey) => {
+    console.log('  Reserve:', pubkey.toString());
+    console.log('    Total borrowed from reserve:', reserveOverview.totalBorrowedAmount.toString());
+    console.log('    Supplied:', reserveOverview.suppliedAmount.toString());
+    console.log('    Utilization ratio:', reserveOverview.utilizationRatio.toString());
+    console.log('    Liquidation Threshold Pct:', reserveOverview.liquidationThresholdPct.toString());
+    console.log('    Supply APY:', reserveOverview.supplyAPY.toString());
+    console.log('    Lending market:', reserveOverview.market.toString());
+  });
+}

package/src/classes/utils.ts

@@ -1,8 +1,9 @@
 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';
+import { MarketOverview, ReserveOverview, SOL_MINTS } from '../lib';
 import { AccountLayout } from '@solana/spl-token';
+import { ReserveAllocationOverview } from './types';
 
 type ObligationFarmScoreType = {
   obligationId: string;
@@ -271,3 +272,51 @@ export function pubkeyHashMapToJson(map: PubkeyHashMap<PublicKey, any>): { [key:
 export function printPubkeyHashMap<V>(map: PubkeyHashMap<PublicKey, V>) {
   console.log(pubkeyHashMapToJson(map));
 }
+
+export function printReservesOverviewMap(map: PubkeyHashMap<PublicKey, ReserveOverview>) {
+  map.forEach((value, key) => {
+    console.log('Reserve:', key.toString());
+    printReserveOverview(value);
+  });
+}
+
+export function printReserveOverview(reserveOverview: ReserveOverview) {
+  console.log('Total borrowed from reserve:', reserveOverview.totalBorrowedAmount.toString());
+  console.log('Borrowed from the supplied amount:', reserveOverview.amountBorrowedFromSupplied.toString());
+  console.log('Supplied:', reserveOverview.suppliedAmount.toString());
+  console.log('Utilization ratio:', reserveOverview.utilizationRatio.toString());
+  console.log('Liquidation Threshold Pct:', reserveOverview.liquidationThresholdPct.toString());
+  console.log('Supply APY:', reserveOverview.supplyAPY.toString());
+  console.log('Lending market:', reserveOverview.market.toString());
+}
+
+export function printMarketsOverviewMap(map: PubkeyHashMap<PublicKey, MarketOverview>) {
+  map.forEach((value, key) => {
+    console.log('Reserve:', key.toString());
+    printMarketOverview(value);
+  });
+}
+
+export function printMarketOverview(marketOverview: MarketOverview) {
+  console.log('Market overview:');
+  console.log('  Address:', marketOverview.address.toString());
+  console.log('  Min LTV percentage:', marketOverview.minLTVPct.toString());
+  console.log('  Max LTV percentage:', marketOverview.maxLTVPct.toString());
+  marketOverview.reservesAsCollateral.forEach((reserve, _) => {
+    console.log('    Liquidation LTV percentage:', reserve.liquidationLTVPct.toString());
+  });
+}
+
+export function printReservesAllocationOverviewMap(map: PubkeyHashMap<PublicKey, ReserveAllocationOverview>) {
+  map.forEach((value, key) => {
+    console.log('Reserve:', key.toString());
+    printReserveAllocationOverview(value);
+  });
+}
+
+export function printReserveAllocationOverview(reserveAllocationOverview: ReserveAllocationOverview) {
+  console.log('Reserve allocation overview:');
+  console.log('  Target weight:', reserveAllocationOverview.targetWeight.toString());
+  console.log('  Token allocation cap:', reserveAllocationOverview.tokenAllocationCap.toString());
+  console.log('  Ctoken allocation:', reserveAllocationOverview.ctokenAllocation.toString());
+}

package/src/classes/vault.ts

@@ -79,7 +79,7 @@ import {
   UserSharesForVault,
   WithdrawIxs,
 } from './types';
-import { collToLamportsDecimal } from '@kamino-finance/kliquidity-sdk';
+import { collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
 import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
 import { FarmState } from '@kamino-finance/farms-sdk/dist';
 import { getAccountsInLUT, initLookupTableIx } from './lut_utils';
@@ -338,7 +338,7 @@ export class KaminoVaultClient {
    * @param vault the vault to update
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
-   * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to batch multiple ixs in the same tx
+   * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
    * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
    */
   async updateVaultConfigIxs(
@@ -404,7 +404,7 @@ export class KaminoVaultClient {
     updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesAccountMetas);
     updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesLendingMarkets);
 
-    const updateLUTIxs = [];
+    const updateLUTIxs: TransactionInstruction[] = [];
 
     if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
       const newPubkey = new PublicKey(value);
@@ -450,7 +450,7 @@ export class KaminoVaultClient {
    * @param farm - the farm where the vault shares can be staked
    * @param [errorOnOverride] - if true, the function will throw an error if the vault already has a farm. If false, it will override the farm
    */
-  async setVaultFarm(
+  async setVaultFarmIxs(
     vault: KaminoVault,
     farm: PublicKey,
     errorOnOverride: boolean = true
@@ -529,7 +529,7 @@ export class KaminoVaultClient {
       (account) => !account.equals(vaultState.adminAuthority)
     );
 
-    const LUTIxs = [];
+    const LUTIxs: TransactionInstruction[] = [];
     const [initNewLUTIx, newLUT] = initLookupTableIx(vaultState.pendingAdmin, await this.getConnection().getSlot());
 
     const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(
@@ -648,7 +648,7 @@ export class KaminoVaultClient {
         const reserveState = reserveStates[index]!;
         const marketAddress = reserveState.lendingMarket;
 
-        return this.withdrawPendingFeesIxn(
+        return this.withdrawPendingFeesIx(
           vault,
           vaultState,
           marketAddress,
@@ -884,7 +884,7 @@ export class KaminoVaultClient {
     ]);
 
     const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
-    const withdrawFromAvailableIxn = await this.withdrawFromAvailableIxn(
+    const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(
       user,
       kaminoVault,
       vaultState,
@@ -980,7 +980,7 @@ export class KaminoVaultClient {
         sharesToWithdraw = reserveWithTokens.shares;
       }
 
-      const withdrawFromReserveIx = this.withdrawIxn(
+      const withdrawFromReserveIx = this.withdrawIx(
         user,
         vault,
         vaultState,
@@ -1005,7 +1005,7 @@ export class KaminoVaultClient {
    */
   async investAllReservesIxs(payer: PublicKey, vault: KaminoVault): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this.getConnection());
-    const allReserves = this.getAllVaultReserves(vaultState);
+    const allReserves = this.getVaultReserves(vaultState);
     if (allReserves.length === 0) {
       throw new Error('No reserves found for the vault, please select at least one reserve for the vault');
     }
@@ -1178,7 +1178,7 @@ export class KaminoVaultClient {
     return decodeVaultName(token);
   }
 
-  private withdrawIxn(
+  private withdrawIx(
     user: PublicKey,
     vault: KaminoVault,
     vaultState: VaultState,
@@ -1248,7 +1248,7 @@ export class KaminoVaultClient {
     return withdrawIxn;
   }
 
-  private async withdrawFromAvailableIxn(
+  private async withdrawFromAvailableIx(
     user: PublicKey,
     vault: KaminoVault,
     vaultState: VaultState,
@@ -1277,7 +1277,7 @@ export class KaminoVaultClient {
     return withdrawFromAvailable(withdrawFromAvailableArgs, withdrawFromAvailableAccounts, this._kaminoVaultProgramId);
   }
 
-  private async withdrawPendingFeesIxn(
+  private async withdrawPendingFeesIx(
     vault: KaminoVault,
     vaultState: VaultState,
     marketAddress: PublicKey,
@@ -1488,7 +1488,7 @@ export class KaminoVaultClient {
     const holdings = await this.getVaultHoldings(vaultState);
     const initialVaultAllocations = this.getVaultAllocations(vaultState);
 
-    const allReserves = this.getAllVaultReserves(vaultState);
+    const allReserves = this.getVaultReserves(vaultState);
 
     let totalAllocation = new Decimal(0);
     initialVaultAllocations.forEach((allocation) => {
@@ -1496,7 +1496,7 @@ export class KaminoVaultClient {
     });
     const expectedHoldingsDistribution = new PubkeyHashMap<PublicKey, Decimal>();
 
-    let totalLeftToInvest = holdings.total;
+    let totalLeftToInvest = holdings.totalAUMIncludingFees.sub(holdings.pendingFees);
     let currentAllocationSum = totalAllocation;
     const ZERO = new Decimal(0);
     while (totalLeftToInvest.gt(ZERO)) {
@@ -1671,8 +1671,9 @@ export class KaminoVaultClient {
     );
 
     const holdings = await this.getVaultHoldings(vaultState, slot, vaultReservesState);
+    const netAUM = holdings.totalAUMIncludingFees.sub(holdings.pendingFees);
 
-    return holdings.total.div(sharesDecimal);
+    return netAUM.div(sharesDecimal);
   }
 
   /**
@@ -1746,14 +1747,16 @@ export class KaminoVaultClient {
    * @returns vault amount supplied in reserve in decimal
    */
   getSuppliedInReserve(vaultState: VaultState, slot: number, reserve: KaminoReserve): Decimal {
-    const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(
-      slot,
-      new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
+    let referralFeeBps = 0;
+    const denominator = reserve.state.config.protocolTakeRatePct / 100;
+    if (denominator > 0) {
+      referralFeeBps = new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
         .toDecimal()
-        .div(reserve.state.config.protocolTakeRatePct / 100)
+        .div(denominator)
         .floor()
-        .toNumber()
-    );
+        .toNumber();
+    }
+    const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, referralFeeBps);
 
     const reserveAllocation = vaultState.vaultAllocationStrategy.find((allocation) =>
       allocation.reserve.equals(reserve.address)
@@ -1868,19 +1871,6 @@ export class KaminoVaultClient {
     return reserveAllocationAvailableLiquidityToWithdraw;
   }
 
-  /**
-   * This will get the list of all reserve pubkeys that the vault has allocations for
-   * @param vault - the vault state to load reserves for
-   * @returns a hashmap from each reserve pubkey to the reserve state
-   */
-  getAllVaultReserves(vault: VaultState): PublicKey[] {
-    return vault.vaultAllocationStrategy
-      .map((vaultAllocation) => vaultAllocation.reserve)
-      .filter((reserve) => {
-        return !reserve.equals(PublicKey.default);
-      });
-  }
-
   /**
    * This will get the list of all reserve pubkeys that the vault has allocations for ex
    * @param vault - the vault state to load reserves for
@@ -2012,20 +2002,24 @@ export class KaminoVaultClient {
    * @param vault - the kamino vault to get available liquidity to withdraw for
    * @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
+   * @param [currentSlot] - the latest confirmed slot. Optional. If provided the function will be  faster as it will not have to fetch the latest slot
    * @returns an VaultHoldings object representing the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve
    */
   async getVaultHoldings(
     vault: VaultState,
     slot?: number,
-    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>
+    vaultReserves?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    currentSlot?: number
   ): Promise<VaultHoldings> {
     const vaultHoldings: VaultHoldings = {
       available: new Decimal(vault.tokenAvailable.toString()),
       invested: new Decimal(0),
       investedInReserves: new PubkeyHashMap<PublicKey, Decimal>(),
-      total: new Decimal(0),
+      totalAUMIncludingFees: new Decimal(0),
+      pendingFees: new Decimal(0),
     };
 
+    const currentSlotToUse = currentSlot ? currentSlot : await this.getConnection().getSlot('confirmed');
     const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
     const decimals = new Decimal(vault.tokenMintDecimals.toString());
 
@@ -2040,6 +2034,7 @@ export class KaminoVaultClient {
       }
 
       let reserveCollExchangeRate: Decimal;
+
       if (slot) {
         reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, 0);
       } else {
@@ -2056,13 +2051,42 @@ export class KaminoVaultClient {
       );
     });
 
+    const currentPendingFees = new Fraction(vault.pendingFeesSf).toDecimal();
+    let totalPendingFees = currentPendingFees;
+
+    // if there is a slot passed and it is in the future we need to estimate the fees from current time until that moment
+    if (slot && slot > currentSlotToUse) {
+      const currentTimestampSec = new Date().getTime() / 1000;
+      const timeAtPassedSlot = currentTimestampSec + (slot - currentSlotToUse) * this.recentSlotDurationMs;
+      const timeUntilPassedSlot = timeAtPassedSlot - currentTimestampSec;
+
+      const managementFeeFactor = new Decimal(timeUntilPassedSlot)
+        .mul(new Decimal(vault.managementFeeBps.toString()))
+        .div(new Decimal(SECONDS_PER_YEAR))
+        .div(FullBPSDecimal);
+      const prevAUM = lamportsToDecimal(new Fraction(vault.prevAumSf).toDecimal(), vault.tokenMintDecimals.toNumber());
+      const simulatedMgmtFee = prevAUM.mul(managementFeeFactor);
+      totalPendingFees = totalPendingFees.add(simulatedMgmtFee);
+
+      const simulatedEarnedInterest = vaultHoldings.invested
+        .add(vaultHoldings.available)
+        .sub(prevAUM)
+        .sub(simulatedMgmtFee);
+      const simulatedPerformanceFee = simulatedEarnedInterest
+        .mul(new Decimal(vault.performanceFeeBps.toString()))
+        .div(FullBPSDecimal);
+      totalPendingFees = totalPendingFees.add(simulatedPerformanceFee);
+    }
+
     const totalAvailableDecimal = lamportsToDecimal(vaultHoldings.available, decimals);
     const totalInvestedDecimal = lamportsToDecimal(vaultHoldings.invested, decimals);
+    const pendingFees = lamportsToDecimal(totalPendingFees, decimals);
     return {
       available: totalAvailableDecimal,
       invested: totalInvestedDecimal,
       investedInReserves: vaultHoldings.investedInReserves,
-      total: totalAvailableDecimal.add(totalInvestedDecimal),
+      totalAUMIncludingFees: totalAvailableDecimal.add(totalInvestedDecimal),
+      pendingFees: pendingFees,
     };
   }
 
@@ -2092,7 +2116,8 @@ export class KaminoVaultClient {
       availableUSD: holdings.available.mul(price),
       investedUSD: holdings.invested.mul(price),
       investedInReservesUSD: investedInReservesUSD,
-      totalUSD: holdings.total.mul(price),
+      totalUSDIncludingFees: holdings.totalAUMIncludingFees.mul(price),
+      pendingFeesUSD: holdings.pendingFees.mul(price),
     };
   }
 
@@ -2212,6 +2237,7 @@ export class KaminoVaultClient {
     if (!totalInvested.isZero()) {
       utilizationRatio = totalBorrowed.div(totalInvested.add(totalAvailable));
     }
+
     return {
       totalInvested: totalInvested,
       totalBorrowed: totalBorrowed,
@@ -2245,11 +2271,13 @@ export class KaminoVaultClient {
       }
 
       const suppliedInReserve = this.getSuppliedInReserve(vault, slot, reserve);
+      const utilizationRatio = new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0));
       const reserveOverview: ReserveOverview = {
         supplyAPY: new Decimal(reserve.totalSupplyAPY(slot)),
-        utilizationRatio: new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0)),
+        utilizationRatio: utilizationRatio,
         liquidationThresholdPct: new Decimal(reserve.state.config.liquidationThresholdPct),
-        borrowedAmount: reserve.getBorrowedAmount(),
+        totalBorrowedAmount: reserve.getBorrowedAmount(),
+        amountBorrowedFromSupplied: suppliedInReserve.mul(utilizationRatio),
         market: reserve.state.lendingMarket,
         suppliedAmount: suppliedInReserve,
       };
@@ -2294,17 +2322,26 @@ export class KaminoVaultClient {
     if (totalWeights.isZero()) {
       return new Decimal(0);
     }
-    return totalAPY.div(totalWeights);
+
+    const grossAPY = totalAPY.div(totalWeights);
+    const netAPY = grossAPY
+      .mul(new Decimal(1).sub(new Decimal(vault.performanceFeeBps.toString()).div(FullBPSDecimal)))
+      .mul(new Decimal(1).sub(new Decimal(vault.managementFeeBps.toString()).div(FullBPSDecimal)));
+    return netAPY;
   }
 
   /**
-   * Retrive the total amount of interest earned by the vault since its inception, including what was charged as fees
+   * Retrive the total amount of interest earned by the vault since its inception, up to the last interaction with the vault on chain, including what was charged as fees
    * @param vaultState the kamino vault state to get total net yield for
-   * @returns a Decimal representing the net number of tokens earned by the vault since its inception
+   * @returns a struct containing a Decimal representing the net number of tokens earned by the vault since its inception and the timestamp of the last fee charge
    */
-  async getVaultCumulativeInterest(vaultState: VaultState): Promise<Decimal> {
+  async getVaultCumulativeInterest(vaultState: VaultState): Promise<VaultCumulativeInterestWithTimestamp> {
     const netYieldLamports = new Fraction(vaultState.cumulativeEarnedInterestSf).toDecimal();
-    return lamportsToDecimal(netYieldLamports, vaultState.tokenMintDecimals.toString());
+    const cumulativeInterest = lamportsToDecimal(netYieldLamports, vaultState.tokenMintDecimals.toString());
+    return {
+      cumulativeInterest: cumulativeInterest,
+      timestamp: vaultState.lastFeeChargeTimestamp.toNumber(),
+    };
   }
 
   /**
@@ -2319,24 +2356,23 @@ export class KaminoVaultClient {
     vaultState: VaultState,
     vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
     currentSlot?: number,
-    previousTotalAUM?: Decimal
+    previousNetAUM?: Decimal
   ): Promise<SimulatedVaultHoldingsWithEarnedInterest> {
     let prevAUM: Decimal;
+    let pendingFees = ZERO;
 
-    if (previousTotalAUM) {
-      prevAUM = previousTotalAUM;
+    if (previousNetAUM) {
+      prevAUM = previousNetAUM;
     } else {
-      const latestUpdateTs = vaultState.lastFeeChargeTimestamp.toNumber();
-      const lastUpdateSlot = latestUpdateTs / this.recentSlotDurationMs;
-
-      const lastUpdateHoldings = await this.getVaultHoldings(vaultState, lastUpdateSlot, vaultReservesMap);
-      prevAUM = lastUpdateHoldings.total;
+      const tokenDecimals = vaultState.tokenMintDecimals.toNumber();
+      prevAUM = lamportsToDecimal(new Fraction(vaultState.prevAumSf).toDecimal(), tokenDecimals);
+      pendingFees = lamportsToDecimal(new Fraction(vaultState.pendingFeesSf).toDecimal(), tokenDecimals);
     }
 
     const slot = currentSlot ? currentSlot : await this.getConnection().getSlot('confirmed');
 
     const currentHoldings = await this.getVaultHoldings(vaultState, slot, vaultReservesMap);
-    const earnedInterest = currentHoldings.total.sub(prevAUM);
+    const earnedInterest = currentHoldings.totalAUMIncludingFees.sub(prevAUM).sub(pendingFees);
 
     return {
       holdings: currentHoldings,
@@ -2505,9 +2541,13 @@ export type VaultHoldings = {
   available: Decimal;
   invested: Decimal;
   investedInReserves: PubkeyHashMap<PublicKey, Decimal>;
-  total: Decimal;
+  pendingFees: Decimal;
+  totalAUMIncludingFees: Decimal;
 };
 
+/**
+ * earnedInterest represents the interest earned from now until the slot provided in the future
+ */
 export type SimulatedVaultHoldingsWithEarnedInterest = {
   holdings: VaultHoldings;
   earnedInterest: Decimal;
@@ -2518,14 +2558,16 @@ export type VaultHoldingsWithUSDValue = {
   availableUSD: Decimal;
   investedUSD: Decimal;
   investedInReservesUSD: PubkeyHashMap<PublicKey, Decimal>;
-  totalUSD: Decimal;
+  totalUSDIncludingFees: Decimal;
+  pendingFeesUSD: Decimal;
 };
 
 export type ReserveOverview = {
   supplyAPY: Decimal;
   utilizationRatio: Decimal;
   liquidationThresholdPct: Decimal;
-  borrowedAmount: Decimal;
+  totalBorrowedAmount: Decimal;
+  amountBorrowedFromSupplied: Decimal;
   suppliedAmount: Decimal;
   market: PublicKey;
 };
@@ -2567,3 +2609,8 @@ export type VaultFees = {
   managementFee: Decimal;
   performanceFee: Decimal;
 };
+
+export type VaultCumulativeInterestWithTimestamp = {
+  cumulativeInterest: Decimal;
+  timestamp: number;
+};

package/src/client.ts

@@ -10,6 +10,8 @@ import {
   getProgramId,
   toJson,
   getAllObligationAccounts,
+  getAllReserveAccounts,
+  getAllLendingMarketAccounts,
 } from './lib';
 import * as fs from 'fs';
 import { Connection, GetProgramAccountsFilter, Keypair, PublicKey } from '@solana/web3.js';
@@ -54,6 +56,16 @@ async function main() {
       );
     });
 
+  commands
+    .command('print-all-lending-market-accounts')
+    .option(`--rpc <string>`, 'The RPC URL')
+    .action(async ({ rpc }) => {
+      const connection = new Connection(rpc, {});
+      for await (const lendingMarketAccount of getAllLendingMarketAccounts(connection)) {
+        console.log(toJson(lendingMarketAccount.toJSON()));
+      }
+    });
+
   commands
     .command('print-obligation')
     .option(`--rpc <string>`, 'The rpc url')
@@ -86,6 +98,16 @@ async function main() {
       await printReserve(connection, reserve, symbol);
     });
 
+  commands
+    .command('print-all-reserve-accounts')
+    .option(`--rpc <string>`, 'The RPC URL')
+    .action(async ({ rpc }) => {
+      const connection = new Connection(rpc, {});
+      for await (const reserveAccount of getAllReserveAccounts(connection)) {
+        console.log(toJson(reserveAccount.toJSON()));
+      }
+    });
+
   commands
     .command('deposit')
     .option(`--url <string>`, 'Custom RPC URL')

package/src/client_kamino_manager.ts

@@ -737,7 +737,7 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instructions = await kaminoManager.investAllReserves(env.payer.publicKey, kaminoVault);
+      const instructions = await kaminoManager.investAllReservesIxs(env.payer.publicKey, kaminoVault);
 
       for (let i = 0; i < instructions.length; i++) {
         const txInstructions: TransactionInstruction[] = [];
@@ -779,7 +779,7 @@ async function main() {
         state: reserveState,
       };
 
-      const instructions = await kaminoManager.investSingleReserve(
+      const instructions = await kaminoManager.investSingleReserveIxs(
         env.payer.publicKey,
         kaminoVault,
         reserveWithAddress
@@ -1349,7 +1349,7 @@ function parseReserveConfigFromFile(farmConfigFromFile: any): ReserveConfig {
     elevationGroups: farmConfigFromFile.elevationGroups,
     deleveragingThresholdDecreaseBpsPerDay: new BN(farmConfigFromFile.deleveragingThresholdDecreaseBpsPerDay),
     disableUsageAsCollOutsideEmode: farmConfigFromFile.disableUsageAsCollOutsideEmode,
-    utilizationLimitBlockBorrowingAbove: farmConfigFromFile.utilizationLimitBlockBorrowingAbove,
+    utilizationLimitBlockBorrowingAbovePct: farmConfigFromFile.utilizationLimitBlockBorrowingAbovePct,
     hostFixedInterestRateBps: farmConfigFromFile.hostFixedInterestRateBps,
     autodeleverageEnabled: farmConfigFromFile.autodeleverageEnabled,
     borrowLimitOutsideElevationGroup: new BN(farmConfigFromFile.borrowLimitOutsideElevationGroup),
@@ -1469,7 +1469,7 @@ function parseReserveConfigToFile(reserveConfig: ReserveConfig) {
     elevationGroups: reserveConfig.elevationGroups,
     deleveragingThresholdDecreaseBpsPerDay: reserveConfig.deleveragingThresholdDecreaseBpsPerDay.toString(),
     disableUsageAsCollOutsideEmode: reserveConfig.disableUsageAsCollOutsideEmode,
-    utilizationLimitBlockBorrowingAbove: reserveConfig.utilizationLimitBlockBorrowingAbove,
+    utilizationLimitBlockBorrowingAbovePct: reserveConfig.utilizationLimitBlockBorrowingAbovePct,
     hostFixedInterestRateBps: reserveConfig.hostFixedInterestRateBps,
     autodeleverageEnabled: reserveConfig.autodeleverageEnabled,
     borrowLimitOutsideElevationGroup: reserveConfig.borrowLimitOutsideElevationGroup.toString(),