@kamino-finance/klend-sdk 7.3.1 → 7.3.2

package/dist/classes/vault.js

@@ -696,67 +696,6 @@ 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) {
-        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 depositAccounts = {
-            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 depositArgs = {
-            maxAmount: new bn_js_1.default((0, utils_1.numberToLamportsDecimal)(tokenAmount, vaultState.tokenMintDecimals.toNumber()).floor().toString()),
-        };
-        let depositIx = (0, instructions_1.deposit)(depositArgs, depositAccounts, undefined, this._kaminoVaultProgramId);
-        const vaultReserves = this.getVaultReserves(vaultState);
-        const vaultReservesState = vaultReservesMap ? vaultReservesMap : await this.loadVaultReserves(vaultState);
-        depositIx = this.appendRemainingAccountsForVaultReserves(depositIx, vaultReserves, vaultReservesState);
-        const depositIxs = {
-            depositIxs: [...createAtasIxs, depositIx, ...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;
-    }
-    // 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);
@@ -926,85 +865,6 @@ 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);
@@ -1018,83 +878,6 @@ 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);
@@ -1167,8 +950,8 @@ class KaminoVaultClient {
                 throw new Error(`Reserve ${reserveWithTokens.reserve} not found in vault reserves map`);
             }
             const marketAddress = reserveState.state.lendingMarket;
-            const withdrawFromReserveIx = await this.withdrawIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, reserveWithTokens.shares, vaultReservesState);
-            withdrawIxs.push(withdrawFromReserveIx);
+            const sellIx = await this.sellIx(user, vault, vaultState, marketAddress, { address: reserveWithTokens.reserve, state: reserveState.state }, userSharesAta, userTokenAta, reserveWithTokens.shares, vaultReservesState);
+            withdrawIxs.push(sellIx);
         }
         return withdrawIxs;
     }
@@ -1380,49 +1163,6 @@ 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);