@kamino-finance/klend-sdk 7.2.6 → 7.3.1

package/dist/classes/vault.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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.getKvaultGlobalConfigPda = getKvaultGlobalConfigPda;
+exports.getReserveWhitelistEntryPda = getReserveWhitelistEntryPda;
 const bn_js_1 = __importDefault(require("bn.js"));
 const kit_1 = require("@solana/kit");
 const lib_1 = require("../lib");
@@ -42,6 +44,8 @@ const BASE_VAULT_AUTHORITY_SEED = 'authority';
 const SHARES_SEED = 'shares';
 const EVENT_AUTHORITY_SEED = '__event_authority';
 exports.METADATA_SEED = 'metadata';
+const GLOBAL_CONFIG_STATE_SEED = 'global_config';
+const WHITELISTED_RESERVES_SEED = 'whitelisted_reserves';
 exports.METADATA_PROGRAM_ID = (0, kit_1.address)('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
 exports.INITIAL_DEPOSIT_LAMPORTS = 1000;
 const addressEncoder = (0, kit_1.getAddressEncoder)();
@@ -95,6 +99,23 @@ class KaminoVaultClient {
         holdings.print();
         console.log('Tokens per share: ', tokensPerShare);
     }
+    /**
+     * This method initializes the kvault global config (one off, needs to be signed by program owner)
+     * @param admin - the admin of the kvault program
+     * @returns - an instruction to initialize the kvault global config
+     */
+    async initKvaultGlobalConfigIx(admin) {
+        const globalConfigAddress = await getKvaultGlobalConfigPda(this.getProgramID());
+        const programData = await (0, utils_2.programDataPda)(this.getProgramID());
+        const ix = (0, instructions_1.initKVaultGlobalConfig)({
+            payer: admin,
+            globalConfig: globalConfigAddress,
+            programData: programData,
+            systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
+            rent: sysvars_1.SYSVAR_RENT_ADDRESS,
+        }, undefined, this.getProgramID());
+        return ix;
+    }
     /**
      * This method will create a vault with a given config. The config can be changed later on, but it is recommended to set it up correctly from the start
      * @param vaultConfig - the config object used to create a vault
@@ -174,21 +195,21 @@ class KaminoVaultClient {
             farm_utils_1.FARMS_GLOBAL_CONFIG_MAINNET,
         ];
         const insertIntoLUTIxs = await (0, lookupTable_1.insertIntoLookupTableIxs)(this.getConnection(), vaultConfig.admin, lut, accountsToBeInserted, []);
-        const setLUTIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.LookupTable(), lut.toString());
+        const setLUTIx = await this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.LookupTable(), lut.toString());
         const ixs = [createVaultIx, initVaultIx, setLUTIx];
         if (vaultConfig.getPerformanceFeeBps() > 0) {
-            const setPerformanceFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.PerformanceFeeBps(), vaultConfig.getPerformanceFeeBps().toString());
+            const setPerformanceFeeIx = await this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.PerformanceFeeBps(), vaultConfig.getPerformanceFeeBps().toString());
             ixs.push(setPerformanceFeeIx);
         }
         if (vaultConfig.getManagementFeeBps() > 0) {
-            const setManagementFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.ManagementFeeBps(), vaultConfig.getManagementFeeBps().toString());
+            const setManagementFeeIx = await this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.ManagementFeeBps(), vaultConfig.getManagementFeeBps().toString());
             ixs.push(setManagementFeeIx);
         }
         if (vaultConfig.name && vaultConfig.name.length > 0) {
-            const setNameIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.Name(), vaultConfig.name);
+            const setNameIx = await this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.Name(), vaultConfig.name);
             ixs.push(setNameIx);
         }
-        const setFarmIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.Farm(), createVaultFarm.farm.address);
+        const setFarmIx = await this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.address, new types_1.VaultConfigField.Farm(), createVaultFarm.farm.address);
         const metadataIx = await this.getSetSharesMetadataIx(this.getConnection(), vaultConfig.admin, vaultState.address, sharesMint, baseVaultAuthority, vaultConfig.vaultTokenSymbol, vaultConfig.vaultTokenName);
         return {
             vault: vaultState,
@@ -254,6 +275,7 @@ class KaminoVaultClient {
         const vaultState = await vault.getState();
         const reserveState = reserveAllocationConfig.getReserveState();
         const cTokenVault = await getCTokenVaultPda(vault.address, reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
+        const reserveWhitelistEntryOption = await getReserveWhitelistEntryIfExists(reserveAllocationConfig.getReserveAddress(), this.getConnection(), this._kaminoVaultProgramId);
         const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
         const updateReserveAllocationAccounts = {
             signer: vaultAdmin,
@@ -262,6 +284,7 @@ class KaminoVaultClient {
             reserveCollateralMint: reserveState.collateral.mintPubkey,
             reserve: reserveAllocationConfig.getReserveAddress(),
             ctokenVault: cTokenVault,
+            reserveWhitelistEntry: reserveWhitelistEntryOption,
             systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
             rent: sysvars_1.SYSVAR_RENT_ADDRESS,
             reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
@@ -436,41 +459,26 @@ class KaminoVaultClient {
      * @param vault the vault to update
      * @param mode the field to update (based on VaultConfigFieldKind enum)
      * @param value the value to update the field with
-     * @param [vaultAdminAuthority] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
+     * @param [adminAuthority] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx.
+     *        The global admin should be passed in when wanting to change the AllowAllocationsInWhitelistedReservesOnly or AllowInvestInWhitelistedReservesOnly fields to false
      * @param [lutIxsSigner] the signer of the transaction to be used for the lookup table instructions. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
      * @param [skipLutUpdate] if true, the lookup table instructions will not be included in the returned instructions
      * @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, lutIxsSigner, skipLutUpdate = false) {
+    async updateVaultConfigIxs(vault, mode, value, adminAuthority, lutIxsSigner, skipLutUpdate = false) {
         const vaultState = await vault.getState();
-        const admin = parseVaultAdmin(vaultState, vaultAdminAuthority);
+        const admin = parseVaultAdmin(vaultState, adminAuthority);
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
         const updateVaultConfigAccs = {
-            vaultAdminAuthority: admin,
+            signer: admin,
+            globalConfig: globalConfig,
             vaultState: vault.address,
             klendProgram: this._kaminoLendProgramId,
         };
-        if (vaultAdminAuthority) {
-            updateVaultConfigAccs.vaultAdminAuthority = vaultAdminAuthority;
-        }
         const updateVaultConfigArgs = {
             entry: mode,
-            data: Buffer.from([0]),
+            data: this.getValueForModeAsBuffer(mode, value),
         };
-        if (isNaN(+value) || value === lib_1.DEFAULT_PUBLIC_KEY) {
-            if (mode.kind === new types_1.VaultConfigField.Name().kind) {
-                const data = Array.from(this.encodeVaultName(value));
-                updateVaultConfigArgs.data = Buffer.from(data);
-            }
-            else {
-                const data = (0, kit_1.address)(value);
-                updateVaultConfigArgs.data = Buffer.from(addressEncoder.encode(data));
-            }
-        }
-        else {
-            const buffer = Buffer.alloc(8);
-            buffer.writeBigUInt64LE(BigInt(value.toString()));
-            updateVaultConfigArgs.data = buffer;
-        }
         const vaultReserves = this.getVaultReserves(vaultState);
         const vaultReservesState = await this.loadVaultReserves(vaultState);
         let updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, undefined, this._kaminoVaultProgramId);
@@ -503,6 +511,30 @@ class KaminoVaultClient {
         };
         return updateVaultConfigIxs;
     }
+    /**
+     * Add or update a reserve whitelist entry. This controls whether the reserve is whitelisted for adding/updating
+     * allocations or for invest, depending on the mode parameter.
+     *
+     * @param reserve - Address of the reserve to whitelist
+     * @param mode - The whitelist mode: either 'Invest' or 'AddAllocation' with a value (1 = allow, 0 = deny)
+     * @param globalAdmin - The global admin that signs the transaction
+     * @returns - An instruction to add/update the whitelisted reserve
+     */
+    async addUpdateWhitelistedReserveIx(reserve, mode, globalAdmin) {
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
+        const reserveWhitelistEntry = await getReserveWhitelistEntryPda(reserve, this._kaminoVaultProgramId);
+        const accounts = {
+            globalAdmin,
+            globalConfig,
+            reserve,
+            reserveWhitelistEntry,
+            systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
+        };
+        const args = {
+            update: mode,
+        };
+        return (0, instructions_1.addUpdateWhitelistedReserve)(args, accounts, undefined, this._kaminoVaultProgramId);
+    }
     /** Sets the farm where the shares can be staked. This is store in vault state and a vault can only have one farm, so the new farm will ovveride the old farm
      * @param vault - vault to set the farm for
      * @param farm - the farm where the vault shares can be staked
@@ -520,38 +552,28 @@ class KaminoVaultClient {
         return this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.Farm(), farm, vaultAdminAuthority, lutIxsSigner, skipLutUpdate);
     }
     /**
-     * This method updates the vault config for a vault that
-     * @param admin - address of vault to be updated
+     * This method updates the vault config during vault initialization, within the same transaction
+     * where the vault is created. Use this when the vault state is not yet committed to the chain
+     * and cannot be fetched via RPC. For updates to existing vaults, use updateVaultConfigIxs instead.
+     *
+     * @param admin - the admin that signs the transaction
      * @param vault - address of vault to be updated
      * @param mode - the field to be updated
      * @param value - the new value for the field to be updated (number or pubkey)
      * @returns - an instruction to update the vault config
      */
-    updateUninitialisedVaultConfigIx(admin, vault, mode, value) {
+    async updateUninitialisedVaultConfigIx(admin, vault, mode, value) {
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
         const updateVaultConfigAccs = {
-            vaultAdminAuthority: admin,
+            signer: admin,
+            globalConfig: globalConfig,
             vaultState: vault,
             klendProgram: this._kaminoLendProgramId,
         };
         const updateVaultConfigArgs = {
             entry: mode,
-            data: Buffer.from([0]),
+            data: this.getValueForModeAsBuffer(mode, value),
         };
-        if (isNaN(+value)) {
-            if (mode.kind === new types_1.VaultConfigField.Name().kind) {
-                const data = Array.from(this.encodeVaultName(value));
-                updateVaultConfigArgs.data = Buffer.from(data);
-            }
-            else {
-                const data = (0, kit_1.address)(value);
-                updateVaultConfigArgs.data = Buffer.from(addressEncoder.encode(data));
-            }
-        }
-        else {
-            const buffer = Buffer.alloc(8);
-            buffer.writeBigUInt64LE(BigInt(value.toString()));
-            updateVaultConfigArgs.data = buffer;
-        }
         const updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, undefined, this._kaminoVaultProgramId);
         return updateVaultConfigIx;
     }
@@ -733,6 +755,67 @@ class KaminoVaultClient {
         depositIxs.stakeInFarmIfNeededIxs = stakeSharesIxs;
         return depositIxs;
     }
+    // todo (silviu): after all tx indexing works for buy/sell ixs remove this function and use the buyIx in the deposit function above
+    async buySharesIxs(user, vault, tokenAmount, vaultReservesMap, farmState) {
+        const vaultState = await vault.getState();
+        const tokenProgramID = vaultState.tokenProgram;
+        const userTokenAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user.address, tokenProgramID);
+        const createAtasIxs = [];
+        const closeAtasIxs = [];
+        if (vaultState.tokenMint === lib_1.WRAPPED_SOL_MINT) {
+            const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = await (0, utils_2.createAtasIdempotent)(user, [
+                {
+                    mint: lib_1.WRAPPED_SOL_MINT,
+                    tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                },
+            ]);
+            createAtasIxs.push(createWsolAtaIxn);
+            const transferWsolIxs = (0, lib_1.getTransferWsolIxs)(user, wsolAta, (0, kit_1.lamports)(BigInt((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil().toString())));
+            createAtasIxs.push(...transferWsolIxs);
+        }
+        const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxs }] = await (0, utils_2.createAtasIdempotent)(user, [
+            {
+                mint: vaultState.sharesMint,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            },
+        ]);
+        createAtasIxs.push(createSharesAtaIxs);
+        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+        const buyAccounts = {
+            user: user,
+            vaultState: vault.address,
+            tokenVault: vaultState.tokenVault,
+            tokenMint: vaultState.tokenMint,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            sharesMint: vaultState.sharesMint,
+            userTokenAta: userTokenAta,
+            userSharesAta: userSharesAta,
+            tokenProgram: tokenProgramID,
+            klendProgram: this._kaminoLendProgramId,
+            sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            eventAuthority: eventAuthority,
+            program: this._kaminoVaultProgramId,
+        };
+        const buyArgs = {
+            maxAmount: new bn_js_1.default((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor().toString()),
+        };
+        let buyIx = (0, instructions_1.buy)(buyArgs, buyAccounts, undefined, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        buyIx = this.appendRemainingAccountsForVaultReserves(buyIx, vaultReserves, vaultReservesState);
+        const depositIxs = {
+            depositIxs: [...createAtasIxs, buyIx, ...closeAtasIxs],
+            stakeInFarmIfNeededIxs: [],
+        };
+        // if there is no farm, we can return the deposit instructions, otherwise include the stake ix in the response
+        if (!(await vault.hasFarm())) {
+            return depositIxs;
+        }
+        // if there is a farm, stake the shares
+        const stakeSharesIxs = await this.stakeSharesIxs(user, vault, undefined, farmState);
+        depositIxs.stakeInFarmIfNeededIxs = stakeSharesIxs;
+        return depositIxs;
+    }
     /**
      * This function creates instructions to stake the shares in the vault farm if the vault has a farm
      * @param user - user to stake
@@ -843,6 +926,85 @@ class KaminoVaultClient {
         }
         return withdrawIxs;
     }
+    async sellSharesIxs(user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState) {
+        const vaultState = await vault.getState();
+        const hasFarm = await vault.hasFarm();
+        const withdrawIxs = {
+            unstakeFromFarmIfNeededIxs: [],
+            withdrawIxs: [],
+            postWithdrawIxs: [],
+        };
+        // compute the total shares the user has (in ATA + in farm) and check if they want to withdraw everything or just a part
+        let userSharesAtaBalance = new decimal_js_1.default(0);
+        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
+        const userSharesAtaState = await (0, token_2022_1.fetchMaybeToken)(this.getConnection(), userSharesAta);
+        if (userSharesAtaState.exists) {
+            const userSharesAtaBalanceInLamports = (0, lib_1.getTokenBalanceFromAccountInfoLamports)(userSharesAtaState);
+            userSharesAtaBalance = userSharesAtaBalanceInLamports.div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toString()));
+        }
+        let userSharesInFarm = new decimal_js_1.default(0);
+        if (hasFarm) {
+            userSharesInFarm = await (0, farm_utils_1.getUserSharesInTokensStakedInFarm)(this.getConnection(), user.address, vaultState.vaultFarm, vaultState.sharesMintDecimals.toNumber());
+        }
+        let sharesToWithdraw = shareAmountToWithdraw;
+        const totalUserShares = userSharesAtaBalance.add(userSharesInFarm);
+        let withdrawAllShares = false;
+        if (sharesToWithdraw.gt(totalUserShares)) {
+            sharesToWithdraw = new decimal_js_1.default(utils_2.U64_MAX.toString()).div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toString()));
+            withdrawAllShares = true;
+        }
+        // if not enough shares in ATA unstake from farm
+        const sharesInAtaAreEnoughForWithdraw = sharesToWithdraw.lte(userSharesAtaBalance);
+        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, [
+                {
+                    mint: vaultState.sharesMint,
+                    tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                },
+            ]);
+            withdrawIxs.unstakeFromFarmIfNeededIxs.push(createAtaIx);
+            let shareLamportsToWithdraw = new decimal_js_1.default(utils_2.U64_MAX.toString());
+            if (!withdrawAllShares) {
+                const sharesToWithdrawFromFarm = sharesToWithdraw.sub(userSharesAtaBalance);
+                shareLamportsToWithdraw = (0, kliquidity_sdk_1.collToLamportsDecimal)(sharesToWithdrawFromFarm, vaultState.sharesMintDecimals.toNumber());
+            }
+            const unstakeAndWithdrawFromFarmIxs = await (0, farm_utils_1.getFarmUnstakeAndWithdrawIxs)(this.getConnection(), user, shareLamportsToWithdraw, vaultState.vaultFarm, farmState);
+            withdrawIxs.unstakeFromFarmIfNeededIxs.push(unstakeAndWithdrawFromFarmIxs.unstakeIx);
+            withdrawIxs.unstakeFromFarmIfNeededIxs.push(unstakeAndWithdrawFromFarmIxs.withdrawIx);
+        }
+        // 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.sellSharesWithReserveIxs(user, vault, sharesToWithdraw, totalUserShares, slot, vaultReservesMap);
+            withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
+        }
+        else {
+            const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, vault, sharesToWithdraw);
+            withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
+        }
+        // if the vault is for SOL return the ix to unwrap the SOL
+        if (vaultState.tokenMint === lib_1.WRAPPED_SOL_MINT) {
+            const userWsolAta = await (0, lib_1.getAssociatedTokenAddress)(lib_1.WRAPPED_SOL_MINT, user.address);
+            const unwrapIx = (0, token_2022_1.getCloseAccountInstruction)({
+                account: userWsolAta,
+                owner: user,
+                destination: user.address,
+            }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+            withdrawIxs.postWithdrawIxs.push(unwrapIx);
+        }
+        // if we burn all of user's shares close its shares ATA
+        const burnAllUserShares = sharesToWithdraw.gt(totalUserShares);
+        if (burnAllUserShares) {
+            const closeAtaIx = (0, token_2022_1.getCloseAccountInstruction)({
+                account: userSharesAta,
+                owner: user,
+                destination: user.address,
+            }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+            withdrawIxs.postWithdrawIxs.push(closeAtaIx);
+        }
+        return withdrawIxs;
+    }
     async withdrawFromAvailableIxs(user, vault, shareAmount) {
         const vaultState = await vault.getState();
         const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
@@ -856,6 +1018,83 @@ class KaminoVaultClient {
         const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareLamportsToWithdraw);
         return [createAtaIx, withdrawFromAvailableIxn];
     }
+    async sellSharesWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
+        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, [
+            {
+                mint: vaultState.tokenMint,
+                tokenProgram: vaultState.tokenProgram,
+            },
+        ]);
+        const withdrawAllShares = shareAmount.gte(allUserShares);
+        const actualSharesToWithdraw = shareAmount.lte(allUserShares) ? shareAmount : allUserShares;
+        const shareLamportsToWithdraw = (0, kliquidity_sdk_1.collToLamportsDecimal)(actualSharesToWithdraw, vaultState.sharesMintDecimals.toNumber());
+        const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+        const sharesPerToken = new decimal_js_1.default(1).div(tokensPerShare);
+        const tokensToWithdraw = shareLamportsToWithdraw.mul(tokensPerShare);
+        let tokenLeftToWithdraw = tokensToWithdraw;
+        const availableTokens = new decimal_js_1.default(vaultState.tokenAvailable.toString());
+        tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableTokens);
+        const reserveWithSharesAmountToWithdraw = [];
+        let isFirstWithdraw = true;
+        if (tokenLeftToWithdraw.lte(0)) {
+            // Availabe enough to withdraw all - using the first existent reserve
+            const firstReserve = vaultState.vaultAllocationStrategy.find((reserve) => reserve.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+            if (withdrawAllShares) {
+                reserveWithSharesAmountToWithdraw.push({
+                    reserve: firstReserve.reserve,
+                    shares: new decimal_js_1.default(utils_2.U64_MAX.toString()),
+                });
+            }
+            else {
+                reserveWithSharesAmountToWithdraw.push({
+                    reserve: firstReserve.reserve,
+                    shares: shareLamportsToWithdraw,
+                });
+            }
+        }
+        else {
+            // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
+            const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(vault, slot, vaultReservesState);
+            // sort
+            const reserveAllocationAvailableLiquidityToWithdrawSorted = [
+                ...reserveAllocationAvailableLiquidityToWithdraw.entries(),
+            ].sort((a, b) => b[1].sub(a[1]).toNumber());
+            reserveAllocationAvailableLiquidityToWithdrawSorted.forEach(([key, availableLiquidityToWithdraw], _) => {
+                if (tokenLeftToWithdraw.gt(0)) {
+                    let tokensToWithdrawFromReserve = decimal_js_1.default.min(tokenLeftToWithdraw, availableLiquidityToWithdraw);
+                    if (isFirstWithdraw) {
+                        tokensToWithdrawFromReserve = tokensToWithdrawFromReserve.add(availableTokens);
+                        isFirstWithdraw = false;
+                    }
+                    if (withdrawAllShares) {
+                        reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: new decimal_js_1.default(utils_2.U64_MAX.toString()) });
+                    }
+                    else {
+                        // round up to the nearest integer the shares to withdraw
+                        const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).floor();
+                        reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
+                    }
+                    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
+                }
+            });
+        }
+        const withdrawIxs = [];
+        withdrawIxs.push(createAtaIx);
+        for (let reserveIndex = 0; reserveIndex < reserveWithSharesAmountToWithdraw.length; reserveIndex++) {
+            const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
+            const reserveState = vaultReservesState.get(reserveWithTokens.reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserveWithTokens.reserve} not found in vault reserves map`);
+            }
+            const marketAddress = reserveState.state.lendingMarket;
+            const withdrawFromReserveIx = await this.sellIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, reserveWithTokens.shares, vaultReservesState);
+            withdrawIxs.push(withdrawFromReserveIx);
+        }
+        return withdrawIxs;
+    }
     async withdrawWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
         const vaultState = await vault.getState();
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
@@ -1036,6 +1275,7 @@ class KaminoVaultClient {
         if (createAtaIfNeeded) {
             ixs.push(createAtaIx);
         }
+        const reserveWhitelistEntryOption = await getReserveWhitelistEntryIfExists(reserve.address, this.getConnection(), this._kaminoVaultProgramId);
         const investAccounts = {
             payer,
             vaultState: vault.address,
@@ -1048,6 +1288,7 @@ class KaminoVaultClient {
             lendingMarketAuthority: lendingMarketAuth,
             reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
             reserveCollateralMint: reserve.state.collateral.mintPubkey,
+            reserveWhitelistEntry: reserveWhitelistEntryOption,
             klendProgram: this._kaminoLendProgramId,
             instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
             tokenProgram: tokenProgram,
@@ -1072,13 +1313,82 @@ class KaminoVaultClient {
     decodeVaultName(token) {
         return (0, utils_1.decodeVaultName)(token);
     }
+    /** Helper to serialize value as Buffer for updateVaultConfig instruction */
+    getValueForModeAsBuffer(mode, value) {
+        const isWhitelistOnlyFlag = mode.kind === new types_1.VaultConfigField.AllowInvestInWhitelistedReservesOnly().kind ||
+            mode.kind === new types_1.VaultConfigField.AllowAllocationsInWhitelistedReservesOnly().kind;
+        if (isWhitelistOnlyFlag) {
+            const flag = (0, utils_2.parseBooleanFlag)(value);
+            return Buffer.from([flag]);
+        }
+        else if (isNaN(+value)) {
+            if (mode.kind === new types_1.VaultConfigField.Name().kind) {
+                const data = Array.from(this.encodeVaultName(value));
+                return Buffer.from(data);
+            }
+            else {
+                const data = (0, kit_1.address)(value);
+                return Buffer.from(addressEncoder.encode(data));
+            }
+        }
+        else {
+            const buffer = Buffer.alloc(8);
+            buffer.writeBigUInt64LE(BigInt(value.toString()));
+            return buffer;
+        }
+    }
+    async sellIx(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
+        const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId);
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
+        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+        const sellAccounts = {
+            withdrawFromAvailable: {
+                user,
+                vaultState: vault.address,
+                globalConfig: globalConfig,
+                tokenVault: vaultState.tokenVault,
+                baseVaultAuthority: vaultState.baseVaultAuthority,
+                userTokenAta: userTokenAta,
+                tokenMint: vaultState.tokenMint,
+                userSharesAta: userSharesAta,
+                sharesMint: vaultState.sharesMint,
+                tokenProgram: vaultState.tokenProgram,
+                sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                klendProgram: this._kaminoLendProgramId,
+                eventAuthority: eventAuthority,
+                program: this._kaminoVaultProgramId,
+            },
+            withdrawFromReserveAccounts: {
+                vaultState: vault.address,
+                reserve: reserve.address,
+                ctokenVault: await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
+                lendingMarket: marketAddress,
+                lendingMarketAuthority: lendingMarketAuth,
+                reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
+                reserveCollateralMint: reserve.state.collateral.mintPubkey,
+                reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
+            },
+            eventAuthority: eventAuthority,
+            program: this._kaminoVaultProgramId,
+        };
+        const sellArgs = {
+            sharesAmount: new bn_js_1.default(shareAmountLamports.floor().toString()),
+        };
+        let sellIxn = (0, instructions_1.sell)(sellArgs, sellAccounts, undefined, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        sellIxn = this.appendRemainingAccountsForVaultReserves(sellIxn, vaultReserves, vaultReservesState);
+        return sellIxn;
+    }
     async withdrawIx(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
         const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId);
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
         const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
         const withdrawAccounts = {
             withdrawFromAvailable: {
                 user,
                 vaultState: vault.address,
+                globalConfig: globalConfig,
                 tokenVault: vaultState.tokenVault,
                 baseVaultAuthority: vaultState.baseVaultAuthority,
                 userTokenAta: userTokenAta,
@@ -1114,10 +1424,12 @@ class KaminoVaultClient {
         return withdrawIxn;
     }
     async withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareAmountLamports) {
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
         const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
         const withdrawFromAvailableAccounts = {
             user,
             vaultState: vault.address,
+            globalConfig: globalConfig,
             tokenVault: vaultState.tokenVault,
             baseVaultAuthority: vaultState.baseVaultAuthority,
             userTokenAta,
@@ -2853,6 +3165,25 @@ async function getEventAuthorityPda(kaminoVaultProgramId) {
         programAddress: kaminoVaultProgramId,
     }))[0];
 }
+async function getKvaultGlobalConfigPda(kaminoVaultProgramId) {
+    return (await (0, kit_1.getProgramDerivedAddress)({
+        seeds: [Buffer.from(GLOBAL_CONFIG_STATE_SEED)],
+        programAddress: kaminoVaultProgramId,
+    }))[0];
+}
+async function getReserveWhitelistEntryPda(reserveAddress, kaminoVaultProgramId) {
+    return (await (0, kit_1.getProgramDerivedAddress)({
+        seeds: [Buffer.from(WHITELISTED_RESERVES_SEED), addressEncoder.encode(reserveAddress)],
+        programAddress: kaminoVaultProgramId,
+    }))[0];
+}
+async function getReserveWhitelistEntryIfExists(reserveAddress, rpc, kaminoVaultProgramId) {
+    const reserveWhitelistEntry = await getReserveWhitelistEntryPda(reserveAddress, kaminoVaultProgramId);
+    const reserveWhitelistEntryAccount = await (0, kit_1.fetchEncodedAccount)(rpc, reserveWhitelistEntry, {
+        commitment: 'processed',
+    });
+    return reserveWhitelistEntryAccount.exists ? (0, kit_1.some)(reserveWhitelistEntry) : (0, kit_1.none)();
+}
 function parseVaultAdmin(vault, signer) {
     return signer ?? (0, signer_1.noopSigner)(vault.vaultAdminAuthority);
 }