@voltr/vault-sdk 1.0.1 → 1.0.3

package/dist/client.d.ts

@@ -179,7 +179,7 @@ export declare class VoltrClient extends AccountUtils {
      * ```
      */
     createInitializeVaultIx(vaultParams: VaultParams, { vault, vaultAssetMint, admin, manager, payer, }: {
-        vault: Keypair;
+        vault: PublicKey;
         vaultAssetMint: PublicKey;
         admin: PublicKey;
         manager: PublicKey;
@@ -817,10 +817,14 @@ export declare class VoltrClient extends AccountUtils {
      * ```
      */
     getAllPendingWithdrawalsForVault(vault: PublicKey): Promise<{
-        amountAssetToWithdraw: number;
-        withdrawableFromTs: BN;
+        amountAssetToWithdrawEffective: number;
+        amountAssetToWithdrawAtRequest: number;
+        amountAssetToWithdrawAtPresent: number;
+        amountLpEscrowed: number;
+        withdrawableFromTs: number;
     }[]>;
     calculateLockedProfit(lastUpdatedLockedProfit: BN, lockedProfitDegradationDuration: BN, currentTime: BN): BN;
+    calculateAssetsForWithdrawHelper(vaultTotalValue: BN, vaultLastUpdatedLockedProfit: BN, vaultLockedProfitDegradationDuration: BN, vaultAccumulatedLpAdminFees: BN, vaultAccumulatedLpManagerFees: BN, vaultAccumulatedLpProtocolFees: BN, vaultRedemptionFee: number, lpSupply: BN, lpAmount: BN): BN;
     /**
      * Calculates the amount of assets that would be received for a given LP token amount
      *

package/dist/client.js

@@ -303,18 +303,23 @@ class VoltrClient extends AccountUtils {
      * ```
      */
     async createInitializeVaultIx(vaultParams, { vault, vaultAssetMint, admin, manager, payer, }) {
-        const addresses = this.findVaultAddresses(vault.publicKey);
+        const addresses = this.findVaultAddresses(vault);
         const vaultAssetIdleAta = (0, spl_token_1.getAssociatedTokenAddressSync)(vaultAssetMint, addresses.vaultAssetIdleAuth, true);
+        const vaultAssetMintAccount = await this.provider.connection.getAccountInfo(vaultAssetMint);
+        const assetTokenProgram = vaultAssetMintAccount?.owner;
+        if (!assetTokenProgram) {
+            throw new Error("Vault asset mint not found");
+        }
         return await this.vaultProgram.methods
             .initializeVault(vaultParams.config, vaultParams.name, vaultParams.description)
             .accounts({
             payer,
             admin,
             manager,
-            vault: vault.publicKey,
+            vault,
             vaultAssetMint,
             vaultAssetIdleAta,
-            assetTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            assetTokenProgram,
         })
             .instruction();
     }
@@ -926,12 +931,25 @@ class VoltrClient extends AccountUtils {
      */
     async getAllPendingWithdrawalsForVault(vault) {
         const requestWithdrawVaultReceipts = await this.fetchAllRequestWithdrawVaultReceiptsOfVault(vault);
+        const vaultAccount = await this.fetchVaultAccount(vault);
+        const lpMint = this.findVaultLpMint(vault);
+        const lp = await (0, spl_token_1.getMint)(this.conn, lpMint);
         return requestWithdrawVaultReceipts.map((receipt) => {
             const amountAssetToWithdrawDecimal = (0, decimals_1.convertDecimalBitsToDecimal)(receipt.account.amountAssetToWithdrawDecimalBits);
-            const amountAssetToWithdraw = amountAssetToWithdrawDecimal.toNumber();
+            const amountAssetToWithdrawAtRequest = amountAssetToWithdrawDecimal.toNumber();
+            const amountLpEscrowed = receipt.account.amountLpEscrowed;
+            const amountAssetToWithdrawAtPresent = this.calculateAssetsForWithdrawHelper(vaultAccount.asset.totalValue, vaultAccount.lockedProfitState.lastUpdatedLockedProfit, vaultAccount.vaultConfiguration.lockedProfitDegradationDuration, vaultAccount.feeState.accumulatedLpAdminFees, vaultAccount.feeState.accumulatedLpManagerFees, vaultAccount.feeState.accumulatedLpProtocolFees, vaultAccount.feeConfiguration.redemptionFee, new bn_js_1.default(lp.supply.toString()), amountLpEscrowed).toNumber();
+            // Get the capped amount of asset to withdraw
+            // If the latest amount of asset to withdraw is greater than the initial amount of asset to withdraw,
+            // then return the initial amount of asset to withdraw
+            // Otherwise, return the latest amount of asset to withdraw
+            const amountAssetToWithdrawEffective = Math.min(amountAssetToWithdrawAtPresent, amountAssetToWithdrawAtRequest);
             return {
-                amountAssetToWithdraw,
-                withdrawableFromTs: receipt.account.withdrawableFromTs,
+                amountAssetToWithdrawEffective,
+                amountAssetToWithdrawAtRequest,
+                amountAssetToWithdrawAtPresent,
+                amountLpEscrowed: amountLpEscrowed.toNumber(),
+                withdrawableFromTs: receipt.account.withdrawableFromTs.toNumber(),
             };
         });
     }
@@ -947,6 +965,26 @@ class VoltrClient extends AccountUtils {
         else
             return lockedProfit;
     }
+    calculateAssetsForWithdrawHelper(vaultTotalValue, vaultLastUpdatedLockedProfit, vaultLockedProfitDegradationDuration, vaultAccumulatedLpAdminFees, vaultAccumulatedLpManagerFees, vaultAccumulatedLpProtocolFees, vaultRedemptionFee, lpSupply, lpAmount) {
+        if (lpSupply <= new bn_js_1.default(0))
+            throw new Error("Invalid LP supply");
+        if (vaultTotalValue <= new bn_js_1.default(0))
+            throw new Error("Invalid total assets");
+        const lockedProfit = this.calculateLockedProfit(vaultLastUpdatedLockedProfit, vaultLockedProfitDegradationDuration, new bn_js_1.default(Date.now() / 1000));
+        const totalUnlockedValue = vaultTotalValue.sub(lockedProfit);
+        const unharvestedFeesLp = vaultAccumulatedLpAdminFees
+            .add(vaultAccumulatedLpManagerFees)
+            .add(vaultAccumulatedLpProtocolFees);
+        const lpSupplyInclFees = lpSupply.add(unharvestedFeesLp);
+        // asset_to_redeem_pre_fee = amount * (total_asset_pre_withdraw / total_lp_supply_pre_withdraw)
+        // asset_to_redeem_post_fee = asset_to_redeem_pre_fee * (10000 - redemption_fee_bps) / 10000
+        const assetToRedeemNumerator = lpAmount
+            .mul(totalUnlockedValue)
+            .mul(new bn_js_1.default(10000 - vaultRedemptionFee));
+        const assetToRedeemDenominator = lpSupplyInclFees.mul(new bn_js_1.default(10000));
+        const amount = assetToRedeemNumerator.div(assetToRedeemDenominator);
+        return amount;
+    }
     /**
      * Calculates the amount of assets that would be received for a given LP token amount
      *
@@ -968,28 +1006,9 @@ class VoltrClient extends AccountUtils {
     async calculateAssetsForWithdraw(vaultPk, lpAmount) {
         try {
             const vault = await this.fetchVaultAccount(vaultPk);
-            const totalValue = vault.asset.totalValue;
-            const lockedProfit = this.calculateLockedProfit(vault.lockedProfitState.lastUpdatedLockedProfit, vault.vaultConfiguration.lockedProfitDegradationDuration, new bn_js_1.default(Date.now() / 1000));
-            const totalUnlockedValue = totalValue.sub(lockedProfit);
             const lpMint = this.findVaultLpMint(vaultPk);
             const lp = await (0, spl_token_1.getMint)(this.conn, lpMint);
-            const lpSupply = new bn_js_1.default(lp.supply.toString());
-            // Validate inputs
-            if (lpSupply <= new bn_js_1.default(0))
-                throw new Error("Invalid LP supply");
-            if (totalValue <= new bn_js_1.default(0))
-                throw new Error("Invalid total assets");
-            const unharvestedFeesLp = vault.feeState.accumulatedLpAdminFees
-                .add(vault.feeState.accumulatedLpManagerFees)
-                .add(vault.feeState.accumulatedLpProtocolFees);
-            const lpSupplyInclFees = lpSupply.add(unharvestedFeesLp);
-            // asset_to_redeem_pre_fee = amount * (total_asset_pre_withdraw / total_lp_supply_pre_withdraw)
-            // asset_to_redeem_post_fee = asset_to_redeem_pre_fee * (10000 - redemption_fee_bps) / 10000
-            const assetToRedeemNumerator = lpAmount
-                .mul(totalUnlockedValue)
-                .mul(new bn_js_1.default(10000 - vault.feeConfiguration.redemptionFee));
-            const assetToRedeemDenominator = lpSupplyInclFees.mul(new bn_js_1.default(10000));
-            const amount = assetToRedeemNumerator.div(assetToRedeemDenominator);
+            const amount = this.calculateAssetsForWithdrawHelper(vault.asset.totalValue, vault.lockedProfitState.lastUpdatedLockedProfit, vault.vaultConfiguration.lockedProfitDegradationDuration, vault.feeState.accumulatedLpAdminFees, vault.feeState.accumulatedLpManagerFees, vault.feeState.accumulatedLpProtocolFees, vault.feeConfiguration.redemptionFee, new bn_js_1.default(lp.supply.toString()), lpAmount);
             return amount;
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltr/vault-sdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "SDK for interacting with Voltr Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",