@kamino-finance/klend-sdk 7.3.3 → 7.3.4

package/dist/classes/vault.js

@@ -697,6 +697,12 @@ class KaminoVaultClient {
      * @returns - an instance of DepositIxs which contains the instructions to deposit in vault and the instructions to stake the shares in the farm if the vault has a farm
      */
     async depositIxs(user, vault, tokenAmount, vaultReservesMap, farmState) {
+        return this.buildShareEntryIxs('deposit', user, vault, tokenAmount, vaultReservesMap, farmState);
+    }
+    async buySharesIxs(user, vault, tokenAmount, vaultReservesMap, farmState) {
+        return this.buildShareEntryIxs('buy', user, vault, tokenAmount, vaultReservesMap, farmState);
+    }
+    async buildShareEntryIxs(mode, 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);
@@ -721,40 +727,63 @@ class KaminoVaultClient {
         ]);
         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 tokenAmountLamports = (0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor();
+        let entryIx;
+        if (mode === 'deposit') {
+            const depositAccounts = {
+                user,
+                vaultState: vault.address,
+                tokenVault: vaultState.tokenVault,
+                tokenMint: vaultState.tokenMint,
+                baseVaultAuthority: vaultState.baseVaultAuthority,
+                sharesMint: vaultState.sharesMint,
+                userTokenAta,
+                userSharesAta,
+                tokenProgram: tokenProgramID,
+                klendProgram: this._kaminoLendProgramId,
+                sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                eventAuthority,
+                program: this._kaminoVaultProgramId,
+            };
+            const depositArgs = {
+                maxAmount: new bn_js_1.default(tokenAmountLamports.toString()),
+            };
+            entryIx = (0, instructions_1.deposit)(depositArgs, depositAccounts, undefined, this._kaminoVaultProgramId);
+        }
+        else {
+            const buyAccounts = {
+                user,
+                vaultState: vault.address,
+                tokenVault: vaultState.tokenVault,
+                tokenMint: vaultState.tokenMint,
+                baseVaultAuthority: vaultState.baseVaultAuthority,
+                sharesMint: vaultState.sharesMint,
+                userTokenAta,
+                userSharesAta,
+                tokenProgram: tokenProgramID,
+                klendProgram: this._kaminoLendProgramId,
+                sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                eventAuthority,
+                program: this._kaminoVaultProgramId,
+            };
+            const buyArgs = {
+                maxAmount: new bn_js_1.default(tokenAmountLamports.toString()),
+            };
+            entryIx = (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],
+        entryIx = this.appendRemainingAccountsForVaultReserves(entryIx, vaultReserves, vaultReservesState);
+        const result = {
+            depositIxs: [...createAtasIxs, entryIx, ...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;
+            return result;
         }
-        // if there is a farm, stake the shares
         const stakeSharesIxs = await this.stakeSharesIxs(user, vault, undefined, farmState);
-        depositIxs.stakeInFarmIfNeededIxs = stakeSharesIxs;
-        return depositIxs;
+        result.stakeInFarmIfNeededIxs = stakeSharesIxs;
+        return result;
     }
     /**
      * This function creates instructions to stake the shares in the vault farm if the vault has a farm
@@ -788,6 +817,22 @@ class KaminoVaultClient {
      * @returns an array of instructions to create missing ATAs if needed and the withdraw instructions
      */
     async withdrawIxs(user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState) {
+        return this.buildShareExitIxs('withdraw', user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState);
+    }
+    /**
+     * This function will return the missing ATA creation instructions, as well as one or multiple withdraw instructions, based on how many reserves it's needed to withdraw from. This might have to be split in multiple transactions
+     * @param user - user to sell shares for vault tokens
+     * @param vault - vault to sell shares from
+     * @param shareAmount - share amount to sell (in tokens, not lamports), in order to withdraw everything, any value > user share amount
+     * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
+     * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
+     * @param [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
+     * @returns an array of instructions to create missing ATAs if needed and the withdraw instructions
+     */
+    async sellSharesIxs(user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState) {
+        return this.buildShareExitIxs('sell', user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState);
+    }
+    async buildShareExitIxs(mode, user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState) {
         const vaultState = await vault.getState();
         const hasFarm = await vault.hasFarm();
         const withdrawIxs = {
@@ -834,10 +879,21 @@ class KaminoVaultClient {
             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.withdrawWithReserveIxs(user, vault, sharesToWithdraw, totalUserShares, slot, vaultReservesMap);
+        const hasAllocatedReserves = vaultState.vaultAllocationStrategy.some((allocation) => allocation.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+        if (hasAllocatedReserves) {
+            const reserveExitBuilder = mode === 'withdraw'
+                ? (params) => this.withdrawIx(params.user, params.vault, params.vaultState, params.marketAddress, params.reserve, params.userSharesAta, params.userTokenAta, params.shareAmountLamports, params.vaultReservesState)
+                : (params) => this.sellIx(params.user, params.vault, params.vaultState, params.marketAddress, params.reserve, params.userSharesAta, params.userTokenAta, params.shareAmountLamports, params.vaultReservesState);
+            const withdrawFromVaultIxs = await this.buildReserveExitIxs({
+                user,
+                vault,
+                vaultState,
+                shareAmount: sharesToWithdraw,
+                allUserShares: totalUserShares,
+                slot,
+                vaultReservesMap,
+                builder: reserveExitBuilder,
+            });
             withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
         }
         else {
@@ -879,8 +935,7 @@ class KaminoVaultClient {
         const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareLamportsToWithdraw);
         return [createAtaIx, withdrawFromAvailableIxn];
     }
-    async withdrawWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
-        const vaultState = await vault.getState();
+    async buildReserveExitIxs({ user, vault, vaultState, shareAmount, allUserShares, slot, vaultReservesMap, builder, }) {
         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, [
@@ -901,8 +956,10 @@ class KaminoVaultClient {
         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 (!firstReserve) {
+                throw new Error('No reserve available to satisfy withdraw request');
+            }
             if (withdrawAllShares) {
                 reserveWithSharesAmountToWithdraw.push({
                     reserve: firstReserve.reserve,
@@ -917,13 +974,11 @@ class KaminoVaultClient {
             }
         }
         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], _) => {
+            reserveAllocationAvailableLiquidityToWithdrawSorted.forEach(([key, availableLiquidityToWithdraw]) => {
                 if (tokenLeftToWithdraw.gt(0)) {
                     let tokensToWithdrawFromReserve = decimal_js_1.default.min(tokenLeftToWithdraw, availableLiquidityToWithdraw);
                     if (isFirstWithdraw) {
@@ -934,7 +989,6 @@ class KaminoVaultClient {
                         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 });
                     }
@@ -944,15 +998,24 @@ class KaminoVaultClient {
         }
         const withdrawIxs = [];
         withdrawIxs.push(createAtaIx);
-        for (let reserveIndex = 0; reserveIndex < reserveWithSharesAmountToWithdraw.length; reserveIndex++) {
-            const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
+        for (const reserveWithTokens of reserveWithSharesAmountToWithdraw) {
             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 sellIx = await this.sellIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, reserveWithTokens.shares, vaultReservesState);
-            withdrawIxs.push(sellIx);
+            const exitIx = await builder({
+                user,
+                vault,
+                vaultState,
+                marketAddress,
+                reserve: { address: reserveWithTokens.reserve, state: reserveState.state },
+                userSharesAta,
+                userTokenAta,
+                shareAmountLamports: reserveWithTokens.shares,
+                vaultReservesState,
+            });
+            withdrawIxs.push(exitIx);
         }
         return withdrawIxs;
     }
@@ -1164,6 +1227,49 @@ class KaminoVaultClient {
         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,
+                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 withdrawArgs = {
+            sharesAmount: new bn_js_1.default(shareAmountLamports.floor().toString()),
+        };
+        let withdrawIxn = (0, instructions_1.withdraw)(withdrawArgs, withdrawAccounts, undefined, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        withdrawIxn = this.appendRemainingAccountsForVaultReserves(withdrawIxn, vaultReserves, vaultReservesState);
+        return withdrawIxn;
+    }
     async withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareAmountLamports) {
         const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
         const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);