@kamino-finance/klend-sdk 7.2.6 → 7.3.0

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;
     }
@@ -1036,6 +1058,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 +1071,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 +1096,39 @@ 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 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 +1164,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 +2905,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);
 }