@kamino-finance/klend-sdk 7.1.10 → 7.2.1

package/src/classes/vault.ts

@@ -7,7 +7,6 @@ import {
   Base58EncodedBytes,
   fetchEncodedAccount,
   generateKeyPairSigner,
-  GetAccountInfoApi,
   getAddressEncoder,
   getBase58Decoder,
   GetProgramAccountsDatasizeFilter,
@@ -78,6 +77,7 @@ import { PROGRAM_ID } from '../@codegen/klend/programId';
 import { ReserveWithAddress } from './reserve';
 import { Fraction } from './fraction';
 import {
+  CDN_ENDPOINT,
   createAtasIdempotent,
   createWsolAtaIfMissing,
   getAllStandardTokenProgramTokenAccounts,
@@ -107,12 +107,13 @@ import {
 } from './vault_types';
 import { batchFetch, collToLamportsDecimal, ZERO } from '@kamino-finance/kliquidity-sdk';
 import { FullBPSDecimal } from '@kamino-finance/kliquidity-sdk/dist/utils/CreationParameters';
-import { FarmIncentives, FarmState } from '@kamino-finance/farms-sdk/dist';
+import { FarmIncentives, FarmState, getUserStatePDA } from '@kamino-finance/farms-sdk/dist';
 import { getAccountsInLut, initLookupTableIx, insertIntoLookupTableIxs } from '../utils/lookupTable';
 import {
   getFarmStakeIxs,
   getFarmUnstakeAndWithdrawIxs,
   getSharesInFarmUserPosition,
+  getUserPendingRewardsInFarm,
   getUserSharesInTokensStakedInFarm,
 } from './farm_utils';
 import { getCreateAccountInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
@@ -173,6 +174,10 @@ export class KaminoVaultClient {
     return this._kaminoVaultProgramId;
   }
 
+  getRpc() {
+    return this._rpc;
+  }
+
   hasFarm() {
     return;
   }
@@ -191,7 +196,7 @@ export class KaminoVaultClient {
       return;
     }
 
-    const kaminoVault = new KaminoVault(vaultPubkey, vault, this._kaminoVaultProgramId);
+    const kaminoVault = KaminoVault.loadWithClientAndState(this, vaultPubkey, vault);
     const vaultName = this.decodeVaultName(vault.name);
     const slot = await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
     const tokensPerShare = await this.getTokensPerShareSingleVault(kaminoVault, slot);
@@ -203,7 +208,7 @@ export class KaminoVaultClient {
 
     console.log('Name: ', vaultName);
     console.log('Shares issued: ', sharesIssued);
-    printHoldings(holdings);
+    holdings.print();
     console.log('Tokens per share: ', tokensPerShare);
   }
 
@@ -408,7 +413,7 @@ export class KaminoVaultClient {
     reserveAllocationConfig: ReserveAllocationConfig,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<UpdateReserveAllocationIxs> {
-    const vaultState: VaultState = await vault.getState(this.getConnection());
+    const vaultState: VaultState = await vault.getState();
     const reserveState: Reserve = reserveAllocationConfig.getReserveState();
 
     const cTokenVault = await getCTokenVaultPda(
@@ -480,7 +485,7 @@ export class KaminoVaultClient {
     unallocatedWeight?: BN,
     unallocatedCap?: BN
   ) {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const unallocatedWeightToUse = unallocatedWeight ? unallocatedWeight : vaultState.unallocatedWeight;
     const unallocatedCapToUse = unallocatedCap ? unallocatedCap : vaultState.unallocatedTokensCap;
@@ -522,7 +527,7 @@ export class KaminoVaultClient {
     reserve: Address,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<WithdrawAndBlockReserveIxs> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some(
       (allocation) => allocation.reserve === reserve
@@ -570,7 +575,7 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     payer?: TransactionSigner
   ): Promise<WithdrawAndBlockReserveIxs> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const reserves = this.getVaultReserves(vaultState);
     const withdrawAndBlockReserveIxs: WithdrawAndBlockReserveIxs = {
@@ -613,7 +618,7 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     payer?: TransactionSigner
   ): Promise<DisinvestAllReservesIxs> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const reserves = this.getVaultReserves(vaultState);
     const disinvestAllReservesIxs: DisinvestAllReservesIxs = {
@@ -666,7 +671,7 @@ export class KaminoVaultClient {
     reserve: Address,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<Instruction | undefined> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
 
     const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some(
@@ -700,7 +705,7 @@ export class KaminoVaultClient {
     value: string,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<UpdateVaultConfigIxs> {
-    const vaultState: VaultState = await vault.getState(this.getConnection());
+    const vaultState: VaultState = await vault.getState();
     const admin = parseVaultAdmin(vaultState, vaultAdminAuthority);
 
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
@@ -802,7 +807,7 @@ export class KaminoVaultClient {
     errorOnOverride: boolean = true,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<UpdateVaultConfigIxs> {
-    const vaultHasFarm = await vault.hasFarm(this.getConnection());
+    const vaultHasFarm = await vault.hasFarm();
     if (vaultHasFarm && errorOnOverride) {
       throw new Error('Vault already has a farm, if you want to override it set errorOnOverride to false');
     }
@@ -868,7 +873,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     pendingAdmin?: TransactionSigner
   ): Promise<AcceptVaultOwnershipIxs> {
-    const vaultState: VaultState = await vault.getState(this.getConnection());
+    const vaultState: VaultState = await vault.getState();
     const signer = parseVaultPendingAdmin(vaultState, pendingAdmin);
 
     const acceptOwneshipAccounts: UpdateAdminAccounts = {
@@ -929,7 +934,7 @@ export class KaminoVaultClient {
     maxAmountToGiveUp: Decimal,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<Instruction> {
-    const vaultState: VaultState = await vault.getState(this.getConnection());
+    const vaultState: VaultState = await vault.getState();
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
 
     const giveUpPendingFeesAccounts: GiveUpPendingFeesAccounts = {
@@ -964,7 +969,7 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     vaultAdminAuthority?: TransactionSigner
   ): Promise<Instruction[]> {
-    const vaultState: VaultState = await vault.getState(this.getConnection());
+    const vaultState: VaultState = await vault.getState();
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
     const [{ ata: adminTokenAta, createAtaIx }] = await createAtasIdempotent(vaultAdmin, [
@@ -1057,7 +1062,7 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     farmState?: FarmState
   ): Promise<DepositIxs> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const tokenProgramID = vaultState.tokenProgram;
     const userTokenAta = await getAssociatedTokenAddress(vaultState.tokenMint, user.address, tokenProgramID);
@@ -1125,7 +1130,7 @@ export class KaminoVaultClient {
     };
 
     // if there is no farm, we can return the deposit instructions, otherwise include the stake ix in the response
-    if (!(await vault.hasFarm(this.getConnection()))) {
+    if (!(await vault.hasFarm())) {
       return depositIxs;
     }
 
@@ -1149,7 +1154,7 @@ export class KaminoVaultClient {
     sharesAmount?: Decimal,
     farmState?: FarmState
   ): Promise<Instruction[]> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     let sharesToStakeLamports = new Decimal(U64_MAX);
     if (sharesAmount) {
@@ -1157,7 +1162,7 @@ export class KaminoVaultClient {
     }
 
     // if tokens to be staked are 0 or vault has no farm there is no stake needed
-    if (sharesToStakeLamports.lte(0) || !(await vault.hasFarm(this.getConnection()))) {
+    if (sharesToStakeLamports.lte(0) || !(await vault.hasFarm())) {
       return [];
     }
 
@@ -1183,9 +1188,8 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     farmState?: FarmState
   ): Promise<WithdrawIxs> {
-    const vaultState = await vault.getState(this.getConnection());
-    const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
-    const hasFarm = await vault.hasFarm(this.getConnection());
+    const vaultState = await vault.getState();
+    const hasFarm = await vault.hasFarm();
 
     const withdrawIxs: WithdrawIxs = {
       unstakeFromFarmIfNeededIxs: [],
@@ -1226,7 +1230,7 @@ export class KaminoVaultClient {
 
     // if not enough shares in ATA unstake from farm
     const sharesInAtaAreEnoughForWithdraw = sharesToWithdraw.lte(userSharesAtaBalance);
-    if (hasFarm && !sharesInAtaAreEnoughForWithdraw) {
+    if (hasFarm && !sharesInAtaAreEnoughForWithdraw && userSharesInFarm.gt(0)) {
       // if we need to unstake we need to make sure share ata is created
       const [{ createAtaIx }] = await createAtasIdempotent(user, [
         {
@@ -1262,7 +1266,7 @@ export class KaminoVaultClient {
     if (vaultAllocation) {
       const withdrawFromVaultIxs = await this.withdrawWithReserveIxs(
         user,
-        kaminoVault,
+        vault,
         sharesToWithdraw,
         totalUserShares,
         slot,
@@ -1270,7 +1274,7 @@ export class KaminoVaultClient {
       );
       withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
     } else {
-      const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, kaminoVault, sharesToWithdraw);
+      const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, vault, sharesToWithdraw);
       withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
     }
 
@@ -1310,8 +1314,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     shareAmount: Decimal
   ): Promise<Instruction[]> {
-    const vaultState = await vault.getState(this.getConnection());
-    const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
+    const vaultState = await vault.getState();
 
     const userSharesAta = await getAssociatedTokenAddress(vaultState.sharesMint, user.address);
     const [{ ata: userTokenAta, createAtaIx }] = await createAtasIdempotent(user, [
@@ -1324,7 +1327,7 @@ export class KaminoVaultClient {
     const shareLamportsToWithdraw = collToLamportsDecimal(shareAmount, vaultState.sharesMintDecimals.toNumber());
     const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(
       user,
-      kaminoVault,
+      vault,
       vaultState,
       userSharesAta,
       userTokenAta,
@@ -1342,7 +1345,7 @@ export class KaminoVaultClient {
     slot: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>
   ): Promise<Instruction[]> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
     const userSharesAta = await getAssociatedTokenAddress(vaultState.sharesMint, user.address);
@@ -1408,7 +1411,7 @@ export class KaminoVaultClient {
             reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: new Decimal(U64_MAX.toString()) });
           } else {
             // round up to the nearest integer the shares to withdraw
-            const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).ceil();
+            const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).floor();
             reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
           }
 
@@ -1427,13 +1430,6 @@ export class KaminoVaultClient {
       }
       const marketAddress = reserveState.state.lendingMarket;
 
-      const isLastWithdraw = reserveIndex === reserveWithSharesAmountToWithdraw.length - 1;
-      // if it is not last withdraw it means that we can pass all shares as we are withdrawing everything from that reserve
-      let sharesToWithdraw = shareAmount;
-      if (isLastWithdraw) {
-        sharesToWithdraw = reserveWithTokens.shares;
-      }
-
       const withdrawFromReserveIx = await this.withdrawIx(
         user,
         vault,
@@ -1442,7 +1438,7 @@ export class KaminoVaultClient {
         { address: reserveWithTokens.reserve, state: reserveState.state },
         userSharesAta,
         userTokenAta,
-        sharesToWithdraw,
+        reserveWithTokens.shares,
         vaultReservesState
       );
       withdrawIxs.push(withdrawFromReserveIx);
@@ -1463,7 +1459,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     skipComputationChecks: boolean = false
   ): Promise<Instruction[]> {
-    const vaultState = await vault.reloadState(this.getConnection());
+    const vaultState = await vault.reloadState();
     const minInvestAmount = vaultState.minInvestAmount;
     const allReserves = this.getVaultReserves(vaultState);
     if (allReserves.length === 0) {
@@ -1576,7 +1572,7 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     createAtaIfNeeded: boolean = true
   ): Promise<Instruction[]> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
     const cTokenVault = await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const [lendingMarketAuth] = await lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId);
 
@@ -1784,7 +1780,7 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     vaultReservesMap?: Map<Address, KaminoReserve>
   ): Promise<SyncVaultLUTIxs> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
     const allAccountsToBeInserted = [
       vault.address,
       vaultState.vaultAdminAuthority,
@@ -1940,7 +1936,7 @@ export class KaminoVaultClient {
    * @returns - user share balance in tokens (not lamports)
    */
   async getUserSharesBalanceSingleVault(user: Address, vault: KaminoVault): Promise<UserSharesForVault> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const userShares: UserSharesForVault = {
       unstakedShares: new Decimal(0),
@@ -1964,7 +1960,7 @@ export class KaminoVaultClient {
       return acc;
     }, new Decimal(0));
 
-    if (await vault.hasFarm(this.getConnection())) {
+    if (await vault.hasFarm()) {
       const userSharesInFarm = await getUserSharesInTokensStakedInFarm(
         this.getConnection(),
         user,
@@ -2019,7 +2015,7 @@ export class KaminoVaultClient {
       });
       userSharesTokenAccountsPerVault.set(vault.address, userSharesTokenAccounts);
 
-      if (await vault.hasFarm(this.getConnection())) {
+      if (await vault.hasFarm()) {
         const userFarmState = allUserFarmStatesMap.get(state.vaultFarm);
         if (userFarmState) {
           console.log('there is a farm state for vault', vault.address);
@@ -2096,7 +2092,7 @@ export class KaminoVaultClient {
     currentSlot?: Slot
   ): Promise<Decimal> {
     // Determine if we have a KaminoVault or VaultState
-    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
+    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState() : vaultOrState;
 
     if (vaultState.sharesIssued.isZero()) {
       return new Decimal(0);
@@ -2203,7 +2199,7 @@ export class KaminoVaultClient {
         throw Error(`kaminoVault with pubkey ${kaminoVault.address} could not be decoded`);
       }
 
-      return new KaminoVault(kaminoVault.address, kaminoVaultAccount, this._kaminoVaultProgramId);
+      return KaminoVault.loadWithClientAndState(this, kaminoVault.address, kaminoVaultAccount);
     });
   }
 
@@ -2219,7 +2215,7 @@ export class KaminoVaultClient {
     const vaultStates = await batchFetch(vaults, (chunk) => this.getVaultsStates(chunk));
     return vaults.map((vault, index) => {
       const state = vaultStates[index];
-      return state ? new KaminoVault(vault, state, this._kaminoVaultProgramId) : null;
+      return state ? KaminoVault.loadWithClientAndState(this, vault, state) : null;
     });
   }
 
@@ -2325,7 +2321,7 @@ export class KaminoVaultClient {
     slot: Slot,
     vaultReservesMap: Map<Address, KaminoReserve>
   ): Promise<Map<Address, Decimal>> {
-    const vaultState = await vault.getState(this.getConnection());
+    const vaultState = await vault.getState();
 
     const reserveAllocationAvailableLiquidityToWithdraw = new Map<Address, Decimal>();
     vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
@@ -2572,13 +2568,13 @@ export class KaminoVaultClient {
     vaultReserves?: Map<Address, KaminoReserve>,
     currentSlot?: Slot
   ): Promise<VaultHoldings> {
-    const vaultHoldings: VaultHoldings = {
+    const vaultHoldings: VaultHoldings = new VaultHoldings({
       available: new Decimal(vault.tokenAvailable.toString()),
       invested: new Decimal(0),
       investedInReserves: new Map<Address, Decimal>(),
       totalAUMIncludingFees: new Decimal(0),
       pendingFees: new Decimal(0),
-    };
+    });
 
     const currentSlotToUse = currentSlot ?? (await this.getConnection().getSlot({ commitment: 'confirmed' }).send());
     const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
@@ -2643,13 +2639,13 @@ export class KaminoVaultClient {
     const totalAvailableDecimal = lamportsToDecimal(vaultHoldings.available, decimals);
     const totalInvestedDecimal = lamportsToDecimal(vaultHoldings.invested, decimals);
     const pendingFees = lamportsToDecimal(totalPendingFees, decimals);
-    return {
+    return new VaultHoldings({
       available: totalAvailableDecimal,
       invested: totalInvestedDecimal,
       investedInReserves: vaultHoldings.investedInReserves,
       totalAUMIncludingFees: totalAvailableDecimal.add(totalInvestedDecimal),
       pendingFees: pendingFees,
-    };
+    });
   }
 
   /**
@@ -2696,7 +2692,7 @@ export class KaminoVaultClient {
    * @returns an VaultOverview object with details about the tokens available and invested in the vault, denominated in tokens and USD, along sie APYs
    */
   async getVaultOverview(
-    vault: VaultState,
+    vault: KaminoVault,
     vaultTokenPrice: Decimal,
     slot?: Slot,
     vaultReservesMap?: Map<Address, KaminoReserve>,
@@ -2704,10 +2700,11 @@ export class KaminoVaultClient {
     currentSlot?: Slot,
     tokensPrices?: Map<Address, Decimal>
   ): Promise<VaultOverview> {
-    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
+    const vaultState = await vault.getState();
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
 
     const vaultHoldingsWithUSDValuePromise = this.getVaultHoldingsWithPrice(
-      vault,
+      vaultState,
       vaultTokenPrice,
       slot,
       vaultReservesState,
@@ -2717,15 +2714,20 @@ export class KaminoVaultClient {
     const slotForOverview = slot ? slot : await this.getConnection().getSlot().send();
     const farmsClient = new Farms(this.getConnection());
 
-    const vaultTheoreticalAPYPromise = this.getVaultTheoreticalAPY(vault, slotForOverview, vaultReservesState);
-    const vaultActualAPYPromise = this.getVaultActualAPY(vault, slotForOverview, vaultReservesState);
+    const vaultTheoreticalAPYPromise = this.getVaultTheoreticalAPY(vaultState, slotForOverview, vaultReservesState);
+    const vaultActualAPYPromise = this.getVaultActualAPY(vaultState, slotForOverview, vaultReservesState);
     const totalInvestedAndBorrowedPromise = this.getTotalBorrowedAndInvested(
-      vault,
+      vaultState,
       slotForOverview,
       vaultReservesState
     );
-    const vaultCollateralsPromise = this.getVaultCollaterals(vault, slotForOverview, vaultReservesState, kaminoMarkets);
-    const reservesOverviewPromise = this.getVaultReservesDetails(vault, slotForOverview, vaultReservesState);
+    const vaultCollateralsPromise = this.getVaultCollaterals(
+      vaultState,
+      slotForOverview,
+      vaultReservesState,
+      kaminoMarkets
+    );
+    const reservesOverviewPromise = this.getVaultReservesDetails(vaultState, slotForOverview, vaultReservesState);
     const vaultFarmIncentivesPromise = this.getVaultRewardsAPY(
       vault,
       vaultTokenPrice,
@@ -2741,6 +2743,13 @@ export class KaminoVaultClient {
       vaultReservesState,
       tokensPrices
     );
+    const vaultDelegatedFarmIncentivesPromise = this.getVaultDelegatedFarmRewardsAPY(
+      vault,
+      vaultTokenPrice,
+      farmsClient,
+      slotForOverview,
+      tokensPrices
+    );
 
     // all the async part of the functions above just read the vaultReservesState which is read beforehand, so excepting vaultCollateralsPromise they should do no additional network calls
     const [
@@ -2752,6 +2761,7 @@ export class KaminoVaultClient {
       reservesOverview,
       vaultFarmIncentives,
       vaultReservesFarmIncentives,
+      vaultDelegatedFarmIncentives,
     ] = await Promise.all([
       vaultHoldingsWithUSDValuePromise,
       vaultTheoreticalAPYPromise,
@@ -2761,6 +2771,7 @@ export class KaminoVaultClient {
       reservesOverviewPromise,
       vaultFarmIncentivesPromise,
       vaultReservesFarmIncentivesPromise,
+      vaultDelegatedFarmIncentivesPromise,
     ]);
 
     return {
@@ -2771,6 +2782,7 @@ export class KaminoVaultClient {
       theoreticalSupplyAPY: vaultTheoreticalAPYs,
       vaultFarmIncentives: vaultFarmIncentives,
       reservesFarmsIncentives: vaultReservesFarmIncentives,
+      delegatedFarmIncentives: vaultDelegatedFarmIncentives,
       totalBorrowed: totalInvestedAndBorrowed.totalBorrowed,
       totalBorrowedUSD: totalInvestedAndBorrowed.totalBorrowed.mul(vaultTokenPrice),
       utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
@@ -3080,11 +3092,64 @@ export class KaminoVaultClient {
     user: Address
   ): Promise<ProgramDerivedAddress> {
     return getProgramDerivedAddress({
-      seeds: [addressEncoder.encode(vault), addressEncoder.encode(reserve), addressEncoder.encode(user)],
+      seeds: [addressEncoder.encode(reserve), addressEncoder.encode(vault), addressEncoder.encode(user)],
       programAddress: farmsProgramId,
     });
   }
 
+  /**
+   * Compute the delegatee PDA for the user farm state for a vault delegate farm
+   * @param farmProgramID - the program ID of the farm program
+   * @param vault - the address of the vault
+   * @param farm - the address of the delegated farm
+   * @param user - the address of the user
+   * @returns the PDA of the delegatee user farm state for the delegated farm
+   */
+  async computeUserFarmStateDelegateePDAForUserInDelegatedVaultFarm(
+    farmProgramID: Address,
+    vault: Address,
+    farm: Address,
+    user: Address
+  ): Promise<ProgramDerivedAddress> {
+    return getProgramDerivedAddress({
+      seeds: [addressEncoder.encode(vault), addressEncoder.encode(farm), addressEncoder.encode(user)],
+      programAddress: farmProgramID,
+    });
+  }
+
+  /**
+   * Compute the user state PDA for a user in a delegated vault farm
+   * @param farmProgramID - the program ID of the farm program
+   * @param vault - the address of the vault
+   * @param farm - the address of the delegated farm
+   * @param user - the address of the user
+   * @returns the PDA of the user state for the delegated farm
+   */
+  async computeUserStatePDAForUserInDelegatedVaultFarm(
+    farmProgramID: Address,
+    vault: Address,
+    farm: Address,
+    user: Address
+  ): Promise<Address> {
+    const delegateePDA = await this.computeDelegateeForUserInDelegatedFarm(farmProgramID, vault, farm, user);
+    return getUserStatePDA(farmProgramID, farm, delegateePDA);
+  }
+
+  async computeDelegateeForUserInDelegatedFarm(
+    farmProgramID: Address,
+    vault: Address,
+    farm: Address,
+    user: Address
+  ): Promise<Address> {
+    const delegateePDA = await this.computeUserFarmStateDelegateePDAForUserInDelegatedVaultFarm(
+      farmProgramID,
+      vault,
+      farm,
+      user
+    );
+    return delegateePDA[0];
+  }
+
   /**
    * Read the APY of the farm built on top of the vault (farm in vaultState.vaultFarm)
    * @param vault - the vault to read the farm APY for
@@ -3101,7 +3166,7 @@ export class KaminoVaultClient {
     tokensPrices?: Map<Address, Decimal>
   ): Promise<FarmIncentives> {
     // Determine if we have a KaminoVault or VaultState
-    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
+    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState() : vaultOrState;
     if (vaultState.vaultFarm === DEFAULT_PUBLIC_KEY) {
       return {
         incentivesStats: [],
@@ -3117,6 +3182,39 @@ export class KaminoVaultClient {
     return getFarmIncentives(kFarmsClient, vaultState.vaultFarm, sharePrice, stakedTokenMintDecimals, tokensPrices);
   }
 
+  /**
+   * Read the APY of the delegated farm providing incentives for vault depositors
+   * @param vault - the vault to read the farm APY for
+   * @param vaultTokenPrice - the price of the vault token in USD (e.g. 1.0 for USDC)
+   * @param [farmsClient] - the farms client to use. Optional. If not provided, the function will create a new one
+   * @param [slot] - the slot to read the farm APY for. Optional. If not provided, the function will read the current slot
+   * @param [tokensPrices] - the prices of the tokens in USD. Optional. If not provided, the function will fetch the prices
+   * @returns the APY of the delegated farm providing incentives for vault depositors
+   */
+  async getVaultDelegatedFarmRewardsAPY(
+    vault: KaminoVault,
+    vaultTokenPrice: Decimal,
+    farmsClient?: Farms,
+    slot?: Slot,
+    tokensPrices?: Map<Address, Decimal>
+  ): Promise<FarmIncentives> {
+    const delegatedFarm = await this.getDelegatedFarmForVault(vault.address);
+    if (!delegatedFarm) {
+      return {
+        incentivesStats: [],
+        totalIncentivesApy: 0,
+      };
+    }
+
+    const vaultState = await vault.getState();
+    const tokensPerShare = await this.getTokensPerShareSingleVault(vaultState, slot);
+    const sharePrice = tokensPerShare.mul(vaultTokenPrice);
+    const stakedTokenMintDecimals = vaultState.sharesMintDecimals.toNumber();
+
+    const kFarmsClient = farmsClient ? farmsClient : new Farms(this.getConnection());
+    return getFarmIncentives(kFarmsClient, delegatedFarm, sharePrice, stakedTokenMintDecimals, tokensPrices);
+  }
+
   /**
    * Get all the token mints of the vault, vault farm rewards and the allocation  rewards
    * @param vaults - the vaults to get the token mints for
@@ -3137,9 +3235,9 @@ export class KaminoVaultClient {
     const reservesToFetch = new Set<Address>();
 
     for (const vault of vaults) {
-      const vaultState = await vault.getState(this.getConnection());
+      const vaultState = await vault.getState();
       vaultsTokenMints.add(vaultState.tokenMint);
-      const hasFarm = await vault.hasFarm(this.getConnection());
+      const hasFarm = await vault.hasFarm();
       if (hasFarm) {
         const farmAddress = vaultState.vaultFarm;
         if (!kFarmsMap.has(farmAddress)) {
@@ -3225,10 +3323,10 @@ export class KaminoVaultClient {
     vaultReservesMap?: Map<Address, KaminoReserve>,
     tokensPrices?: Map<Address, Decimal>
   ): Promise<VaultReservesFarmsIncentives> {
-    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState(this.getConnection()) : vaultOrState;
+    const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState() : vaultOrState;
 
     const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-    const currentSlot = slot ? slot : await this.getConnection().getSlot({ commitment: 'confirmed' }).send();
+    const currentSlot = slot ?? (await this.getConnection().getSlot({ commitment: 'confirmed' }).send());
 
     const holdings = await this.getVaultHoldings(vaultState, currentSlot, vaultReservesState);
 
@@ -3264,7 +3362,6 @@ export class KaminoVaultClient {
         kFarmsClient,
         currentSlot,
         reserveState.state,
-        undefined,
         tokensPrices
       );
       vaultReservesFarmsIncentives.set(reserveAddress, reserveFarmIncentives.collateralFarmIncentives);
@@ -3282,6 +3379,323 @@ export class KaminoVaultClient {
     };
   }
 
+  /// reads the pending rewards for a user in the vault farm
+  /// @param user - the user address
+  /// @param vault - the vault
+  /// @returns a map of the pending rewards token mint and amount in lamports
+  async getUserPendingRewardsInVaultFarm(user: Address, vault: KaminoVault): Promise<Map<Address, Decimal>> {
+    const vaultState = await vault.getState();
+    const hasFarm = await vault.hasFarm();
+    if (!hasFarm) {
+      return new Map<Address, Decimal>();
+    }
+
+    const farmClient = new Farms(this.getConnection());
+    const userState = await getUserStatePDA(farmClient.getProgramID(), vaultState.vaultFarm, user);
+    return getUserPendingRewardsInFarm(this.getConnection(), userState, vaultState.vaultFarm);
+  }
+
+  /// reads the pending rewards for a user in a delegated vault farm
+  /// @param user - the user address
+  /// @param vaultAddress - the address of the vault
+  /// @returns a map of the pending rewards token mint and amount in lamports
+  async getUserPendingRewardsInVaultDelegatedFarm(
+    user: Address,
+    vaultAddress: Address
+  ): Promise<Map<Address, Decimal>> {
+    const delegatedFarm = await this.getDelegatedFarmForVault(vaultAddress);
+    if (!delegatedFarm) {
+      return new Map<Address, Decimal>();
+    }
+
+    const farmClient = new Farms(this.getConnection());
+    const userState = await this.computeUserStatePDAForUserInDelegatedVaultFarm(
+      farmClient.getProgramID(),
+      vaultAddress,
+      delegatedFarm,
+      user
+    );
+
+    return getUserPendingRewardsInFarm(this.getConnection(), userState, delegatedFarm);
+  }
+
+  /// gets the delegated farm for a vault
+  async getDelegatedFarmForVault(vault: Address): Promise<Address | undefined> {
+    const response = await fetch(`${CDN_ENDPOINT}/resources.json`);
+    if (!response.ok) {
+      console.log(`Failed to fetch CDN for user pending rewards in vault delegated farm: ${response.statusText}`);
+      return undefined;
+    }
+    const data = (await response.json()) as { 'mainnet-beta'?: { delegatedVaultFarms: any } };
+    const delegatedVaultFarms = data['mainnet-beta']?.delegatedVaultFarms;
+    if (!delegatedVaultFarms) {
+      return undefined;
+    }
+    const delegatedFarmWithVault = delegatedVaultFarms.find((vaultWithFarm: any) => vaultWithFarm.vault === vault);
+    if (!delegatedFarmWithVault) {
+      return undefined;
+    }
+    return address(delegatedFarmWithVault.farm);
+  }
+
+  /// reads the pending rewards for a user in the reserves farms of a vault
+  /// @param user - the user address
+  /// @param vault - the vault
+  /// @param [vaultReservesMap] - the vault reserves map to get the reserves for; if not provided, the function will fetch the reserves
+  /// @returns a map of the pending rewards token mint and amount in lamports
+  async getUserPendingRewardsInVaultReservesFarms(
+    user: Address,
+    vault: KaminoVault,
+    vaultReservesMap?: Map<Address, KaminoReserve>
+  ): Promise<Map<Address, Decimal>> {
+    const vaultState = await vault.getState();
+
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+
+    const vaultReserves = vaultState.vaultAllocationStrategy
+      .map((allocationStrategy) => allocationStrategy.reserve)
+      .filter((reserve) => reserve !== DEFAULT_PUBLIC_KEY);
+    const pendingRewardsPerToken: Map<Address, Decimal> = new Map();
+
+    const farmClient = new Farms(this.getConnection());
+    for (const reserveAddress of vaultReserves) {
+      const reserveState = vaultReservesState.get(reserveAddress);
+      if (!reserveState) {
+        console.log(`Reserve to read farm incentives for not found: ${reserveAddress}`);
+        continue;
+      }
+
+      if (reserveState.state.farmCollateral === DEFAULT_PUBLIC_KEY) {
+        continue;
+      }
+
+      const delegatee = await this.computeUserFarmStateDelegateePDAForUserInVault(
+        farmClient.getProgramID(),
+        vault.address,
+        reserveAddress,
+        user
+      );
+      const userState = await getUserStatePDA(
+        farmClient.getProgramID(),
+        reserveState.state.farmCollateral,
+        delegatee[0]
+      );
+      const pendingRewards = await getUserPendingRewardsInFarm(
+        this.getConnection(),
+        userState,
+        reserveState.state.farmCollateral
+      );
+      pendingRewards.forEach((reward, token) => {
+        const existingReward = pendingRewardsPerToken.get(token);
+        if (existingReward) {
+          pendingRewardsPerToken.set(token, existingReward.add(reward));
+        } else {
+          pendingRewardsPerToken.set(token, reward);
+        }
+      });
+    }
+
+    return pendingRewardsPerToken;
+  }
+
+  /// reads the pending rewards for a user in the vault farm, the reserves farms of the vault and the delegated vault farm
+  /// @param user - the user address
+  /// @param vault - the vault
+  /// @param [vaultReservesMap] - the vault reserves map to get the reserves for; if not provided, the function will fetch the reserves
+  /// @returns a struct containing the pending rewards in the vault farm, the reserves farms of the vault and the delegated vault farm, and the total pending rewards in lamports
+  async getAllPendingRewardsForUserInVault(
+    user: Address,
+    vault: KaminoVault,
+    vaultReservesMap?: Map<Address, KaminoReserve>
+  ): Promise<PendingRewardsForUserInVault> {
+    const pendingRewardsInVaultFarm = await this.getUserPendingRewardsInVaultFarm(user, vault);
+    const pendingRewardsInVaultReservesFarms = await this.getUserPendingRewardsInVaultReservesFarms(
+      user,
+      vault,
+      vaultReservesMap
+    );
+    const pendingRewardsInVaultDelegatedFarm = await this.getUserPendingRewardsInVaultDelegatedFarm(
+      user,
+      vault.address
+    );
+
+    const totalPendingRewards = new Map<Address, Decimal>();
+    pendingRewardsInVaultFarm.forEach((reward, token) => {
+      const existingReward = totalPendingRewards.get(token);
+      if (existingReward) {
+        totalPendingRewards.set(token, existingReward.add(reward));
+      } else {
+        totalPendingRewards.set(token, reward);
+      }
+    });
+    pendingRewardsInVaultReservesFarms.forEach((reward, token) => {
+      const existingReward = totalPendingRewards.get(token);
+      if (existingReward) {
+        totalPendingRewards.set(token, existingReward.add(reward));
+      } else {
+        totalPendingRewards.set(token, reward);
+      }
+    });
+    pendingRewardsInVaultDelegatedFarm.forEach((reward, token) => {
+      const existingReward = totalPendingRewards.get(token);
+      if (existingReward) {
+        totalPendingRewards.set(token, existingReward.add(reward));
+      } else {
+        totalPendingRewards.set(token, reward);
+      }
+    });
+
+    return {
+      pendingRewardsInVaultFarm,
+      pendingRewardsInVaultReservesFarms,
+      pendingRewardsInVaultDelegatedFarm,
+      totalPendingRewards,
+    };
+  }
+
+  /**
+   * This function will return the instructions to claim the rewards for the farm of a vault, the delegated farm of the vault and the reserves farms of the vault
+   * @param user - the user to claim the rewards
+   * @param vault - the vault
+   * @param [vaultReservesMap] - the vault reserves map to get the reserves for; if not provided, the function will fetch the reserves
+   * @returns the instructions to claim the rewards for the farm of the vault, the delegated farm of the vault and the reserves farms of the vault
+   */
+  async getClaimAllRewardsForVaultIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    vaultReservesMap?: Map<Address, KaminoReserve>
+  ): Promise<Instruction[]> {
+    const [vaultFarmIxs, delegatedFarmIxs, reservesFarmsIxs] = await Promise.all([
+      this.getClaimVaultFarmRewardsIxs(user, vault),
+      this.getClaimVaultDelegatedFarmRewardsIxs(user, vault),
+      this.getClaimVaultReservesFarmsRewardsIxs(user, vault, vaultReservesMap),
+    ]);
+
+    return [...new Set([...vaultFarmIxs, ...delegatedFarmIxs, ...reservesFarmsIxs])];
+  }
+
+  /**
+   * This function will return the instructions to claim the rewards for the farm of a vault
+   * @param user - the user to claim the rewards
+   * @param vault - the vault
+   * @returns the instructions to claim the rewards for the farm of the vault
+   */
+  async getClaimVaultFarmRewardsIxs(user: TransactionSigner, vault: KaminoVault): Promise<Instruction[]> {
+    const vaultState = await vault.getState();
+    const hasFarm = await vault.hasFarm();
+    if (!hasFarm) {
+      return [];
+    }
+
+    const farmClient = new Farms(this.getConnection());
+    const pendingRewardsInVaultFarm = await this.getUserPendingRewardsInVaultFarm(user.address, vault);
+    // if there are no pending rewards of their total is 0 no ix is needed
+    const totalPendingRewards = Array.from(pendingRewardsInVaultFarm.values()).reduce(
+      (acc, reward) => acc.add(reward),
+      new Decimal(0)
+    );
+    if (totalPendingRewards.eq(0)) {
+      return [];
+    }
+    return farmClient.claimForUserForFarmAllRewardsIx(user, vaultState.vaultFarm, false);
+  }
+
+  /**
+   * This function will return the instructions to claim the rewards for the delegated farm of a vault
+   * @param user - the user to claim the rewards
+   * @param vault - the vault
+   * @returns the instructions to claim the rewards for the delegated farm of the vault
+   */
+  async getClaimVaultDelegatedFarmRewardsIxs(user: TransactionSigner, vault: KaminoVault): Promise<Instruction[]> {
+    const delegatedFarm = await this.getDelegatedFarmForVault(vault.address);
+    if (!delegatedFarm) {
+      return [];
+    }
+
+    const farmClient = new Farms(this.getConnection());
+
+    const delegatee = await this.computeDelegateeForUserInDelegatedFarm(
+      farmClient.getProgramID(),
+      vault.address,
+      delegatedFarm,
+      user.address
+    );
+    const userState = await getUserStatePDA(farmClient.getProgramID(), delegatedFarm, delegatee);
+    // check if the user state exists
+    const userStateExists = await fetchEncodedAccount(this.getConnection(), userState);
+    if (!userStateExists.exists) {
+      return [];
+    }
+
+    return farmClient.claimForUserForFarmAllRewardsIx(user, delegatedFarm, true, [delegatee]);
+  }
+
+  /**
+   * This function will return the instructions to claim the rewards for the reserves farms of a vault
+   * @param user - the user to claim the rewards
+   * @param vault - the vault
+   * @param [vaultReservesMap] - the vault reserves map to get the reserves for; if not provided, the function will fetch the reserves
+   * @returns the instructions to claim the rewards for the reserves farms of the vault
+   */
+  async getClaimVaultReservesFarmsRewardsIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    vaultReservesMap?: Map<Address, KaminoReserve>
+  ): Promise<Instruction[]> {
+    const vaultState = await vault.getState();
+
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+
+    const vaultReserves = vaultState.vaultAllocationStrategy
+      .map((allocationStrategy) => allocationStrategy.reserve)
+      .filter((reserve) => reserve !== DEFAULT_PUBLIC_KEY);
+
+    const ixs: Instruction[] = [];
+    const farmClient = new Farms(this.getConnection());
+    for (const reserveAddress of vaultReserves) {
+      const reserveState = vaultReservesState.get(reserveAddress);
+      if (!reserveState) {
+        console.log(`Reserve to read farm incentives for not found: ${reserveAddress}`);
+        continue;
+      }
+
+      if (reserveState.state.farmCollateral === DEFAULT_PUBLIC_KEY) {
+        continue;
+      }
+
+      const delegatee = await this.computeUserFarmStateDelegateePDAForUserInVault(
+        farmClient.getProgramID(),
+        vault.address,
+        reserveAddress,
+        user.address
+      );
+      const userState = await getUserStatePDA(
+        farmClient.getProgramID(),
+        reserveState.state.farmCollateral,
+        delegatee[0]
+      );
+
+      const pendingRewards = await getUserPendingRewardsInFarm(
+        this.getConnection(),
+        userState,
+        reserveState.state.farmCollateral
+      );
+      const totalPendingRewards = Array.from(pendingRewards.values()).reduce(
+        (acc, reward) => acc.add(reward),
+        new Decimal(0)
+      );
+      if (totalPendingRewards.eq(0)) {
+        continue;
+      }
+      const ix = await farmClient.claimForUserForFarmAllRewardsIx(user, reserveState.state.farmCollateral, true, [
+        delegatee[0],
+      ]);
+      ixs.push(...ix);
+    }
+
+    return ixs;
+  }
+
   private appendRemainingAccountsForVaultReserves(
     ix: Instruction,
     vaultReserves: Address[],
@@ -3310,16 +3724,33 @@ export class KaminoVault {
   readonly address: Address;
   state: VaultState | undefined | null;
   programId: Address;
+  client: KaminoVaultClient;
+  vaultReservesStateCache: Map<Address, KaminoReserve> | undefined;
 
-  constructor(vaultAddress: Address, state?: VaultState, programId: Address = kaminoVaultId) {
+  constructor(
+    rpc: Rpc<SolanaRpcApi>,
+    vaultAddress: Address,
+    state?: VaultState,
+    programId: Address = kaminoVaultId,
+    recentSlotDurationMs: number = DEFAULT_RECENT_SLOT_DURATION_MS
+  ) {
     this.address = vaultAddress;
     this.state = state;
     this.programId = programId;
+    this.client = new KaminoVaultClient(rpc, recentSlotDurationMs);
   }
 
-  async getState(rpc: Rpc<GetAccountInfoApi>): Promise<VaultState> {
+  static loadWithClientAndState(client: KaminoVaultClient, vaultAddress: Address, state: VaultState): KaminoVault {
+    const vault = new KaminoVault(client.getConnection(), vaultAddress);
+    vault.state = state;
+    vault.programId = client.getProgramID();
+    vault.client = client;
+    return vault;
+  }
+
+  async getState(): Promise<VaultState> {
     if (!this.state) {
-      const res = await VaultState.fetch(rpc, this.address, this.programId);
+      const res = await VaultState.fetch(this.client.getConnection(), this.address, this.programId);
       if (!res) {
         throw new Error('Invalid vault');
       }
@@ -3330,18 +3761,141 @@ export class KaminoVault {
     }
   }
 
-  async reloadState(rpc: Rpc<GetAccountInfoApi>): Promise<VaultState> {
-    this.state = await VaultState.fetch(rpc, this.address, this.programId);
+  async reloadVaultReserves(): Promise<void> {
+    this.vaultReservesStateCache = await this.client.loadVaultReserves(this.state!);
+  }
+
+  async reloadState(): Promise<VaultState> {
+    this.state = await VaultState.fetch(this.client.getConnection(), this.address, this.programId);
     if (!this.state) {
       throw new Error('Could not fetch vault');
     }
     return this.state;
   }
 
-  async hasFarm(rpc: Rpc<GetAccountInfoApi>): Promise<boolean> {
-    const state = await this.getState(rpc);
+  async hasFarm(): Promise<boolean> {
+    const state = await this.getState();
     return state.vaultFarm !== DEFAULT_PUBLIC_KEY;
   }
+
+  /**
+   * 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
+   * @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(): Promise<VaultHoldings> {
+    if (!this.state || !this.vaultReservesStateCache) {
+      await this.reloadState();
+      await this.reloadVaultReserves();
+    }
+
+    return await this.client.getVaultHoldings(this.state!, undefined, this.vaultReservesStateCache!, undefined);
+  }
+
+  /**
+   * This will return the a map between reserve pubkey and the allocation overview for the reserve
+   * @returns a map between reserve pubkey and the allocation overview for the reserve
+   */
+  async getVaultAllocations(): Promise<Map<Address, ReserveAllocationOverview>> {
+    if (!this.state) {
+      await this.reloadState();
+    }
+
+    return this.client.getVaultAllocations(this.state!);
+  }
+
+  /**
+   * This will return the APY of the vault based on the current invested amounts and the theoretical APY if all the available tokens were invested
+   * @returns a struct containing actualAPY and theoreticalAPY for the vault
+   */
+  async getAPYs(slot?: Slot): Promise<VaultAPYs> {
+    if (!this.state || !this.vaultReservesStateCache) {
+      await this.reloadState();
+      await this.reloadVaultReserves();
+    }
+
+    const latestSlot = slot ?? (await this.client.getConnection().getSlot({ commitment: 'confirmed' }).send());
+    const actualApy = await this.client.getVaultActualAPY(this.state!, latestSlot, this.vaultReservesStateCache!);
+    const theoreticalApy = await this.client.getVaultTheoreticalAPY(
+      this.state!,
+      latestSlot,
+      this.vaultReservesStateCache!
+    );
+
+    return {
+      actualAPY: actualApy,
+      theoreticalAPY: theoreticalApy,
+    };
+  }
+
+  /**
+   * This method returns the exchange rate of the vault (tokens per share)
+   * @returns - Decimal representing the exchange rate (tokens per share)
+   */
+  async getExchangeRate(slot?: Slot): Promise<Decimal> {
+    if (!this.state || !this.vaultReservesStateCache) {
+      await this.reloadState();
+      await this.reloadVaultReserves();
+    }
+
+    const latestSlot = slot ?? (await this.client.getConnection().getSlot({ commitment: 'confirmed' }).send());
+    const tokensPerShare = await this.client.getTokensPerShareSingleVault(this.state!, latestSlot);
+    return tokensPerShare;
+  }
+
+  /**
+   * This method returns the user shares balance for a given vault
+   * @param user - user to calculate the shares balance for
+   * @param vault - vault to calculate shares balance for
+   * @returns - a struct of user share balance (staked in vault farm if the vault has a farm and unstaked) in decimal (not lamports)
+   */
+  async getUserShares(user: Address): Promise<UserSharesForVault> {
+    return this.client.getUserSharesBalanceSingleVault(user, this);
+  }
+
+  /**
+   * This function creates instructions to deposit into a vault. It will also create ATA creation instructions for the vault shares that the user receives in return
+   * @param user - user to deposit
+   * @param tokenAmount - token amount to be deposited, in decimals (will be converted in lamports)
+   * @param [vaultReservesMap] - optional parameter; 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 [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
+   * @returns - an instance of DepositIxs which contains the instructions to deposit in vault and the instructions to stake the shares in the farm if the vault has a farm
+   */
+  async depositIxs(
+    user: TransactionSigner,
+    tokenAmount: Decimal,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<DepositIxs> {
+    if (vaultReservesMap) {
+      this.vaultReservesStateCache = vaultReservesMap;
+    }
+    return this.client.depositIxs(user, this, tokenAmount, this.vaultReservesStateCache, farmState);
+  }
+
+  /**
+   * This function will return the missing ATA creation instructions, as well as one or multiple withdraw instructions, based on how many reserves it's needed to withdraw from. This might have to be split in multiple transactions
+   * @param user - user to withdraw
+   * @param shareAmount - share amount to withdraw (in tokens, not lamports), in order to withdraw everything, any value > user share amount
+   * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+   * @param [vaultReservesMap] - 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 [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
+   * @returns an array of instructions to create missing ATAs if needed and the withdraw instructions
+   */
+  async withdrawIxs(
+    user: TransactionSigner,
+    shareAmount: Decimal,
+    slot?: Slot,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<WithdrawIxs> {
+    if (vaultReservesMap) {
+      this.vaultReservesStateCache = vaultReservesMap;
+    }
+
+    const currentSlot = slot ?? (await this.client.getConnection().getSlot({ commitment: 'confirmed' }).send());
+
+    return this.client.withdrawIxs(user, this, shareAmount, currentSlot, this.vaultReservesStateCache, farmState);
+  }
 }
 
 /**
@@ -3456,13 +4010,56 @@ export type VaultHolder = {
   amount: Decimal;
 };
 
-export type VaultHoldings = {
+export type APY = {
+  grossAPY: Decimal;
+  netAPY: Decimal;
+};
+
+export type VaultAPYs = {
+  theoreticalAPY: APY;
+  actualAPY: APY;
+};
+
+export class VaultHoldings {
   available: Decimal;
   invested: Decimal;
   investedInReserves: Map<Address, Decimal>;
   pendingFees: Decimal;
   totalAUMIncludingFees: Decimal;
-};
+
+  constructor(params: {
+    available: Decimal;
+    invested: Decimal;
+    investedInReserves: Map<Address, Decimal>;
+    pendingFees: Decimal;
+    totalAUMIncludingFees: Decimal;
+  }) {
+    this.available = params.available;
+    this.invested = params.invested;
+    this.investedInReserves = params.investedInReserves;
+    this.pendingFees = params.pendingFees;
+    this.totalAUMIncludingFees = params.totalAUMIncludingFees;
+  }
+
+  asJSON() {
+    return {
+      available: this.available.toString(),
+      invested: this.invested.toString(),
+      totalAUMIncludingFees: this.totalAUMIncludingFees.toString(),
+      pendingFees: this.pendingFees.toString(),
+      investedInReserves: pubkeyHashMapToJson(this.investedInReserves),
+    };
+  }
+
+  print() {
+    console.log('Holdings:');
+    console.log('  Available:', this.available.toString());
+    console.log('  Invested:', this.invested.toString());
+    console.log('  Total AUM including fees:', this.totalAUMIncludingFees.toString());
+    console.log('  Pending fees:', this.pendingFees.toString());
+    console.log('  Invested in reserves:', pubkeyHashMapToJson(this.investedInReserves));
+  }
+}
 
 /**
  * earnedInterest represents the interest earned from now until the slot provided in the future
@@ -3518,6 +4115,7 @@ export type VaultOverview = {
   actualSupplyAPY: APYs;
   vaultFarmIncentives: FarmIncentives;
   reservesFarmsIncentives: VaultReservesFarmsIncentives;
+  delegatedFarmIncentives: FarmIncentives;
   totalBorrowed: Decimal;
   totalBorrowedUSD: Decimal;
   totalSupplied: Decimal;
@@ -3545,11 +4143,9 @@ export type VaultCumulativeInterestWithTimestamp = {
   timestamp: number;
 };
 
-export function printHoldings(holdings: VaultHoldings) {
-  console.log('Holdings:');
-  console.log('  Available:', holdings.available.toString());
-  console.log('  Invested:', holdings.invested.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 type PendingRewardsForUserInVault = {
+  pendingRewardsInVaultFarm: Map<Address, Decimal>;
+  pendingRewardsInVaultDelegatedFarm: Map<Address, Decimal>;
+  pendingRewardsInVaultReservesFarms: Map<Address, Decimal>;
+  totalPendingRewards: Map<Address, Decimal>;
+};