@kamino-finance/klend-sdk 7.1.10 → 7.2.1

package/dist/classes/vault.js

@@ -3,10 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReserveAllocationConfig = exports.KaminoVaultConfig = exports.KaminoVault = exports.KaminoVaultClient = exports.INITIAL_DEPOSIT_LAMPORTS = exports.METADATA_PROGRAM_ID = exports.METADATA_SEED = exports.kaminoVaultStagingId = exports.kaminoVaultId = void 0;
+exports.VaultHoldings = exports.ReserveAllocationConfig = exports.KaminoVaultConfig = exports.KaminoVault = exports.KaminoVaultClient = exports.INITIAL_DEPOSIT_LAMPORTS = exports.METADATA_PROGRAM_ID = exports.METADATA_SEED = exports.kaminoVaultStagingId = exports.kaminoVaultId = void 0;
 exports.getCTokenVaultPda = getCTokenVaultPda;
 exports.getEventAuthorityPda = getEventAuthorityPda;
-exports.printHoldings = printHoldings;
 const bn_js_1 = __importDefault(require("bn.js"));
 const kit_1 = require("@solana/kit");
 const lib_1 = require("../lib");
@@ -67,6 +66,9 @@ class KaminoVaultClient {
     getProgramID() {
         return this._kaminoVaultProgramId;
     }
+    getRpc() {
+        return this._rpc;
+    }
     hasFarm() {
         return;
     }
@@ -82,7 +84,7 @@ class KaminoVaultClient {
             console.log(`Vault ${vaultPubkey.toString()} not found`);
             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);
@@ -90,7 +92,7 @@ class KaminoVaultClient {
         const sharesIssued = new decimal_js_1.default(vault.sharesIssued.toString()).div(new decimal_js_1.default(vault.sharesMintDecimals.toString()));
         console.log('Name: ', vaultName);
         console.log('Shares issued: ', sharesIssued);
-        printHoldings(holdings);
+        holdings.print();
         console.log('Tokens per share: ', tokensPerShare);
     }
     /**
@@ -224,7 +226,7 @@ class KaminoVaultClient {
      * @returns - a struct with an instruction to update the reserve allocation and an optional list of instructions to update the lookup table for the allocation changes
      */
     async updateReserveAllocationIxs(vault, reserveAllocationConfig, vaultAdminAuthority) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const reserveState = reserveAllocationConfig.getReserveState();
         const cTokenVault = await getCTokenVaultPda(vault.address, reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
         const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
@@ -267,7 +269,7 @@ class KaminoVaultClient {
      * @returns - a list of instructions to update the unallocated weight and cap
      */
     async updateVaultUnallocatedWeightAndCapIxs(vault, vaultAdminAuthority, unallocatedWeight, unallocatedCap) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const unallocatedWeightToUse = unallocatedWeight ? unallocatedWeight : vaultState.unallocatedWeight;
         const unallocatedCapToUse = unallocatedCap ? unallocatedCap : vaultState.unallocatedTokensCap;
         const ixs = [];
@@ -289,7 +291,7 @@ class KaminoVaultClient {
      * @returns - a struct with an instruction to update the reserve allocation and an optional list of instructions to update the lookup table for the allocation changes
      */
     async withdrawEverythingAndBlockInvestReserve(vault, reserve, vaultAdminAuthority) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve === reserve);
         const withdrawAndBlockReserveIxs = {
             updateReserveAllocationIxs: [],
@@ -323,7 +325,7 @@ class KaminoVaultClient {
      * @returns - a struct with an instruction to update the reserve allocations (set weight and ctoken allocation to 0) and an a list of instructions to disinvest the funds in the reserves
      */
     async withdrawEverythingFromAllReservesAndBlockInvest(vault, vaultReservesMap, payer) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const reserves = this.getVaultReserves(vaultState);
         const withdrawAndBlockReserveIxs = {
             updateReserveAllocationIxs: [],
@@ -355,7 +357,7 @@ class KaminoVaultClient {
      * @returns - a struct with an instruction to update the reserve allocations to 0 weight and a list of instructions to disinvest the funds in the reserves
      */
     async disinvestAllReservesIxs(vault, vaultReservesMap, payer) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const reserves = this.getVaultReserves(vaultState);
         const disinvestAllReservesIxs = {
             updateReserveAllocationIxs: [],
@@ -391,7 +393,7 @@ class KaminoVaultClient {
      * @returns - an instruction to remove the reserve from the vault allocation strategy or undefined if the reserve is not part of the allocation strategy
      */
     async removeReserveFromAllocationIx(vault, reserve, vaultAdminAuthority) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const reserveIsPartOfAllocation = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve === reserve);
         if (!reserveIsPartOfAllocation) {
@@ -413,7 +415,7 @@ class KaminoVaultClient {
      * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
      */
     async updateVaultConfigIxs(vault, mode, value, vaultAdminAuthority) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const admin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const updateVaultConfigAccs = {
             vaultAdminAuthority: admin,
@@ -479,7 +481,7 @@ class KaminoVaultClient {
      *
      */
     async setVaultFarmIxs(vault, farm, errorOnOverride = true, vaultAdminAuthority) {
-        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');
         }
@@ -528,7 +530,7 @@ class KaminoVaultClient {
      * @returns - an instruction to accept the ownership of the vault and a list of instructions to update the lookup table
      */
     async acceptVaultOwnershipIxs(vault, pendingAdmin) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const signer = parseVaultPendingAdmin(vaultState, pendingAdmin);
         const acceptOwneshipAccounts = {
             pendingAdmin: signer,
@@ -559,7 +561,7 @@ class KaminoVaultClient {
      * @returns - an instruction to give up the specified pending fees
      */
     async giveUpPendingFeesIx(vault, maxAmountToGiveUp, vaultAdminAuthority) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const giveUpPendingFeesAccounts = {
             vaultAdminAuthority: vaultAdmin,
@@ -582,7 +584,7 @@ class KaminoVaultClient {
      * @returns - list of instructions to withdraw all pending fees, including the ATA creation instructions if needed
      */
     async withdrawPendingFeesIxs(vault, slot, vaultReservesMap, vaultAdminAuthority) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
         const [{ ata: adminTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(vaultAdmin, [
@@ -640,7 +642,7 @@ class KaminoVaultClient {
      * @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, vault, tokenAmount, vaultReservesMap, farmState) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const tokenProgramID = vaultState.tokenProgram;
         const userTokenAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user.address, tokenProgramID);
         const createAtasIxs = [];
@@ -691,7 +693,7 @@ class KaminoVaultClient {
             stakeInFarmIfNeededIxs: [],
         };
         // 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;
         }
         // if there is a farm, stake the shares
@@ -708,13 +710,13 @@ class KaminoVaultClient {
      * @returns - a list of instructions for the user to stake shares into the vault's farm, including the creation of prerequisite accounts if needed
      */
     async stakeSharesIxs(user, vault, sharesAmount, farmState) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         let sharesToStakeLamports = new decimal_js_1.default(utils_2.U64_MAX);
         if (sharesAmount) {
             sharesToStakeLamports = (0, utils_1.numberToLamportsDecimal)(sharesAmount, vaultState.sharesMintDecimals.toNumber());
         }
         // 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 [];
         }
         // returns the ix to create the farm state account if needed and the ix to stake the shares
@@ -731,9 +733,8 @@ class KaminoVaultClient {
      * @returns an array of instructions to create missing ATAs if needed and the withdraw instructions
      */
     async withdrawIxs(user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState) {
-        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 = {
             unstakeFromFarmIfNeededIxs: [],
             withdrawIxs: [],
@@ -760,7 +761,7 @@ 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 (0, utils_2.createAtasIdempotent)(user, [
                 {
@@ -781,11 +782,11 @@ class KaminoVaultClient {
         // if the vault has allocations withdraw otherwise wtihdraw from available ix
         const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) => allocation.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
         if (vaultAllocation) {
-            const withdrawFromVaultIxs = await this.withdrawWithReserveIxs(user, kaminoVault, sharesToWithdraw, totalUserShares, slot, vaultReservesMap);
+            const withdrawFromVaultIxs = await this.withdrawWithReserveIxs(user, vault, sharesToWithdraw, totalUserShares, slot, vaultReservesMap);
             withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
         }
         else {
-            const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, kaminoVault, sharesToWithdraw);
+            const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, vault, sharesToWithdraw);
             withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
         }
         // if the vault is for SOL return the ix to unwrap the SOL
@@ -811,8 +812,7 @@ class KaminoVaultClient {
         return withdrawIxs;
     }
     async withdrawFromAvailableIxs(user, vault, shareAmount) {
-        const vaultState = await vault.getState(this.getConnection());
-        const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
+        const vaultState = await vault.getState();
         const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
         const [{ ata: userTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
             {
@@ -821,11 +821,11 @@ class KaminoVaultClient {
             },
         ]);
         const shareLamportsToWithdraw = (0, kliquidity_sdk_1.collToLamportsDecimal)(shareAmount, vaultState.sharesMintDecimals.toNumber());
-        const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(user, kaminoVault, vaultState, userSharesAta, userTokenAta, shareLamportsToWithdraw);
+        const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareLamportsToWithdraw);
         return [createAtaIx, withdrawFromAvailableIxn];
     }
     async withdrawWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
         const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
         const [{ ata: userTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
@@ -880,7 +880,7 @@ class KaminoVaultClient {
                     }
                     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 });
                     }
                     tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
@@ -896,13 +896,7 @@ class KaminoVaultClient {
                 throw new Error(`Reserve ${reserveWithTokens.reserve} not found in vault reserves map`);
             }
             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, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, sharesToWithdraw, vaultReservesState);
+            const withdrawFromReserveIx = await this.withdrawIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, reserveWithTokens.shares, vaultReservesState);
             withdrawIxs.push(withdrawFromReserveIx);
         }
         return withdrawIxs;
@@ -915,7 +909,7 @@ class KaminoVaultClient {
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
     async investAllReservesIxs(payer, vault, skipComputationChecks = false) {
-        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) {
@@ -999,7 +993,7 @@ class KaminoVaultClient {
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
     async investSingleReserveIxs(payer, vault, reserve, vaultReservesMap, createAtaIfNeeded = true) {
-        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 (0, utils_2.lendingMarketAuthPda)(reserve.state.lendingMarket, this._kaminoLendProgramId);
         const ixs = [];
@@ -1144,7 +1138,7 @@ class KaminoVaultClient {
      * @returns a struct that contains a list of ix to create the LUT and assign it to the vault if needed + a list of ixs to insert all the accounts in the LUT
      */
     async syncVaultLookupTableIxs(authority, vault, vaultReservesMap) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const allAccountsToBeInserted = [
             vault.address,
             vaultState.vaultAdminAuthority,
@@ -1260,7 +1254,7 @@ class KaminoVaultClient {
      * @returns - user share balance in tokens (not lamports)
      */
     async getUserSharesBalanceSingleVault(user, vault) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const userShares = {
             unstakedShares: new decimal_js_1.default(0),
             stakedShares: new decimal_js_1.default(0),
@@ -1280,7 +1274,7 @@ class KaminoVaultClient {
             }
             return acc;
         }, new decimal_js_1.default(0));
-        if (await vault.hasFarm(this.getConnection())) {
+        if (await vault.hasFarm()) {
             const userSharesInFarm = await (0, farm_utils_1.getUserSharesInTokensStakedInFarm)(this.getConnection(), user, vaultState.vaultFarm, vaultState.sharesMintDecimals.toNumber());
             userShares.stakedShares = userSharesInFarm;
         }
@@ -1317,7 +1311,7 @@ class KaminoVaultClient {
                 return mint === state.sharesMint;
             });
             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);
@@ -1386,7 +1380,7 @@ class KaminoVaultClient {
      */
     async getTokensPerShareSingleVault(vaultOrState, slot, vaultReservesMap, currentSlot) {
         // 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_js_1.default(0);
         }
@@ -1465,7 +1459,7 @@ class KaminoVaultClient {
             if (!kaminoVaultAccount) {
                 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);
         });
     }
     /**
@@ -1480,7 +1474,7 @@ class KaminoVaultClient {
         const vaultStates = await (0, kliquidity_sdk_1.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;
         });
     }
     async getVaultsStates(vaults) {
@@ -1557,7 +1551,7 @@ class KaminoVaultClient {
      * @returns an HashMap of reserves (key) with the amount available to withdraw for each (value)
      */
     async getReserveAllocationAvailableLiquidityToWithdraw(vault, slot, vaultReservesMap) {
-        const vaultState = await vault.getState(this.getConnection());
+        const vaultState = await vault.getState();
         const reserveAllocationAvailableLiquidityToWithdraw = new Map();
         vaultState.vaultAllocationStrategy.forEach((allocationStrategy) => {
             if (allocationStrategy.reserve === lib_1.DEFAULT_PUBLIC_KEY) {
@@ -1739,13 +1733,13 @@ class KaminoVaultClient {
      * @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, slot, vaultReserves, currentSlot) {
-        const vaultHoldings = {
+        const vaultHoldings = new VaultHoldings({
             available: new decimal_js_1.default(vault.tokenAvailable.toString()),
             invested: new decimal_js_1.default(0),
             investedInReserves: new Map(),
             totalAUMIncludingFees: new decimal_js_1.default(0),
             pendingFees: new decimal_js_1.default(0),
-        };
+        });
         const currentSlotToUse = currentSlot ?? (await this.getConnection().getSlot({ commitment: 'confirmed' }).send());
         const vaultReservesState = vaultReserves ? vaultReserves : await this.loadVaultReserves(vault);
         const decimals = new decimal_js_1.default(vault.tokenMintDecimals.toString());
@@ -1794,13 +1788,13 @@ class KaminoVaultClient {
         const totalAvailableDecimal = (0, lib_1.lamportsToDecimal)(vaultHoldings.available, decimals);
         const totalInvestedDecimal = (0, lib_1.lamportsToDecimal)(vaultHoldings.invested, decimals);
         const pendingFees = (0, lib_1.lamportsToDecimal)(totalPendingFees, decimals);
-        return {
+        return new VaultHoldings({
             available: totalAvailableDecimal,
             invested: totalInvestedDecimal,
             investedInReserves: vaultHoldings.investedInReserves,
             totalAUMIncludingFees: totalAvailableDecimal.add(totalInvestedDecimal),
             pendingFees: pendingFees,
-        };
+        });
     }
     /**
      * 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
@@ -1838,19 +1832,21 @@ 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, vaultTokenPrice, slot, vaultReservesMap, kaminoMarkets, currentSlot, tokensPrices) {
-        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vault);
-        const vaultHoldingsWithUSDValuePromise = this.getVaultHoldingsWithPrice(vault, vaultTokenPrice, slot, vaultReservesState, currentSlot);
+        const vaultState = await vault.getState();
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        const vaultHoldingsWithUSDValuePromise = this.getVaultHoldingsWithPrice(vaultState, vaultTokenPrice, slot, vaultReservesState, currentSlot);
         const slotForOverview = slot ? slot : await this.getConnection().getSlot().send();
         const farmsClient = new farms_sdk_1.Farms(this.getConnection());
-        const vaultTheoreticalAPYPromise = this.getVaultTheoreticalAPY(vault, slotForOverview, vaultReservesState);
-        const vaultActualAPYPromise = this.getVaultActualAPY(vault, slotForOverview, vaultReservesState);
-        const totalInvestedAndBorrowedPromise = this.getTotalBorrowedAndInvested(vault, slotForOverview, vaultReservesState);
-        const vaultCollateralsPromise = this.getVaultCollaterals(vault, slotForOverview, vaultReservesState, kaminoMarkets);
-        const reservesOverviewPromise = this.getVaultReservesDetails(vault, slotForOverview, vaultReservesState);
+        const vaultTheoreticalAPYPromise = this.getVaultTheoreticalAPY(vaultState, slotForOverview, vaultReservesState);
+        const vaultActualAPYPromise = this.getVaultActualAPY(vaultState, slotForOverview, vaultReservesState);
+        const totalInvestedAndBorrowedPromise = this.getTotalBorrowedAndInvested(vaultState, slotForOverview, vaultReservesState);
+        const vaultCollateralsPromise = this.getVaultCollaterals(vaultState, slotForOverview, vaultReservesState, kaminoMarkets);
+        const reservesOverviewPromise = this.getVaultReservesDetails(vaultState, slotForOverview, vaultReservesState);
         const vaultFarmIncentivesPromise = this.getVaultRewardsAPY(vault, vaultTokenPrice, farmsClient, slotForOverview, tokensPrices);
         const vaultReservesFarmIncentivesPromise = this.getVaultReservesFarmsIncentives(vault, vaultTokenPrice, farmsClient, slotForOverview, 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 [vaultHoldingsWithUSDValue, vaultTheoreticalAPYs, vaultActualAPYs, totalInvestedAndBorrowed, vaultCollaterals, reservesOverview, vaultFarmIncentives, vaultReservesFarmIncentives,] = await Promise.all([
+        const [vaultHoldingsWithUSDValue, vaultTheoreticalAPYs, vaultActualAPYs, totalInvestedAndBorrowed, vaultCollaterals, reservesOverview, vaultFarmIncentives, vaultReservesFarmIncentives, vaultDelegatedFarmIncentives,] = await Promise.all([
             vaultHoldingsWithUSDValuePromise,
             vaultTheoreticalAPYPromise,
             vaultActualAPYPromise,
@@ -1859,6 +1855,7 @@ class KaminoVaultClient {
             reservesOverviewPromise,
             vaultFarmIncentivesPromise,
             vaultReservesFarmIncentivesPromise,
+            vaultDelegatedFarmIncentivesPromise,
         ]);
         return {
             holdingsUSD: vaultHoldingsWithUSDValue,
@@ -1868,6 +1865,7 @@ class KaminoVaultClient {
             theoreticalSupplyAPY: vaultTheoreticalAPYs,
             vaultFarmIncentives: vaultFarmIncentives,
             reservesFarmsIncentives: vaultReservesFarmIncentives,
+            delegatedFarmIncentives: vaultDelegatedFarmIncentives,
             totalBorrowed: totalInvestedAndBorrowed.totalBorrowed,
             totalBorrowedUSD: totalInvestedAndBorrowed.totalBorrowed.mul(vaultTokenPrice),
             utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
@@ -2098,10 +2096,40 @@ class KaminoVaultClient {
      */
     computeUserFarmStateDelegateePDAForUserInVault(farmsProgramId, vault, reserve, user) {
         return (0, kit_1.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, vault, farm, user) {
+        return (0, kit_1.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, vault, farm, user) {
+        const delegateePDA = await this.computeDelegateeForUserInDelegatedFarm(farmProgramID, vault, farm, user);
+        return (0, dist_1.getUserStatePDA)(farmProgramID, farm, delegateePDA);
+    }
+    async computeDelegateeForUserInDelegatedFarm(farmProgramID, vault, farm, user) {
+        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
@@ -2112,7 +2140,7 @@ class KaminoVaultClient {
      */
     async getVaultRewardsAPY(vaultOrState, vaultTokenPrice, farmsClient, slot, tokensPrices) {
         // 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 === lib_1.DEFAULT_PUBLIC_KEY) {
             return {
                 incentivesStats: [],
@@ -2125,6 +2153,30 @@ class KaminoVaultClient {
         const kFarmsClient = farmsClient ? farmsClient : new farms_sdk_1.Farms(this.getConnection());
         return (0, apy_1.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, vaultTokenPrice, farmsClient, slot, tokensPrices) {
+        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_sdk_1.Farms(this.getConnection());
+        return (0, apy_1.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
@@ -2138,9 +2190,9 @@ class KaminoVaultClient {
         const farmsToFetch = new Set();
         const reservesToFetch = new Set();
         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)) {
@@ -2216,9 +2268,9 @@ class KaminoVaultClient {
         return vaultsTokenMints;
     }
     async getVaultReservesFarmsIncentives(vaultOrState, vaultTokenPrice, farmsClient, slot, vaultReservesMap, tokensPrices) {
-        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);
         const vaultReservesAddresses = vaultState.vaultAllocationStrategy.map((allocationStrategy) => allocationStrategy.reserve);
         const vaultReservesFarmsIncentives = new Map();
@@ -2237,7 +2289,7 @@ class KaminoVaultClient {
                 });
                 continue;
             }
-            const reserveFarmIncentives = await (0, farmUtils_1.getReserveFarmRewardsAPY)(this._rpc, this.recentSlotDurationMs, reserveAddress, vaultTokenPrice, this._kaminoLendProgramId, kFarmsClient, currentSlot, reserveState.state, undefined, tokensPrices);
+            const reserveFarmIncentives = await (0, farmUtils_1.getReserveFarmRewardsAPY)(this._rpc, this.recentSlotDurationMs, reserveAddress, vaultTokenPrice, this._kaminoLendProgramId, kFarmsClient, currentSlot, reserveState.state, tokensPrices);
             vaultReservesFarmsIncentives.set(reserveAddress, reserveFarmIncentives.collateralFarmIncentives);
             const investedInReserve = holdings.investedInReserves.get(reserveAddress);
             const weightedReserveAPY = new decimal_js_1.default(reserveFarmIncentives.collateralFarmIncentives.totalIncentivesApy)
@@ -2250,6 +2302,227 @@ class KaminoVaultClient {
             totalIncentivesAPY: totalIncentivesApy,
         };
     }
+    /// 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, vault) {
+        const vaultState = await vault.getState();
+        const hasFarm = await vault.hasFarm();
+        if (!hasFarm) {
+            return new Map();
+        }
+        const farmClient = new farms_sdk_1.Farms(this.getConnection());
+        const userState = await (0, dist_1.getUserStatePDA)(farmClient.getProgramID(), vaultState.vaultFarm, user);
+        return (0, farm_utils_1.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, vaultAddress) {
+        const delegatedFarm = await this.getDelegatedFarmForVault(vaultAddress);
+        if (!delegatedFarm) {
+            return new Map();
+        }
+        const farmClient = new farms_sdk_1.Farms(this.getConnection());
+        const userState = await this.computeUserStatePDAForUserInDelegatedVaultFarm(farmClient.getProgramID(), vaultAddress, delegatedFarm, user);
+        return (0, farm_utils_1.getUserPendingRewardsInFarm)(this.getConnection(), userState, delegatedFarm);
+    }
+    /// gets the delegated farm for a vault
+    async getDelegatedFarmForVault(vault) {
+        const response = await fetch(`${utils_2.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());
+        const delegatedVaultFarms = data['mainnet-beta']?.delegatedVaultFarms;
+        if (!delegatedVaultFarms) {
+            return undefined;
+        }
+        const delegatedFarmWithVault = delegatedVaultFarms.find((vaultWithFarm) => vaultWithFarm.vault === vault);
+        if (!delegatedFarmWithVault) {
+            return undefined;
+        }
+        return (0, kit_1.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, vault, vaultReservesMap) {
+        const vaultState = await vault.getState();
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        const vaultReserves = vaultState.vaultAllocationStrategy
+            .map((allocationStrategy) => allocationStrategy.reserve)
+            .filter((reserve) => reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+        const pendingRewardsPerToken = new Map();
+        const farmClient = new farms_sdk_1.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 === lib_1.DEFAULT_PUBLIC_KEY) {
+                continue;
+            }
+            const delegatee = await this.computeUserFarmStateDelegateePDAForUserInVault(farmClient.getProgramID(), vault.address, reserveAddress, user);
+            const userState = await (0, dist_1.getUserStatePDA)(farmClient.getProgramID(), reserveState.state.farmCollateral, delegatee[0]);
+            const pendingRewards = await (0, farm_utils_1.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, vault, vaultReservesMap) {
+        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();
+        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, vault, vaultReservesMap) {
+        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, vault) {
+        const vaultState = await vault.getState();
+        const hasFarm = await vault.hasFarm();
+        if (!hasFarm) {
+            return [];
+        }
+        const farmClient = new farms_sdk_1.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_js_1.default(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, vault) {
+        const delegatedFarm = await this.getDelegatedFarmForVault(vault.address);
+        if (!delegatedFarm) {
+            return [];
+        }
+        const farmClient = new farms_sdk_1.Farms(this.getConnection());
+        const delegatee = await this.computeDelegateeForUserInDelegatedFarm(farmClient.getProgramID(), vault.address, delegatedFarm, user.address);
+        const userState = await (0, dist_1.getUserStatePDA)(farmClient.getProgramID(), delegatedFarm, delegatee);
+        // check if the user state exists
+        const userStateExists = await (0, kit_1.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, vault, vaultReservesMap) {
+        const vaultState = await vault.getState();
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        const vaultReserves = vaultState.vaultAllocationStrategy
+            .map((allocationStrategy) => allocationStrategy.reserve)
+            .filter((reserve) => reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+        const ixs = [];
+        const farmClient = new farms_sdk_1.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 === lib_1.DEFAULT_PUBLIC_KEY) {
+                continue;
+            }
+            const delegatee = await this.computeUserFarmStateDelegateePDAForUserInVault(farmClient.getProgramID(), vault.address, reserveAddress, user.address);
+            const userState = await (0, dist_1.getUserStatePDA)(farmClient.getProgramID(), reserveState.state.farmCollateral, delegatee[0]);
+            const pendingRewards = await (0, farm_utils_1.getUserPendingRewardsInFarm)(this.getConnection(), userState, reserveState.state.farmCollateral);
+            const totalPendingRewards = Array.from(pendingRewards.values()).reduce((acc, reward) => acc.add(reward), new decimal_js_1.default(0));
+            if (totalPendingRewards.eq(0)) {
+                continue;
+            }
+            const ix = await farmClient.claimForUserForFarmAllRewardsIx(user, reserveState.state.farmCollateral, true, [
+                delegatee[0],
+            ]);
+            ixs.push(...ix);
+        }
+        return ixs;
+    }
     appendRemainingAccountsForVaultReserves(ix, vaultReserves, vaultReservesState) {
         let vaultReservesAccountMetas = [];
         let vaultReservesLendingMarkets = [];
@@ -2274,14 +2547,24 @@ class KaminoVault {
     address;
     state;
     programId;
-    constructor(vaultAddress, state, programId = exports.kaminoVaultId) {
+    client;
+    vaultReservesStateCache;
+    constructor(rpc, vaultAddress, state, programId = exports.kaminoVaultId, recentSlotDurationMs = lib_1.DEFAULT_RECENT_SLOT_DURATION_MS) {
         this.address = vaultAddress;
         this.state = state;
         this.programId = programId;
+        this.client = new KaminoVaultClient(rpc, recentSlotDurationMs);
+    }
+    static loadWithClientAndState(client, vaultAddress, state) {
+        const vault = new KaminoVault(client.getConnection(), vaultAddress);
+        vault.state = state;
+        vault.programId = client.getProgramID();
+        vault.client = client;
+        return vault;
     }
-    async getState(rpc) {
+    async getState() {
         if (!this.state) {
-            const res = await accounts_1.VaultState.fetch(rpc, this.address, this.programId);
+            const res = await accounts_1.VaultState.fetch(this.client.getConnection(), this.address, this.programId);
             if (!res) {
                 throw new Error('Invalid vault');
             }
@@ -2292,17 +2575,110 @@ class KaminoVault {
             return this.state;
         }
     }
-    async reloadState(rpc) {
-        this.state = await accounts_1.VaultState.fetch(rpc, this.address, this.programId);
+    async reloadVaultReserves() {
+        this.vaultReservesStateCache = await this.client.loadVaultReserves(this.state);
+    }
+    async reloadState() {
+        this.state = await accounts_1.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) {
-        const state = await this.getState(rpc);
+    async hasFarm() {
+        const state = await this.getState();
         return state.vaultFarm !== lib_1.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() {
+        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() {
+        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) {
+        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) {
+        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) {
+        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, tokenAmount, vaultReservesMap, farmState) {
+        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, shareAmount, slot, vaultReservesMap, farmState) {
+        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);
+    }
 }
 exports.KaminoVault = KaminoVault;
 /**
@@ -2385,12 +2761,36 @@ function parseVaultAdmin(vault, signer) {
 function parseVaultPendingAdmin(vault, signer) {
     return signer ?? (0, signer_1.noopSigner)(vault.pendingAdmin);
 }
-function printHoldings(holdings) {
-    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:', (0, utils_1.pubkeyHashMapToJson)(holdings.investedInReserves));
+class VaultHoldings {
+    available;
+    invested;
+    investedInReserves;
+    pendingFees;
+    totalAUMIncludingFees;
+    constructor(params) {
+        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: (0, utils_1.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:', (0, utils_1.pubkeyHashMapToJson)(this.investedInReserves));
+    }
 }
+exports.VaultHoldings = VaultHoldings;
 //# sourceMappingURL=vault.js.map