@kamino-finance/klend-sdk 5.2.12 → 5.2.14

package/dist/classes/vault.js

@@ -10,6 +10,7 @@ const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const lib_1 = require("../lib");
 const instructions_1 = require("../idl_codegen_kamino_vault/instructions");
+const types_1 = require("../idl_codegen_kamino_vault/types");
 const accounts_1 = require("../idl_codegen_kamino_vault/accounts");
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const utils_1 = require("./utils");
@@ -21,6 +22,7 @@ const fraction_1 = require("./fraction");
 const utils_2 = require("../utils");
 const bs58_1 = __importDefault(require("bs58"));
 const rpc_1 = require("../utils/rpc");
+const kliquidity_sdk_1 = require("@kamino-finance/kliquidity-sdk");
 exports.kaminoVaultId = new web3_js_1.PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
 exports.kaminoVaultStagingId = new web3_js_1.PublicKey('STkvh7ostar39Fwr4uZKASs1RNNuYMFMTsE77FiRsL2');
 const TOKEN_VAULT_SEED = 'token_vault';
@@ -51,7 +53,7 @@ class KaminoVaultClient {
      * 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
      * @returns vault - keypair, should be used to sign the transaction which creates the vault account
-     * @returns ixns - an array of instructions to create the vault
+     * @returns vault: the keypair of the vault, used to sign the initialization transaction; initVaultIxs: a struct with ixs to initialize the vault and its lookup table + populateLUTIxs, a list to populate the lookup table which has to be executed in a separate transaction
      */
     async createVaultIxs(vaultConfig) {
         const vaultState = web3_js_1.Keypair.generate();
@@ -79,8 +81,38 @@ class KaminoVaultClient {
             sharesTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         };
         const initVaultIx = (0, instructions_1.initVault)(initVaultAccounts, this._kaminoVaultProgramId);
-        // TODO: Add logic to update vault based on vaultConfig
-        return { vault: vaultState, ixns: [createVaultIx, initVaultIx] };
+        // create and set up the vault lookup table
+        const slot = await this._connection.getSlot();
+        const [createLUTIx, lut] = this.getInitLookupTableIx(vaultConfig.admin, slot);
+        const accountsToBeInserted = [
+            vaultConfig.admin,
+            vaultState.publicKey,
+            vaultConfig.tokenMint,
+            vaultConfig.tokenMintProgramId,
+            baseVaultAuthority,
+            sharesMint,
+            web3_js_1.SystemProgram.programId,
+            web3_js_1.SYSVAR_RENT_PUBKEY,
+            spl_token_1.TOKEN_PROGRAM_ID,
+            this._kaminoLendProgramId,
+            web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+        ];
+        const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(vaultConfig.admin, lut, accountsToBeInserted, []);
+        const setLUTIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.LookupTable(), lut.toString());
+        const ixns = [createVaultIx, initVaultIx, createLUTIx, setLUTIx];
+        if (vaultConfig.getPerformanceFeeBps() > 0) {
+            const setPerformanceFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.PerformanceFeeBps(), vaultConfig.getPerformanceFeeBps().toString());
+            ixns.push(setPerformanceFeeIx);
+        }
+        if (vaultConfig.getManagementFeeBps() > 0) {
+            const setManagementFeeIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.ManagementFeeBps(), vaultConfig.getManagementFeeBps().toString());
+            ixns.push(setManagementFeeIx);
+        }
+        if (vaultConfig.name && vaultConfig.name.length > 0) {
+            const setNameIx = this.updateUninitialisedVaultConfigIx(vaultConfig.admin, vaultState.publicKey, new types_1.VaultConfigField.Name(), vaultConfig.name);
+            ixns.push(setNameIx);
+        }
+        return { vault: vaultState, initVaultIxs: { initVaultIxs: ixns, populateLUTIxs: insertIntoLUTIxs } };
     }
     /**
      * This method updates the vault reserve allocation cofnig for an exiting vault reserve, or adds a new reserve to the vault if it does not exist.
@@ -107,16 +139,29 @@ class KaminoVaultClient {
             weight: new anchor_1.BN(reserveAllocationConfig.targetAllocationWeight),
             cap: new anchor_1.BN(reserveAllocationConfig.getAllocationCapLamports().floor().toString()),
         };
-        return (0, instructions_1.updateReserveAllocation)(updateReserveAllocationArgs, updateReserveAllocationAccounts, this._kaminoVaultProgramId);
+        const updateReserveAllocationIx = (0, instructions_1.updateReserveAllocation)(updateReserveAllocationArgs, updateReserveAllocationAccounts, this._kaminoVaultProgramId);
+        const accountsToAddToLUT = [
+            reserveAllocationConfig.getReserveAddress(),
+            cTokenVault,
+            ...this.getReserveAccountsToInsertInLut(reserveState),
+        ];
+        const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(reserveState.lendingMarket, this._kaminoLendProgramId)[0];
+        accountsToAddToLUT.push(lendingMarketAuth);
+        const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(vaultState.adminAuthority, vaultState.vaultLookupTable, accountsToAddToLUT);
+        const updateReserveAllocationIxs = {
+            updateReserveAllocationIx,
+            updateLUTIxs: insertIntoLUTIxs,
+        };
+        return updateReserveAllocationIxs;
     }
     /**
-     * This method updates the vault config
-     * @param vault - 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 - a list of instructions
+     * Update a field of the vault. If the field is a pubkey it will return an extra instruction to add that account into the lookup table
+     * @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
+     * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
      */
-    async updateVaultConfigIx(vault, mode, value) {
+    async updateVaultConfigIxs(vault, mode, value) {
         const vaultState = await vault.getState(this.getConnection());
         const updateVaultConfigAccs = {
             adminAuthority: vaultState.adminAuthority,
@@ -128,8 +173,14 @@ class KaminoVaultClient {
             data: Buffer.from([0]),
         };
         if (isNaN(+value)) {
-            const data = new web3_js_1.PublicKey(value);
-            updateVaultConfigArgs.data = data.toBuffer();
+            if (mode.kind === new types_1.VaultConfigField.Name().kind) {
+                const data = Array.from(this.encodeVaultName(value));
+                updateVaultConfigArgs.data = Buffer.from(data);
+            }
+            else {
+                const data = new web3_js_1.PublicKey(value);
+                updateVaultConfigArgs.data = data.toBuffer();
+            }
         }
         else {
             const buffer = Buffer.alloc(8);
@@ -155,6 +206,51 @@ class KaminoVaultClient {
         const updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, this._kaminoVaultProgramId);
         updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesAccountMetas);
         updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesLendingMarkets);
+        const updateLUTIxs = [];
+        if (mode.kind === new types_1.VaultConfigField.PendingVaultAdmin().kind || mode.kind === new types_1.VaultConfigField.Farm().kind) {
+            const newPubkey = new web3_js_1.PublicKey(value);
+            const insertIntoLutIxs = await this.insertIntoLookupTableIxs(vaultState.adminAuthority, vaultState.vaultLookupTable, [newPubkey]);
+            updateLUTIxs.push(...insertIntoLutIxs);
+        }
+        const updateVaultConfigIxs = {
+            updateVaultConfigIx,
+            updateLUTIxs,
+        };
+        return updateVaultConfigIxs;
+    }
+    /**
+     * This method updates the vault config for a vault that
+     * @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 - a list of instructions
+     */
+    updateUninitialisedVaultConfigIx(admin, vault, mode, value) {
+        const updateVaultConfigAccs = {
+            adminAuthority: admin,
+            vaultState: vault,
+            klendProgram: this._kaminoLendProgramId,
+        };
+        const updateVaultConfigArgs = {
+            entry: mode,
+            data: Buffer.from([0]),
+        };
+        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 = new web3_js_1.PublicKey(value);
+                updateVaultConfigArgs.data = data.toBuffer();
+            }
+        }
+        else {
+            const buffer = Buffer.alloc(8);
+            buffer.writeBigUInt64LE(BigInt(value.toString()));
+            updateVaultConfigArgs.data = buffer;
+        }
+        const updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, this._kaminoVaultProgramId);
         return updateVaultConfigIx;
     }
     /**
@@ -162,13 +258,28 @@ class KaminoVaultClient {
      * @param vault - vault to change the ownership for
      * @returns - an instruction to be used to be executed
      */
-    async acceptVaultOwnershipIx(vault) {
+    async acceptVaultOwnershipIxs(vault) {
         const vaultState = await vault.getState(this.getConnection());
         const acceptOwneshipAccounts = {
             pendingAdmin: vaultState.pendingAdmin,
             vaultState: vault.address,
         };
-        return (0, instructions_1.updateAdmin)(acceptOwneshipAccounts, this._kaminoVaultProgramId);
+        const acceptVaultOwnershipIx = (0, instructions_1.updateAdmin)(acceptOwneshipAccounts, this._kaminoVaultProgramId);
+        // read the current LUT and create a new one for the new admin and backfill it
+        const accountsInExistentLUT = (await this.getAccountsInLUT(vaultState.vaultLookupTable)).filter((account) => !account.equals(vaultState.adminAuthority));
+        const LUTIxs = [];
+        const [initNewLUTIx, newLUT] = this.getInitLookupTableIx(vaultState.pendingAdmin, await this._connection.getSlot());
+        LUTIxs.push(initNewLUTIx);
+        const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(vaultState.pendingAdmin, newLUT, accountsInExistentLUT);
+        LUTIxs.push(...insertIntoLUTIxs);
+        const updateVaultConfigIxs = await this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.LookupTable(), newLUT.toString());
+        LUTIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
+        LUTIxs.push(...updateVaultConfigIxs.updateLUTIxs);
+        const acceptVaultOwnershipIxs = {
+            acceptVaultOwnershipIx,
+            updateLUTIxs: LUTIxs,
+        };
+        return acceptVaultOwnershipIxs;
     }
     /**
      * This function creates the instruction for the admin to give up a part of the pending fees (which will be accounted as part of the vault)
@@ -322,6 +433,32 @@ class KaminoVaultClient {
      * @returns an array of instructions to be executed
      */
     async withdrawIxs(user, vault, shareAmount, slot, vaultReservesMap) {
+        const vaultState = await vault.getState(this._connection);
+        const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
+        // if the vault has allocations withdraw otherwise wtihdraw from available ix
+        const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) => ~allocation.reserve.equals(web3_js_1.PublicKey.default));
+        if (vaultAllocation) {
+            return this.wihdrdrawWithReserveIxns(user, kaminoVault, shareAmount, slot, vaultReservesMap);
+        }
+        else {
+            return this.withdrawFromAvailableIxns(user, kaminoVault, shareAmount);
+        }
+    }
+    async withdrawFromAvailableIxns(user, vault, shareAmount) {
+        const vaultState = await vault.getState(this._connection);
+        const kaminoVault = new KaminoVault(vault.address, vaultState, vault.programId);
+        const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
+        const [{ ata: userTokenAta, createAtaIx }] = (0, utils_2.createAtasIdempotent)(user, [
+            {
+                mint: vaultState.tokenMint,
+                tokenProgram: vaultState.tokenProgram,
+            },
+        ]);
+        const shareLamportsToWithdraw = (0, kliquidity_sdk_1.collToLamportsDecimal)(shareAmount, vaultState.sharesMintDecimals.toNumber());
+        const withdrawFromAvailableIxn = await this.withdrawFromAvailableIxn(user, kaminoVault, vaultState, userSharesAta, userTokenAta, shareLamportsToWithdraw);
+        return [createAtaIx, withdrawFromAvailableIxn];
+    }
+    async wihdrdrawWithReserveIxns(user, vault, shareAmount, slot, vaultReservesMap) {
         const vaultState = await vault.getState(this._connection);
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
         const userSharesAta = (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user);
@@ -396,7 +533,7 @@ class KaminoVaultClient {
      * @param reserve - reserve to invest into or disinvest from
      * @returns - an array of invest instructions for each invest action required for the vault reserves
      */
-    async investSingleReserveIxs(payer, vault, reserve) {
+    async investSingleReserveIxs(payer, vault, reserve, vaultReservesMap) {
         const vaultState = await vault.getState(this._connection);
         const cTokenVault = getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
         const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
@@ -425,12 +562,38 @@ class KaminoVaultClient {
         };
         const investIx = (0, instructions_1.invest)(investAccounts, this._kaminoVaultProgramId);
         const vaultReserves = this.getVaultReserves(vaultState);
-        const vaultReservesAccountMetas = vaultReserves.map((reserve) => {
-            return { pubkey: reserve, isSigner: false, isWritable: true };
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        let vaultReservesAccountMetas = [];
+        let vaultReservesLendingMarkets = [];
+        vaultReserves.forEach((reserve) => {
+            const reserveState = vaultReservesState.get(reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserve.toBase58()} not found`);
+            }
+            vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+                { pubkey: reserve, isSigner: false, isWritable: true },
+            ]);
+            vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+                { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+            ]);
         });
         investIx.keys = investIx.keys.concat(vaultReservesAccountMetas);
+        investIx.keys = investIx.keys.concat(vaultReservesLendingMarkets);
         return [createAtaIx, investIx];
     }
+    encodeVaultName(token) {
+        const maxArray = new Uint8Array(40);
+        const s = new TextEncoder().encode(token);
+        maxArray.set(s);
+        return maxArray;
+    }
+    decodeVaultName(token) {
+        const maxArray = new Uint8Array(token);
+        let s = new TextDecoder().decode(maxArray);
+        // Remove trailing zeros and spaces
+        s = s.replace(/[\0 ]+$/, '');
+        return s;
+    }
     withdrawIxn(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
         const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId)[0];
         const withdrawAccounts = {
@@ -482,6 +645,25 @@ class KaminoVaultClient {
         withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesLendingMarkets);
         return withdrawIxn;
     }
+    async withdrawFromAvailableIxn(user, vault, vaultState, userSharesAta, userTokenAta, shareAmountLamports) {
+        const withdrawFromAvailableAccounts = {
+            user,
+            vaultState: vault.address,
+            tokenVault: vaultState.tokenVault,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            userTokenAta: userTokenAta,
+            tokenMint: vaultState.tokenMint,
+            userSharesAta: userSharesAta,
+            sharesMint: vaultState.sharesMint,
+            tokenProgram: vaultState.tokenProgram,
+            sharesTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            klendProgram: this._kaminoLendProgramId,
+        };
+        const withdrawFromAvailableArgs = {
+            sharesAmount: new anchor_1.BN(shareAmountLamports.toString()),
+        };
+        return (0, instructions_1.withdrawFromAvailable)(withdrawFromAvailableArgs, withdrawFromAvailableAccounts, this._kaminoVaultProgramId);
+    }
     async withdrawPendingFeesIxn(vault, vaultState, marketAddress, reserve, adminTokenAta) {
         const lendingMarketAuth = (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId)[0];
         const withdrawPendingFeesAccounts = {
@@ -524,6 +706,150 @@ class KaminoVaultClient {
         withdrawPendingFeesIxn.keys = withdrawPendingFeesIxn.keys.concat(vaultReservesLendingMarkets);
         return withdrawPendingFeesIxn;
     }
+    /**
+     * Sync a vault for lookup table; create and set the LUT for the vault if needed and fill it with all the needed accounts
+     * @param vault the vault to sync and set the LUT for if needed
+     * @param vaultReserves optional; the state of the reserves in the vault allocation
+     * @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 syncVaultLookupTable(vault, vaultReserves) {
+        const vaultState = await vault.getState(this._connection);
+        const allAccountsToBeInserted = [
+            vault.address,
+            vaultState.adminAuthority,
+            vaultState.baseVaultAuthority,
+            vaultState.tokenMint,
+            vaultState.tokenVault,
+            vaultState.sharesMint,
+            vaultState.tokenProgram,
+            this._kaminoLendProgramId,
+        ];
+        vaultState.vaultAllocationStrategy.forEach((allocation) => {
+            allAccountsToBeInserted.push(allocation.reserve);
+            allAccountsToBeInserted.push(allocation.ctokenVault);
+        });
+        if (vaultReserves) {
+            vaultReserves.forEach((reserve) => {
+                allAccountsToBeInserted.push(reserve.state.lendingMarket);
+                allAccountsToBeInserted.push(reserve.state.farmCollateral);
+                allAccountsToBeInserted.push(reserve.state.farmDebt);
+                allAccountsToBeInserted.push(reserve.state.liquidity.supplyVault);
+                allAccountsToBeInserted.push(reserve.state.liquidity.feeVault);
+                allAccountsToBeInserted.push(reserve.state.collateral.mintPubkey);
+                allAccountsToBeInserted.push(reserve.state.collateral.supplyVault);
+            });
+        }
+        else {
+            const vaultReservesState = await this.loadVaultReserves(vaultState);
+            vaultReservesState.forEach((reserve) => {
+                allAccountsToBeInserted.push(reserve.state.lendingMarket);
+                allAccountsToBeInserted.push(reserve.state.farmCollateral);
+                allAccountsToBeInserted.push(reserve.state.farmDebt);
+                allAccountsToBeInserted.push(reserve.state.liquidity.supplyVault);
+                allAccountsToBeInserted.push(reserve.state.liquidity.feeVault);
+                allAccountsToBeInserted.push(reserve.state.collateral.mintPubkey);
+                allAccountsToBeInserted.push(reserve.state.collateral.supplyVault);
+            });
+        }
+        if (!vaultState.vaultFarm.equals(web3_js_1.PublicKey.default)) {
+            allAccountsToBeInserted.push(vaultState.vaultFarm);
+        }
+        const setupLUTIfNeededIxs = [];
+        let lut = vaultState.vaultLookupTable;
+        if (lut.equals(web3_js_1.PublicKey.default)) {
+            const recentSlot = await this._connection.getSlot();
+            const [ixn, address] = this.getInitLookupTableIx(vaultState.adminAuthority, recentSlot);
+            setupLUTIfNeededIxs.push(ixn);
+            lut = address;
+            // set the new LUT for the vault
+            const updateVaultConfigIxs = await this.updateVaultConfigIxs(vault, new types_1.VaultConfigField.LookupTable(), lut.toString());
+            setupLUTIfNeededIxs.push(updateVaultConfigIxs.updateVaultConfigIx);
+        }
+        const ixns = [];
+        let overridenExistentAccounts = undefined;
+        if (vaultState.vaultLookupTable.equals(web3_js_1.PublicKey.default)) {
+            overridenExistentAccounts = [];
+        }
+        ixns.push(...(await this.insertIntoLookupTableIxs(vaultState.adminAuthority, lut, allAccountsToBeInserted, overridenExistentAccounts)));
+        return {
+            setupLUTIfNeededIxs,
+            syncLUTIxs: ixns,
+        };
+    }
+    getInitLookupTableIx(payer, slot) {
+        const [ixn, address] = web3_js_1.AddressLookupTableProgram.createLookupTable({
+            authority: payer,
+            payer,
+            recentSlot: slot,
+        });
+        return [ixn, address];
+    }
+    getReserveAccountsToInsertInLut(reserveState) {
+        return [
+            reserveState.lendingMarket,
+            reserveState.farmCollateral,
+            reserveState.farmDebt,
+            reserveState.liquidity.mintPubkey,
+            reserveState.liquidity.supplyVault,
+            reserveState.liquidity.feeVault,
+            reserveState.collateral.mintPubkey,
+            reserveState.collateral.supplyVault,
+        ];
+    }
+    async insertIntoLookupTableIxs(payer, lookupTable, keys, accountsInLUT) {
+        let lutContents = accountsInLUT;
+        if (!accountsInLUT) {
+            lutContents = await this.getAccountsInLUT(lookupTable);
+        }
+        else {
+            lutContents = accountsInLUT;
+        }
+        const missingAccounts = keys.filter((key) => !lutContents.includes(key) && !key.equals(web3_js_1.PublicKey.default));
+        // deduplicate missing accounts and remove default accounts and convert it back to an array
+        const missingAccountsList = new utils_2.PublicKeySet(missingAccounts).toArray();
+        const chunkSize = 20;
+        const ixns = [];
+        for (let i = 0; i < missingAccountsList.length; i += chunkSize) {
+            const chunk = missingAccountsList.slice(i, i + chunkSize);
+            const ixn = web3_js_1.AddressLookupTableProgram.extendLookupTable({
+                lookupTable,
+                authority: payer,
+                payer,
+                addresses: chunk,
+            });
+            ixns.push(ixn);
+        }
+        return ixns;
+    }
+    /**
+     *
+     * @param connection
+     * @param lookupTable
+     * @returns
+     */
+    async getAccountsInLUT(lookupTable) {
+        const lutState = await this._connection.getAddressLookupTable(lookupTable);
+        if (!lutState || !lutState.value) {
+            throw new Error(`Lookup table ${lookupTable} not found`);
+        }
+        return lutState.value.state.addresses;
+    }
+    deactivateLookupTableIx(payer, lookupTable) {
+        const ixn = web3_js_1.AddressLookupTableProgram.deactivateLookupTable({
+            authority: payer,
+            lookupTable: lookupTable,
+        });
+        return ixn;
+    }
+    /// this require the LUT to be deactivated at least 500 blocks before
+    closeLookupTableIx(payer, lookupTable) {
+        const ixn = web3_js_1.AddressLookupTableProgram.closeLookupTable({
+            authority: payer,
+            recipient: payer,
+            lookupTable: lookupTable,
+        });
+        return ixn;
+    }
     /**
      * This method returns the user shares balance for a given vault
      * @param user - user to calculate the shares balance for
@@ -1066,18 +1392,21 @@ class KaminoVaultConfig {
     performanceFeeRate;
     /** The management fee rate of the vault, expressed as a decimal */
     managementFeeRate;
+    /** The name to be stored on cain for the vault (max 40 characters). */
+    name;
     constructor(args) {
         this.admin = args.admin;
         this.tokenMint = args.tokenMint;
         this.performanceFeeRate = args.performanceFeeRate;
         this.managementFeeRate = args.managementFeeRate;
         this.tokenMintProgramId = args.tokenMintProgramId;
+        this.name = args.name;
     }
     getPerformanceFeeBps() {
-        return this.performanceFeeRate.mul(10000).toNumber();
+        return this.performanceFeeRate.mul(100).toNumber();
     }
-    getManagementFeeRate() {
-        return this.managementFeeRate.mul(10000).toNumber();
+    getManagementFeeBps() {
+        return this.managementFeeRate.mul(100).toNumber();
     }
 }
 exports.KaminoVaultConfig = KaminoVaultConfig;