@kamino-finance/klend-sdk 7.3.0 → 7.3.1

package/dist/classes/vault.js

@@ -755,6 +755,67 @@ class KaminoVaultClient {
         depositIxs.stakeInFarmIfNeededIxs = stakeSharesIxs;
         return depositIxs;
     }
+    // todo (silviu): after all tx indexing works for buy/sell ixs remove this function and use the buyIx in the deposit function above
+    async buySharesIxs(user, vault, tokenAmount, vaultReservesMap, farmState) {
+        const vaultState = await vault.getState();
+        const tokenProgramID = vaultState.tokenProgram;
+        const userTokenAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.tokenMint, user.address, tokenProgramID);
+        const createAtasIxs = [];
+        const closeAtasIxs = [];
+        if (vaultState.tokenMint === lib_1.WRAPPED_SOL_MINT) {
+            const [{ ata: wsolAta, createAtaIx: createWsolAtaIxn }] = await (0, utils_2.createAtasIdempotent)(user, [
+                {
+                    mint: lib_1.WRAPPED_SOL_MINT,
+                    tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                },
+            ]);
+            createAtasIxs.push(createWsolAtaIxn);
+            const transferWsolIxs = (0, lib_1.getTransferWsolIxs)(user, wsolAta, (0, kit_1.lamports)(BigInt((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).ceil().toString())));
+            createAtasIxs.push(...transferWsolIxs);
+        }
+        const [{ ata: userSharesAta, createAtaIx: createSharesAtaIxs }] = await (0, utils_2.createAtasIdempotent)(user, [
+            {
+                mint: vaultState.sharesMint,
+                tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            },
+        ]);
+        createAtasIxs.push(createSharesAtaIxs);
+        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+        const buyAccounts = {
+            user: user,
+            vaultState: vault.address,
+            tokenVault: vaultState.tokenVault,
+            tokenMint: vaultState.tokenMint,
+            baseVaultAuthority: vaultState.baseVaultAuthority,
+            sharesMint: vaultState.sharesMint,
+            userTokenAta: userTokenAta,
+            userSharesAta: userSharesAta,
+            tokenProgram: tokenProgramID,
+            klendProgram: this._kaminoLendProgramId,
+            sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+            eventAuthority: eventAuthority,
+            program: this._kaminoVaultProgramId,
+        };
+        const buyArgs = {
+            maxAmount: new bn_js_1.default((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor().toString()),
+        };
+        let buyIx = (0, instructions_1.buy)(buyArgs, buyAccounts, undefined, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        buyIx = this.appendRemainingAccountsForVaultReserves(buyIx, vaultReserves, vaultReservesState);
+        const depositIxs = {
+            depositIxs: [...createAtasIxs, buyIx, ...closeAtasIxs],
+            stakeInFarmIfNeededIxs: [],
+        };
+        // if there is no farm, we can return the deposit instructions, otherwise include the stake ix in the response
+        if (!(await vault.hasFarm())) {
+            return depositIxs;
+        }
+        // if there is a farm, stake the shares
+        const stakeSharesIxs = await this.stakeSharesIxs(user, vault, undefined, farmState);
+        depositIxs.stakeInFarmIfNeededIxs = stakeSharesIxs;
+        return depositIxs;
+    }
     /**
      * This function creates instructions to stake the shares in the vault farm if the vault has a farm
      * @param user - user to stake
@@ -865,6 +926,85 @@ class KaminoVaultClient {
         }
         return withdrawIxs;
     }
+    async sellSharesIxs(user, vault, shareAmountToWithdraw, slot, vaultReservesMap, farmState) {
+        const vaultState = await vault.getState();
+        const hasFarm = await vault.hasFarm();
+        const withdrawIxs = {
+            unstakeFromFarmIfNeededIxs: [],
+            withdrawIxs: [],
+            postWithdrawIxs: [],
+        };
+        // compute the total shares the user has (in ATA + in farm) and check if they want to withdraw everything or just a part
+        let userSharesAtaBalance = new decimal_js_1.default(0);
+        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
+        const userSharesAtaState = await (0, token_2022_1.fetchMaybeToken)(this.getConnection(), userSharesAta);
+        if (userSharesAtaState.exists) {
+            const userSharesAtaBalanceInLamports = (0, lib_1.getTokenBalanceFromAccountInfoLamports)(userSharesAtaState);
+            userSharesAtaBalance = userSharesAtaBalanceInLamports.div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toString()));
+        }
+        let userSharesInFarm = new decimal_js_1.default(0);
+        if (hasFarm) {
+            userSharesInFarm = await (0, farm_utils_1.getUserSharesInTokensStakedInFarm)(this.getConnection(), user.address, vaultState.vaultFarm, vaultState.sharesMintDecimals.toNumber());
+        }
+        let sharesToWithdraw = shareAmountToWithdraw;
+        const totalUserShares = userSharesAtaBalance.add(userSharesInFarm);
+        let withdrawAllShares = false;
+        if (sharesToWithdraw.gt(totalUserShares)) {
+            sharesToWithdraw = new decimal_js_1.default(utils_2.U64_MAX.toString()).div(new decimal_js_1.default(10).pow(vaultState.sharesMintDecimals.toString()));
+            withdrawAllShares = true;
+        }
+        // if not enough shares in ATA unstake from farm
+        const sharesInAtaAreEnoughForWithdraw = sharesToWithdraw.lte(userSharesAtaBalance);
+        if (hasFarm && !sharesInAtaAreEnoughForWithdraw && userSharesInFarm.gt(0)) {
+            // if we need to unstake we need to make sure share ata is created
+            const [{ createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
+                {
+                    mint: vaultState.sharesMint,
+                    tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                },
+            ]);
+            withdrawIxs.unstakeFromFarmIfNeededIxs.push(createAtaIx);
+            let shareLamportsToWithdraw = new decimal_js_1.default(utils_2.U64_MAX.toString());
+            if (!withdrawAllShares) {
+                const sharesToWithdrawFromFarm = sharesToWithdraw.sub(userSharesAtaBalance);
+                shareLamportsToWithdraw = (0, kliquidity_sdk_1.collToLamportsDecimal)(sharesToWithdrawFromFarm, vaultState.sharesMintDecimals.toNumber());
+            }
+            const unstakeAndWithdrawFromFarmIxs = await (0, farm_utils_1.getFarmUnstakeAndWithdrawIxs)(this.getConnection(), user, shareLamportsToWithdraw, vaultState.vaultFarm, farmState);
+            withdrawIxs.unstakeFromFarmIfNeededIxs.push(unstakeAndWithdrawFromFarmIxs.unstakeIx);
+            withdrawIxs.unstakeFromFarmIfNeededIxs.push(unstakeAndWithdrawFromFarmIxs.withdrawIx);
+        }
+        // if the vault has allocations withdraw otherwise wtihdraw from available ix
+        const vaultAllocation = vaultState.vaultAllocationStrategy.find((allocation) => allocation.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+        if (vaultAllocation) {
+            const withdrawFromVaultIxs = await this.sellSharesWithReserveIxs(user, vault, sharesToWithdraw, totalUserShares, slot, vaultReservesMap);
+            withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
+        }
+        else {
+            const withdrawFromVaultIxs = await this.withdrawFromAvailableIxs(user, vault, sharesToWithdraw);
+            withdrawIxs.withdrawIxs = withdrawFromVaultIxs;
+        }
+        // if the vault is for SOL return the ix to unwrap the SOL
+        if (vaultState.tokenMint === lib_1.WRAPPED_SOL_MINT) {
+            const userWsolAta = await (0, lib_1.getAssociatedTokenAddress)(lib_1.WRAPPED_SOL_MINT, user.address);
+            const unwrapIx = (0, token_2022_1.getCloseAccountInstruction)({
+                account: userWsolAta,
+                owner: user,
+                destination: user.address,
+            }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+            withdrawIxs.postWithdrawIxs.push(unwrapIx);
+        }
+        // if we burn all of user's shares close its shares ATA
+        const burnAllUserShares = sharesToWithdraw.gt(totalUserShares);
+        if (burnAllUserShares) {
+            const closeAtaIx = (0, token_2022_1.getCloseAccountInstruction)({
+                account: userSharesAta,
+                owner: user,
+                destination: user.address,
+            }, { programAddress: token_1.TOKEN_PROGRAM_ADDRESS });
+            withdrawIxs.postWithdrawIxs.push(closeAtaIx);
+        }
+        return withdrawIxs;
+    }
     async withdrawFromAvailableIxs(user, vault, shareAmount) {
         const vaultState = await vault.getState();
         const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
@@ -878,6 +1018,83 @@ class KaminoVaultClient {
         const withdrawFromAvailableIxn = await this.withdrawFromAvailableIx(user, vault, vaultState, userSharesAta, userTokenAta, shareLamportsToWithdraw);
         return [createAtaIx, withdrawFromAvailableIxn];
     }
+    async sellSharesWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
+        const vaultState = await vault.getState();
+        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
+        const userSharesAta = await (0, lib_1.getAssociatedTokenAddress)(vaultState.sharesMint, user.address);
+        const [{ ata: userTokenAta, createAtaIx }] = await (0, utils_2.createAtasIdempotent)(user, [
+            {
+                mint: vaultState.tokenMint,
+                tokenProgram: vaultState.tokenProgram,
+            },
+        ]);
+        const withdrawAllShares = shareAmount.gte(allUserShares);
+        const actualSharesToWithdraw = shareAmount.lte(allUserShares) ? shareAmount : allUserShares;
+        const shareLamportsToWithdraw = (0, kliquidity_sdk_1.collToLamportsDecimal)(actualSharesToWithdraw, vaultState.sharesMintDecimals.toNumber());
+        const tokensPerShare = await this.getTokensPerShareSingleVault(vault, slot);
+        const sharesPerToken = new decimal_js_1.default(1).div(tokensPerShare);
+        const tokensToWithdraw = shareLamportsToWithdraw.mul(tokensPerShare);
+        let tokenLeftToWithdraw = tokensToWithdraw;
+        const availableTokens = new decimal_js_1.default(vaultState.tokenAvailable.toString());
+        tokenLeftToWithdraw = tokenLeftToWithdraw.sub(availableTokens);
+        const reserveWithSharesAmountToWithdraw = [];
+        let isFirstWithdraw = true;
+        if (tokenLeftToWithdraw.lte(0)) {
+            // Availabe enough to withdraw all - using the first existent reserve
+            const firstReserve = vaultState.vaultAllocationStrategy.find((reserve) => reserve.reserve !== lib_1.DEFAULT_PUBLIC_KEY);
+            if (withdrawAllShares) {
+                reserveWithSharesAmountToWithdraw.push({
+                    reserve: firstReserve.reserve,
+                    shares: new decimal_js_1.default(utils_2.U64_MAX.toString()),
+                });
+            }
+            else {
+                reserveWithSharesAmountToWithdraw.push({
+                    reserve: firstReserve.reserve,
+                    shares: shareLamportsToWithdraw,
+                });
+            }
+        }
+        else {
+            // Get decreasing order sorted available liquidity to withdraw from each reserve allocated to
+            const reserveAllocationAvailableLiquidityToWithdraw = await this.getReserveAllocationAvailableLiquidityToWithdraw(vault, slot, vaultReservesState);
+            // sort
+            const reserveAllocationAvailableLiquidityToWithdrawSorted = [
+                ...reserveAllocationAvailableLiquidityToWithdraw.entries(),
+            ].sort((a, b) => b[1].sub(a[1]).toNumber());
+            reserveAllocationAvailableLiquidityToWithdrawSorted.forEach(([key, availableLiquidityToWithdraw], _) => {
+                if (tokenLeftToWithdraw.gt(0)) {
+                    let tokensToWithdrawFromReserve = decimal_js_1.default.min(tokenLeftToWithdraw, availableLiquidityToWithdraw);
+                    if (isFirstWithdraw) {
+                        tokensToWithdrawFromReserve = tokensToWithdrawFromReserve.add(availableTokens);
+                        isFirstWithdraw = false;
+                    }
+                    if (withdrawAllShares) {
+                        reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: new decimal_js_1.default(utils_2.U64_MAX.toString()) });
+                    }
+                    else {
+                        // round up to the nearest integer the shares to withdraw
+                        const sharesToWithdrawFromReserve = tokensToWithdrawFromReserve.mul(sharesPerToken).floor();
+                        reserveWithSharesAmountToWithdraw.push({ reserve: key, shares: sharesToWithdrawFromReserve });
+                    }
+                    tokenLeftToWithdraw = tokenLeftToWithdraw.sub(tokensToWithdrawFromReserve);
+                }
+            });
+        }
+        const withdrawIxs = [];
+        withdrawIxs.push(createAtaIx);
+        for (let reserveIndex = 0; reserveIndex < reserveWithSharesAmountToWithdraw.length; reserveIndex++) {
+            const reserveWithTokens = reserveWithSharesAmountToWithdraw[reserveIndex];
+            const reserveState = vaultReservesState.get(reserveWithTokens.reserve);
+            if (reserveState === undefined) {
+                throw new Error(`Reserve ${reserveWithTokens.reserve} not found in vault reserves map`);
+            }
+            const marketAddress = reserveState.state.lendingMarket;
+            const withdrawFromReserveIx = await this.sellIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, reserveWithTokens.shares, vaultReservesState);
+            withdrawIxs.push(withdrawFromReserveIx);
+        }
+        return withdrawIxs;
+    }
     async withdrawWithReserveIxs(user, vault, shareAmount, allUserShares, slot, vaultReservesMap) {
         const vaultState = await vault.getState();
         const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
@@ -1120,6 +1337,49 @@ class KaminoVaultClient {
             return buffer;
         }
     }
+    async sellIx(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
+        const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId);
+        const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);
+        const eventAuthority = await getEventAuthorityPda(this._kaminoVaultProgramId);
+        const sellAccounts = {
+            withdrawFromAvailable: {
+                user,
+                vaultState: vault.address,
+                globalConfig: globalConfig,
+                tokenVault: vaultState.tokenVault,
+                baseVaultAuthority: vaultState.baseVaultAuthority,
+                userTokenAta: userTokenAta,
+                tokenMint: vaultState.tokenMint,
+                userSharesAta: userSharesAta,
+                sharesMint: vaultState.sharesMint,
+                tokenProgram: vaultState.tokenProgram,
+                sharesTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                klendProgram: this._kaminoLendProgramId,
+                eventAuthority: eventAuthority,
+                program: this._kaminoVaultProgramId,
+            },
+            withdrawFromReserveAccounts: {
+                vaultState: vault.address,
+                reserve: reserve.address,
+                ctokenVault: await getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
+                lendingMarket: marketAddress,
+                lendingMarketAuthority: lendingMarketAuth,
+                reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
+                reserveCollateralMint: reserve.state.collateral.mintPubkey,
+                reserveCollateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
+                instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
+            },
+            eventAuthority: eventAuthority,
+            program: this._kaminoVaultProgramId,
+        };
+        const sellArgs = {
+            sharesAmount: new bn_js_1.default(shareAmountLamports.floor().toString()),
+        };
+        let sellIxn = (0, instructions_1.sell)(sellArgs, sellAccounts, undefined, this._kaminoVaultProgramId);
+        const vaultReserves = this.getVaultReserves(vaultState);
+        sellIxn = this.appendRemainingAccountsForVaultReserves(sellIxn, vaultReserves, vaultReservesState);
+        return sellIxn;
+    }
     async withdrawIx(user, vault, vaultState, marketAddress, reserve, userSharesAta, userTokenAta, shareAmountLamports, vaultReservesState) {
         const [lendingMarketAuth] = await (0, utils_2.lendingMarketAuthPda)(marketAddress, this._kaminoLendProgramId);
         const globalConfig = await getKvaultGlobalConfigPda(this._kaminoVaultProgramId);