@kamino-finance/klend-sdk 7.3.10-beta.0 → 7.4.0-beta.1

package/dist/classes/vault.js

@@ -487,6 +487,7 @@ class KaminoVaultClient {
             entry: mode,
             data: this.getValueForModeAsBuffer(mode, value),
         };
+        await this.updateVaultConfigValidations(mode, value, vaultState);
         const vaultReserves = this.getVaultReserves(vaultState);
         const vaultReservesState = await this.loadVaultReserves(vaultState);
         let updateVaultConfigIx = (0, instructions_1.updateVaultConfig)(updateVaultConfigArgs, updateVaultConfigAccs, undefined, this._kaminoVaultProgramId);
@@ -519,6 +520,20 @@ class KaminoVaultClient {
         };
         return updateVaultConfigIxs;
     }
+    async updateVaultConfigValidations(mode, value, vaultState) {
+        if (mode.kind === new types_1.VaultConfigField.FirstLossCapitalFarm().kind ||
+            mode.kind === new types_1.VaultConfigField.Farm().kind) {
+            const farmAddress = (0, kit_1.address)(value);
+            const farmState = await dist_1.FarmState.fetch(this.getConnection(), farmAddress);
+            if (!farmState) {
+                throw new Error(`Farm ${farmAddress.toString()} not found for FirstLossCapitalFarm`);
+            }
+            if (mode.kind === new types_1.VaultConfigField.FirstLossCapitalFarm().kind &&
+                !(await this.isFlcFarmValid(farmState, vaultState))) {
+                throw new Error(`Farm ${farmAddress.toString()} is not valid for FirstLossCapitalFarm`);
+            }
+        }
+    }
     /**
      * 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.
@@ -701,7 +716,7 @@ class KaminoVaultClient {
      * @param tokenAmount - token amount to be deposited, in decimals (will be converted in lamports)
      * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. Optional. 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 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
+     * @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 as well as ixs to stake in the first loss capital farm if the vault has one - only one set on ixs so stake in a farm can be used -> staking can be either done in the farm or in the first loss capital farm
      */
     async depositIxs(user, vault, tokenAmount, vaultReservesMap, farmState) {
         return this.buildShareEntryIxs('deposit', user, vault, tokenAmount, vaultReservesMap, farmState);
@@ -784,12 +799,16 @@ class KaminoVaultClient {
         const result = {
             depositIxs: [...createAtasIxs, entryIx, ...closeAtasIxs],
             stakeInFarmIfNeededIxs: [],
+            stakeInFlcFarmIfNeededIxs: [],
         };
-        if (!(await vault.hasFarm())) {
-            return result;
+        if (await vault.hasFarm()) {
+            const stakeSharesIxs = await this.stakeSharesIxs(user, vault, undefined, farmState);
+            result.stakeInFarmIfNeededIxs = stakeSharesIxs;
+        }
+        if (await vault.hasFlcFarm()) {
+            const stakeSharesInFlcFarmIxs = await this.stakeSharesInFlcFarmIxs(user, vault, undefined, undefined);
+            result.stakeInFlcFarmIfNeededIxs = stakeSharesInFlcFarmIxs;
         }
-        const stakeSharesIxs = await this.stakeSharesIxs(user, vault, undefined, farmState);
-        result.stakeInFarmIfNeededIxs = stakeSharesIxs;
         return result;
     }
     /**
@@ -813,6 +832,27 @@ class KaminoVaultClient {
         // returns the ix to create the farm state account if needed and the ix to stake the shares
         return (0, farm_utils_1.getFarmStakeIxs)(this.getConnection(), user, sharesToStakeLamports, vaultState.vaultFarm, farmState);
     }
+    /**
+     * This function creates instructions to stake the shares in the vault firstLossCapital farm if the vault has a farm
+     * @param user - user to stake
+     * @param vault - vault to deposit into its flc farm (if the state is not provided, it will be fetched)
+     * @param [sharesAmount] - token amount to be deposited, in decimals (will be converted in lamports). Optional. If not provided, the user's share balance will be used
+     * @param [farmState] - the state of the vault flc farm, if the vault has a farm. Optional. If not provided, it will be fetched
+     * @returns - a list of instructions for the user to stake shares into the vault's firstLossCapital farm, including the creation of prerequisite accounts if needed
+     */
+    async stakeSharesInFlcFarmIxs(user, vault, sharesAmount, farmState) {
+        const vaultState = await vault.getState();
+        let sharesToStakeLamports = new decimal_js_1.default(utils_2.U64_MAX);
+        if (sharesAmount) {
+            sharesToStakeLamports = (0, utils_1.numberToLamportsDecimal)(sharesAmount, vaultState.sharesMintDecimals.toNumber());
+        }
+        // if tokens to be staked are 0 or vault has no farm there is no stake needed
+        if (sharesToStakeLamports.lte(0) || !(await vault.hasFlcFarm())) {
+            return [];
+        }
+        // returns the ix to create the farm state account if needed and the ix to stake the shares
+        return (0, farm_utils_1.getFarmStakeIxs)(this.getConnection(), user, sharesToStakeLamports, vaultState.firstLossCapitalFarm, farmState);
+    }
     /**
      * This function will return a struct with the instructions to unstake from the farm if necessary and the instructions for 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 withdraw
@@ -2044,8 +2084,9 @@ class KaminoVaultClient {
         const vaultFarmIncentivesPromise = this.getVaultRewardsAPY(vault, vaultTokenPrice, farmsClient, slotForOverview, tokensPrices);
         const vaultReservesFarmIncentivesPromise = this.getVaultReservesFarmsIncentives(vault, vaultTokenPrice, farmsClient, slotForOverview, vaultReservesState, tokensPrices);
         const vaultDelegatedFarmIncentivesPromise = this.getVaultDelegatedFarmRewardsAPY(vault, vaultTokenPrice, farmsClient, slotForOverview, tokensPrices);
+        const vaultFlcFarmStatsPromise = this.getVaultFlcFarmStats(vault);
         // all the async part of the functions above just read the vaultReservesState which is read beforehand, so excepting vaultCollateralsPromise they should do no additional network calls
-        const [vaultHoldingsWithUSDValue, vaultTheoreticalAPYs, vaultActualAPYs, totalInvestedAndBorrowed, vaultCollaterals, reservesOverview, vaultFarmIncentives, vaultReservesFarmIncentives, vaultDelegatedFarmIncentives,] = await Promise.all([
+        const [vaultHoldingsWithUSDValue, vaultTheoreticalAPYs, vaultActualAPYs, totalInvestedAndBorrowed, vaultCollaterals, reservesOverview, vaultFarmIncentives, vaultReservesFarmIncentives, vaultDelegatedFarmIncentives, vaultFlcFarmStats,] = await Promise.all([
             vaultHoldingsWithUSDValuePromise,
             vaultTheoreticalAPYPromise,
             vaultActualAPYPromise,
@@ -2055,6 +2096,7 @@ class KaminoVaultClient {
             vaultFarmIncentivesPromise,
             vaultReservesFarmIncentivesPromise,
             vaultDelegatedFarmIncentivesPromise,
+            vaultFlcFarmStatsPromise,
         ]);
         return {
             holdingsUSD: vaultHoldingsWithUSDValue,
@@ -2070,6 +2112,7 @@ class KaminoVaultClient {
             utilizationRatio: totalInvestedAndBorrowed.utilizationRatio,
             totalSupplied: totalInvestedAndBorrowed.totalInvested,
             totalSuppliedUSD: totalInvestedAndBorrowed.totalInvested.mul(vaultTokenPrice),
+            flcFarmStats: vaultFlcFarmStats,
         };
     }
     /**
@@ -2544,6 +2587,56 @@ class KaminoVaultClient {
             totalIncentivesAPY: totalIncentivesApy,
         };
     }
+    async getVaultFlcFarmStats(vaultOrState) {
+        const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState() : vaultOrState;
+        if (vaultState.firstLossCapitalFarm === lib_1.DEFAULT_PUBLIC_KEY) {
+            return undefined;
+        }
+        const kFarmsClient = new farms_sdk_1.Farms(this.getConnection());
+        const flcFarmState = await dist_1.FarmState.fetch(this.getConnection(), vaultState.firstLossCapitalFarm);
+        if (!flcFarmState) {
+            return undefined;
+        }
+        if (!(await this.isFlcFarmValid(flcFarmState, vaultState))) {
+            return undefined;
+        }
+        const userStates = await kFarmsClient.getAllUserStatesForFarm(vaultState.firstLossCapitalFarm);
+        const pendingUnstakes = [];
+        for (const { userState, key } of userStates) {
+            const pendingWithdrawalUnstake = new decimal_js_1.default((0, dist_1.scaleDownWads)(userState.pendingWithdrawalUnstakeScaled));
+            if (pendingWithdrawalUnstake.gt(0)) {
+                pendingUnstakes.push({
+                    userStateAddress: key,
+                    pendingUnstakeAmountLamports: pendingWithdrawalUnstake,
+                    pendingUnstakeAvailableAtTimestamp: userState.pendingWithdrawalUnstakeTs.toNumber(),
+                });
+            }
+        }
+        return {
+            address: vaultState.firstLossCapitalFarm,
+            farmState: flcFarmState,
+            totalStakedShares: new decimal_js_1.default((0, dist_1.scaleDownWads)(flcFarmState.totalActiveStakeScaled)),
+            withdrawalCooldownDurationSeconds: flcFarmState.withdrawalCooldownPeriod,
+            isPendingUnstake: pendingUnstakes.length > 0,
+            pendingUnstakeInfo: pendingUnstakes,
+        };
+    }
+    async isFlcFarmValid(flcFarmState, vaultOrState) {
+        const vaultState = 'getState' in vaultOrState ? await vaultOrState.getState() : vaultOrState;
+        if (flcFarmState.timeUnit !== 0) {
+            // timeUnit = 0 -> seconds
+            return false;
+        }
+        if (flcFarmState.withdrawalCooldownPeriod === 0) {
+            // invalid FLC farm, should have > 0 withdrawal cooldown
+            return false;
+        }
+        if (flcFarmState.token.mint !== vaultState.sharesMint) {
+            // staked token mint should be the vault shares mint
+            return false;
+        }
+        return true;
+    }
     /// reads the pending rewards for a user in the vault farm
     /// @param user - the user address
     /// @param vault - the vault
@@ -2856,6 +2949,10 @@ class KaminoVault {
         const state = await this.getState();
         return state.vaultFarm !== lib_1.DEFAULT_PUBLIC_KEY;
     }
+    async hasFlcFarm() {
+        const state = await this.getState();
+        return state.firstLossCapitalFarm !== lib_1.DEFAULT_PUBLIC_KEY;
+    }
     /**
      * This will return an VaultHoldings object which contains the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve
      * @returns an VaultHoldings object representing the amount available (uninvested) in vault, total amount invested in reseves and a breakdown of the amount invested in each reserve