@kamino-finance/klend-sdk 7.2.6 → 7.3.1

package/src/classes/vault.ts

@@ -23,6 +23,9 @@ import {
   AccountInfoWithPubkey,
   AccountInfoBase,
   AccountInfoWithJsonData,
+  Option,
+  some,
+  none,
 } from '@solana/kit';
 import {
   AllOracleAccounts,
@@ -40,18 +43,28 @@ import {
   WRAPPED_SOL_MINT,
 } from '../lib';
 import {
+  addUpdateWhitelistedReserve,
+  AddUpdateWhitelistedReserveAccounts,
+  AddUpdateWhitelistedReserveArgs,
+  buy,
+  BuyAccounts,
+  BuyArgs,
   deposit,
   DepositAccounts,
   DepositArgs,
   giveUpPendingFees,
   GiveUpPendingFeesAccounts,
   GiveUpPendingFeesArgs,
+  initKVaultGlobalConfig,
   initVault,
   InitVaultAccounts,
   invest,
   InvestAccounts,
   removeAllocation,
   RemoveAllocationAccounts,
+  sell,
+  SellAccounts,
+  SellArgs,
   updateAdmin,
   UpdateAdminAccounts,
   updateReserveAllocation,
@@ -69,7 +82,7 @@ import {
   withdrawPendingFees,
   WithdrawPendingFeesAccounts,
 } from '../@codegen/kvault/instructions';
-import { VaultConfigField, VaultConfigFieldKind } from '../@codegen/kvault/types';
+import { UpdateReserveWhitelistModeKind, VaultConfigField, VaultConfigFieldKind } from '../@codegen/kvault/types';
 import { VaultState } from '../@codegen/kvault/accounts';
 import Decimal from 'decimal.js';
 import { bpsToPct, decodeVaultName, numberToLamportsDecimal, parseTokenSymbol, pubkeyHashMapToJson } from './utils';
@@ -85,6 +98,8 @@ import {
   getTokenAccountAmount,
   getTokenAccountMint,
   lendingMarketAuthPda,
+  parseBooleanFlag,
+  programDataPda,
   SECONDS_PER_YEAR,
   U64_MAX,
   VAULT_INITIAL_DEPOSIT,
@@ -140,6 +155,8 @@ const BASE_VAULT_AUTHORITY_SEED = 'authority';
 const SHARES_SEED = 'shares';
 const EVENT_AUTHORITY_SEED = '__event_authority';
 export const METADATA_SEED = 'metadata';
+const GLOBAL_CONFIG_STATE_SEED = 'global_config';
+const WHITELISTED_RESERVES_SEED = 'whitelisted_reserves';
 
 export const METADATA_PROGRAM_ID: Address = address('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
 
@@ -215,6 +232,29 @@ export class KaminoVaultClient {
     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: TransactionSigner) {
+    const globalConfigAddress = await getKvaultGlobalConfigPda(this.getProgramID());
+
+    const programData = await programDataPda(this.getProgramID());
+    const ix = initKVaultGlobalConfig(
+      {
+        payer: admin,
+        globalConfig: globalConfigAddress,
+        programData: programData,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
+        rent: 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
@@ -316,7 +356,7 @@ export class KaminoVaultClient {
       []
     );
 
-    const setLUTIx = this.updateUninitialisedVaultConfigIx(
+    const setLUTIx = await this.updateUninitialisedVaultConfigIx(
       vaultConfig.admin,
       vaultState.address,
       new VaultConfigField.LookupTable(),
@@ -326,7 +366,7 @@ export class KaminoVaultClient {
     const ixs = [createVaultIx, initVaultIx, setLUTIx];
 
     if (vaultConfig.getPerformanceFeeBps() > 0) {
-      const setPerformanceFeeIx = this.updateUninitialisedVaultConfigIx(
+      const setPerformanceFeeIx = await this.updateUninitialisedVaultConfigIx(
         vaultConfig.admin,
         vaultState.address,
         new VaultConfigField.PerformanceFeeBps(),
@@ -335,7 +375,7 @@ export class KaminoVaultClient {
       ixs.push(setPerformanceFeeIx);
     }
     if (vaultConfig.getManagementFeeBps() > 0) {
-      const setManagementFeeIx = this.updateUninitialisedVaultConfigIx(
+      const setManagementFeeIx = await this.updateUninitialisedVaultConfigIx(
         vaultConfig.admin,
         vaultState.address,
         new VaultConfigField.ManagementFeeBps(),
@@ -344,7 +384,7 @@ export class KaminoVaultClient {
       ixs.push(setManagementFeeIx);
     }
     if (vaultConfig.name && vaultConfig.name.length > 0) {
-      const setNameIx = this.updateUninitialisedVaultConfigIx(
+      const setNameIx = await this.updateUninitialisedVaultConfigIx(
         vaultConfig.admin,
         vaultState.address,
         new VaultConfigField.Name(),
@@ -352,7 +392,7 @@ export class KaminoVaultClient {
       );
       ixs.push(setNameIx);
     }
-    const setFarmIx = this.updateUninitialisedVaultConfigIx(
+    const setFarmIx = await this.updateUninitialisedVaultConfigIx(
       vaultConfig.admin,
       vaultState.address,
       new VaultConfigField.Farm(),
@@ -482,6 +522,12 @@ export class KaminoVaultClient {
       this._kaminoVaultProgramId
     );
 
+    const reserveWhitelistEntryOption = await getReserveWhitelistEntryIfExists(
+      reserveAllocationConfig.getReserveAddress(),
+      this.getConnection(),
+      this._kaminoVaultProgramId
+    );
+
     const vaultAdmin = parseVaultAdmin(vaultState, vaultAdminAuthority);
     const updateReserveAllocationAccounts: UpdateReserveAllocationAccounts = {
       signer: vaultAdmin,
@@ -490,6 +536,7 @@ export class KaminoVaultClient {
       reserveCollateralMint: reserveState.collateral.mintPubkey,
       reserve: reserveAllocationConfig.getReserveAddress(),
       ctokenVault: cTokenVault,
+      reserveWhitelistEntry: reserveWhitelistEntryOption,
       systemProgram: SYSTEM_PROGRAM_ADDRESS,
       rent: SYSVAR_RENT_ADDRESS,
       reserveCollateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
@@ -756,7 +803,8 @@ export class KaminoVaultClient {
    * @param vault the vault to update
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
-   * @param [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
@@ -765,41 +813,26 @@ export class KaminoVaultClient {
     vault: KaminoVault,
     mode: VaultConfigFieldKind,
     value: string,
-    vaultAdminAuthority?: TransactionSigner,
+    adminAuthority?: TransactionSigner,
     lutIxsSigner?: TransactionSigner,
     skipLutUpdate: boolean = false
   ): Promise<UpdateVaultConfigIxs> {
     const vaultState: VaultState = await vault.getState();
-    const admin = parseVaultAdmin(vaultState, vaultAdminAuthority);
+    const admin = parseVaultAdmin(vaultState, adminAuthority);
 
+    const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
-      vaultAdminAuthority: admin,
+      signer: admin,
+      globalConfig: globalConfig,
       vaultState: vault.address,
       klendProgram: this._kaminoLendProgramId,
     };
-    if (vaultAdminAuthority) {
-      updateVaultConfigAccs.vaultAdminAuthority = vaultAdminAuthority;
-    }
 
     const updateVaultConfigArgs: UpdateVaultConfigArgs = {
       entry: mode,
-      data: Buffer.from([0]),
+      data: this.getValueForModeAsBuffer(mode, value),
     };
 
-    if (isNaN(+value) || value === DEFAULT_PUBLIC_KEY) {
-      if (mode.kind === new VaultConfigField.Name().kind) {
-        const data = Array.from(this.encodeVaultName(value));
-        updateVaultConfigArgs.data = Buffer.from(data);
-      } else {
-        const data = 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);
 
@@ -863,6 +896,38 @@ export 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: Address,
+    mode: UpdateReserveWhitelistModeKind,
+    globalAdmin: TransactionSigner
+  ): Promise<Instruction> {
+    const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
+    const reserveWhitelistEntry = await getReserveWhitelistEntryPda(reserve, this._kaminoVaultProgramId);
+
+    const accounts: AddUpdateWhitelistedReserveAccounts = {
+      globalAdmin,
+      globalConfig,
+      reserve,
+      reserveWhitelistEntry,
+      systemProgram: SYSTEM_PROGRAM_ADDRESS,
+    };
+
+    const args: AddUpdateWhitelistedReserveArgs = {
+      update: mode,
+    };
+
+    return 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
@@ -895,44 +960,35 @@ export class KaminoVaultClient {
   }
 
   /**
-   * 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
    */
-  private updateUninitialisedVaultConfigIx(
+  private async updateUninitialisedVaultConfigIx(
     admin: TransactionSigner,
     vault: Address,
     mode: VaultConfigFieldKind,
     value: string
-  ): Instruction {
+  ): Promise<Instruction> {
+    const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
     const updateVaultConfigAccs: UpdateVaultConfigAccounts = {
-      vaultAdminAuthority: admin,
+      signer: admin,
+      globalConfig: globalConfig,
       vaultState: vault,
       klendProgram: this._kaminoLendProgramId,
     };
 
     const updateVaultConfigArgs: UpdateVaultConfigArgs = {
       entry: mode,
-      data: Buffer.from([0]),
+      data: this.getValueForModeAsBuffer(mode, value),
     };
 
-    if (isNaN(+value)) {
-      if (mode.kind === new VaultConfigField.Name().kind) {
-        const data = Array.from(this.encodeVaultName(value));
-        updateVaultConfigArgs.data = Buffer.from(data);
-      } else {
-        const data = 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 = updateVaultConfig(
       updateVaultConfigArgs,
       updateVaultConfigAccs,
@@ -1220,6 +1276,92 @@ export class KaminoVaultClient {
     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: TransactionSigner,
+    vault: KaminoVault,
+    tokenAmount: Decimal,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<DepositIxs> {
+    const vaultState = await vault.getState();
+
+    const tokenProgramID = vaultState.tokenProgram;
+    const userTokenAta = await getAssociatedTokenAddress(vaultState.tokenMint, user.address, tokenProgramID);
+    const createAtasIxs: Instruction[] = [];
+    const closeAtasIxs: Instruction[] = [];
+    if (vaultState.tokenMint === WRAPPED_SOL_MINT) {
+      const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = await createAtasIdempotent(user, [
+        {
+          mint: WRAPPED_SOL_MINT,
+          tokenProgram: TOKEN_PROGRAM_ADDRESS,
+        },
+      ]);
+      createAtasIxs.push(createWsolAtaIxn);
+      const transferWsolIxs = getTransferWsolIxs(
+        user,
+        wsolAta,
+        lamports(
+          BigInt(numberToLamportsDecimal(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil().toString())
+        )
+      );
+      createAtasIxs.push(...transferWsolIxs);
+    }
+
+    const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxs }] = await createAtasIdempotent(user, [
+      {
+        mint: vaultState.sharesMint,
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      },
+    ]);
+    createAtasIxs.push(createSharesAtaIxs);
+
+    const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+    const buyAccounts: 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_PROGRAM_ADDRESS,
+      eventAuthority: eventAuthority,
+      program: this._kaminoVaultProgramId,
+    };
+
+    const buyArgs: BuyArgs = {
+      maxAmount: new BN(
+        numberToLamportsDecimal(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor().toString()
+      ),
+    };
+
+    let buyIx = 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 = {
+      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
@@ -1389,6 +1531,135 @@ export class KaminoVaultClient {
     return withdrawIxs;
   }
 
+  async sellSharesIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    shareAmountToWithdraw: Decimal,
+    slot: Slot,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    farmState?: FarmState
+  ): Promise<WithdrawIxs> {
+    const vaultState = await vault.getState();
+    const hasFarm = await vault.hasFarm();
+
+    const withdrawIxs: 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(0);
+    const userSharesAta = await getAssociatedTokenAddress(vaultState.sharesMint, user.address);
+    const userSharesAtaState = await fetchMaybeToken(this.getConnection(), userSharesAta);
+    if (userSharesAtaState.exists) {
+      const userSharesAtaBalanceInLamports = getTokenBalanceFromAccountInfoLamports(userSharesAtaState);
+      userSharesAtaBalance = userSharesAtaBalanceInLamports.div(
+        new Decimal(10).pow(vaultState.sharesMintDecimals.toString())
+      );
+    }
+
+    let userSharesInFarm = new Decimal(0);
+    if (hasFarm) {
+      userSharesInFarm = await 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(U64_MAX.toString()).div(
+        new Decimal(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 createAtasIdempotent(user, [
+        {
+          mint: vaultState.sharesMint,
+          tokenProgram: TOKEN_PROGRAM_ADDRESS,
+        },
+      ]);
+      withdrawIxs.unstakeFromFarmIfNeededIxs.push(createAtaIx);
+      let shareLamportsToWithdraw = new Decimal(U64_MAX.toString());
+      if (!withdrawAllShares) {
+        const sharesToWithdrawFromFarm = sharesToWithdraw.sub(userSharesAtaBalance);
+        shareLamportsToWithdraw = collToLamportsDecimal(
+          sharesToWithdrawFromFarm,
+          vaultState.sharesMintDecimals.toNumber()
+        );
+      }
+      const unstakeAndWithdrawFromFarmIxs = await 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 !== 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 === WRAPPED_SOL_MINT) {
+      const userWsolAta = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, user.address);
+      const unwrapIx = getCloseAccountInstruction(
+        {
+          account: userWsolAta,
+          owner: user,
+          destination: user.address,
+        },
+        { programAddress: 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 = getCloseAccountInstruction(
+        {
+          account: userSharesAta,
+          owner: user,
+          destination: user.address,
+        },
+        { programAddress: TOKEN_PROGRAM_ADDRESS }
+      );
+      withdrawIxs.postWithdrawIxs.push(closeAtaIx);
+    }
+
+    return withdrawIxs;
+  }
+
   private async withdrawFromAvailableIxs(
     user: TransactionSigner,
     vault: KaminoVault,
@@ -1417,6 +1688,115 @@ export class KaminoVaultClient {
     return [createAtaIx, withdrawFromAvailableIxn];
   }
 
+  private async sellSharesWithReserveIxs(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    shareAmount: Decimal,
+    allUserShares: Decimal,
+    slot: Slot,
+    vaultReservesMap?: Map<Address, KaminoReserve>
+  ): Promise<Instruction[]> {
+    const vaultState = await vault.getState();
+
+    const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+    const userSharesAta = await getAssociatedTokenAddress(vaultState.sharesMint, user.address);
+    const [{ ata: userTokenAta, createAtaIx }] = await createAtasIdempotent(user, [
+      {
+        mint: vaultState.tokenMint,
+        tokenProgram: vaultState.tokenProgram,
+      },
+    ]);
+
+    const withdrawAllShares = shareAmount.gte(allUserShares);
+    const actualSharesToWithdraw = shareAmount.lte(allUserShares) ? shareAmount : allUserShares;
+    const shareLamportsToWithdraw = collToLamportsDecimal(
+      actualSharesToWithdraw,
+      vaultState.sharesMintDecimals.toNumber()
+    );
+    const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+    const sharesPerToken = new Decimal(1).div(tokensPerShare);
+    const tokensToWithdraw = shareLamportsToWithdraw.mul(tokensPerShare);
+    let tokenLeftToWithdraw = tokensToWithdraw;
+    const availableTokens = new Decimal(vaultState.tokenAvailable.toString());
+    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableTokens);
+
+    type ReserveWithTokensToWithdraw = { reserve: Address; shares: Decimal };
+
+    const reserveWithSharesAmountToWithdraw: ReserveWithTokensToWithdraw[] = [];
+    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 !== DEFAULT_PUBLIC_KEY);
+      if (withdrawAllShares) {
+        reserveWithSharesAmountToWithdraw.push({
+          reserve: firstReserve!.reserve,
+          shares: new Decimal(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.min(tokenLeftToWithdraw, availableLiquidityToWithdraw);
+          if (isFirstWithdraw) {
+            tokensToWithdrawFromReserve = tokensToWithdrawFromReserve.add(availableTokens);
+            isFirstWithdraw = false;
+          }
+          if (withdrawAllShares) {
+            reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: new Decimal(U64_MAX.toString()) });
+          } else {
+            // round up to the nearest integer the shares to withdraw
+            const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).floor();
+            reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
+          }
+
+          tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
+        }
+      });
+    }
+
+    const withdrawIxs: Instruction[] = [];
+    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;
+  }
   private async withdrawWithReserveIxs(
     user: TransactionSigner,
     vault: KaminoVault,
@@ -1666,6 +2046,12 @@ export class KaminoVaultClient {
       ixs.push(createAtaIx);
     }
 
+    const reserveWhitelistEntryOption = await getReserveWhitelistEntryIfExists(
+      reserve.address,
+      this.getConnection(),
+      this._kaminoVaultProgramId
+    );
+
     const investAccounts: InvestAccounts = {
       payer,
       vaultState: vault.address,
@@ -1678,6 +2064,7 @@ export class KaminoVaultClient {
       lendingMarketAuthority: lendingMarketAuth,
       reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
       reserveCollateralMint: reserve.state.collateral.mintPubkey,
+      reserveWhitelistEntry: reserveWhitelistEntryOption,
       klendProgram: this._kaminoLendProgramId,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
       tokenProgram: tokenProgram,
@@ -1707,6 +2094,89 @@ export class KaminoVaultClient {
     return decodeVaultName(token);
   }
 
+  /** Helper to serialize value as Buffer for updateVaultConfig instruction */
+  private getValueForModeAsBuffer(mode: VaultConfigFieldKind, value: string): Buffer {
+    const isWhitelistOnlyFlag =
+      mode.kind === new VaultConfigField.AllowInvestInWhitelistedReservesOnly().kind ||
+      mode.kind === new VaultConfigField.AllowAllocationsInWhitelistedReservesOnly().kind;
+
+    if (isWhitelistOnlyFlag) {
+      const flag = parseBooleanFlag(value);
+      return Buffer.from([flag]);
+    } else if (isNaN(+value)) {
+      if (mode.kind === new VaultConfigField.Name().kind) {
+        const data = Array.from(this.encodeVaultName(value));
+        return Buffer.from(data);
+      } else {
+        const data = address(value);
+        return Buffer.from(addressEncoder.encode(data));
+      }
+    } else {
+      const buffer = Buffer.alloc(8);
+      buffer.writeBigUInt64LE(BigInt(value.toString()));
+      return buffer;
+    }
+  }
+
+  private async sellIx(
+    user: TransactionSigner,
+    vault: KaminoVault,
+    vaultState: VaultState,
+    marketAddress: Address,
+    reserve: ReserveWithAddress,
+    userSharesAta: Address,
+    userTokenAta: Address,
+    shareAmountLamports: Decimal,
+    vaultReservesState: Map<Address, KaminoReserve>
+  ): Promise<Instruction> {
+    const [lendingMarketAuth] = await lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId);
+
+    const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
+    const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+    const sellAccounts: 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_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_PROGRAM_ADDRESS,
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
+      },
+      eventAuthority: eventAuthority,
+      program: this._kaminoVaultProgramId,
+    };
+
+    const sellArgs: SellArgs = {
+      sharesAmount: new BN(shareAmountLamports.floor().toString()),
+    };
+
+    let sellIxn = sell(sellArgs, sellAccounts, undefined, this._kaminoVaultProgramId);
+
+    const vaultReserves = this.getVaultReserves(vaultState);
+    sellIxn = this.appendRemainingAccountsForVaultReserves(sellIxn, vaultReserves, vaultReservesState);
+
+    return sellIxn;
+  }
+
   private async withdrawIx(
     user: TransactionSigner,
     vault: KaminoVault,
@@ -1720,11 +2190,13 @@ export class KaminoVaultClient {
   ): Promise<Instruction> {
     const [lendingMarketAuth] = await lendingMarketAuthPda(marketAddress, this._kaminoLendProgramId);
 
+    const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
     const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
     const withdrawAccounts: WithdrawAccounts = {
       withdrawFromAvailable: {
         user,
         vaultState: vault.address,
+        globalConfig: globalConfig,
         tokenVault: vaultState.tokenVault,
         baseVaultAuthority: vaultState.baseVaultAuthority,
         userTokenAta: userTokenAta,
@@ -1772,10 +2244,12 @@ export class KaminoVaultClient {
     userTokenAta: Address,
     shareAmountLamports: Decimal
   ): Promise<Instruction> {
+    const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
     const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
     const withdrawFromAvailableAccounts: WithdrawFromAvailableAccounts = {
       user,
       vaultState: vault.address,
+      globalConfig: globalConfig,
       tokenVault: vaultState.tokenVault,
       baseVaultAuthority: vaultState.baseVaultAuthority,
       userTokenAta,
@@ -4162,6 +4636,39 @@ export async function getEventAuthorityPda(kaminoVaultProgramId: Address): Promi
   )[0];
 }
 
+export async function getKvaultGlobalConfigPda(kaminoVaultProgramId: Address): Promise<Address> {
+  return (
+    await getProgramDerivedAddress({
+      seeds: [Buffer.from(GLOBAL_CONFIG_STATE_SEED)],
+      programAddress: kaminoVaultProgramId,
+    })
+  )[0];
+}
+
+export async function getReserveWhitelistEntryPda(
+  reserveAddress: Address,
+  kaminoVaultProgramId: Address
+): Promise<Address> {
+  return (
+    await getProgramDerivedAddress({
+      seeds: [Buffer.from(WHITELISTED_RESERVES_SEED), addressEncoder.encode(reserveAddress)],
+      programAddress: kaminoVaultProgramId,
+    })
+  )[0];
+}
+
+async function getReserveWhitelistEntryIfExists(
+  reserveAddress: Address,
+  rpc: Rpc<SolanaRpcApi>,
+  kaminoVaultProgramId: Address
+): Promise<Option<Address>> {
+  const reserveWhitelistEntry = await getReserveWhitelistEntryPda(reserveAddress, kaminoVaultProgramId);
+  const reserveWhitelistEntryAccount = await fetchEncodedAccount(rpc, reserveWhitelistEntry, {
+    commitment: 'processed',
+  });
+  return reserveWhitelistEntryAccount.exists ? some(reserveWhitelistEntry) : none<Address>();
+}
+
 function parseVaultAdmin(vault: VaultState, signer?: TransactionSigner) {
   return signer ?? noopSigner(vault.vaultAdminAuthority);
 }