@voltr/vault-sdk 0.2.0 → 1.0.0

package/dist/client.js

@@ -32,9 +32,13 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VoltrClient = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
+const bn_js_1 = __importDefault(require("bn.js"));
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const constants_1 = require("./constants");
@@ -227,6 +231,21 @@ class VoltrClient extends AccountUtils {
             directWithdrawInitReceipt,
         };
     }
+    /**
+     * Finds the request withdraw vault receipt address
+     * @param vault - Public key of the vault
+     * @param user - Public key of the user
+     * @returns The PDA for the request withdraw vault receipt
+     *
+     * @example
+     * ```typescript
+     * const requestWithdrawVaultReceipt = client.findRequestWithdrawVaultReceipt(vaultPubkey, userPubkey);
+     * ```
+     */
+    findRequestWithdrawVaultReceipt(vault, user) {
+        const [requestWithdrawVaultReceipt] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.SEEDS.REQUEST_WITHDRAW_VAULT_RECEIPT, vault.toBuffer(), user.toBuffer()], this.vaultProgram.programId);
+        return requestWithdrawVaultReceipt;
+    }
     // --------------------------------------- Vault Instructions
     /**
      * Creates an instruction to initialize a new vault
@@ -235,10 +254,14 @@ class VoltrClient extends AccountUtils {
      * @param {VaultConfig} vaultParams.config - Vault configuration settings
      * @param {BN} vaultParams.config.maxCap - Maximum capacity of the vault
      * @param {BN} vaultParams.config.startAtTs - Vault start timestamp in seconds
+     * @param {BN} vaultParams.config.lockedProfitDegradationDuration - Locked profit degradation duration in seconds
      * @param {number} vaultParams.config.managerManagementFee - Manager's management fee in basis points (e.g., 50 = 0.5%)
      * @param {number} vaultParams.config.managerPerformanceFee - Manager's performance fee in basis points (e.g., 1000 = 10%)
      * @param {number} vaultParams.config.adminManagementFee - Admin's management fee in basis points (e.g., 50 = 0.5%)
      * @param {number} vaultParams.config.adminPerformanceFee - Admin's performance fee in basis points (e.g., 1000 = 10%)
+     * @param {number} vaultParams.config.redemptionFee - Redemption fee in basis points (e.g., 10 = 0.1%)
+     * @param {number} vaultParams.config.issuanceFee - Issuance fee in basis points (e.g., 10 = 0.1%)
+     * @param {BN} vaultParams.config.withdrawalWaitingPeriod - Withdrawal waiting period in seconds
      * @param {string} vaultParams.name - Name of the vault
      * @param {string} vaultParams.description - Description of the vault
      * @param {Object} params - Additional parameters for initializing the vault
@@ -256,6 +279,10 @@ class VoltrClient extends AccountUtils {
      *     config: {
      *       maxCap: new BN('1000000000'),
      *       startAtTs: new BN(Math.floor(Date.now() / 1000)),
+     *       lockedProfitDegradationDuration: new BN(3600), // 1 hour
+     *       redemptionFee: 10,
+     *       issuanceFee: 10,
+     *       withdrawalWaitingPeriod: new BN(3600), // 1 hour
      *       managerManagementFee: 50,  // 0.5%
      *       managerPerformanceFee: 1000,  // 10%
      *       adminManagementFee: 50,  // 0.5%
@@ -365,29 +392,86 @@ class VoltrClient extends AccountUtils {
             .instruction();
     }
     /**
-     * Creates a withdraw instruction for a vault
+     * Creates a request withdraw instruction for a vault
      *
-     * @param {WithdrawVaultArgs} obj - Arguments for withdrawing from the vault
-     * @param {BN} obj.amount - Amount of LP tokens to withdraw
-     * @param {boolean} obj.isAmountInLp - Whether the amount is in LP tokens
-     * @param {boolean} obj.isWithdrawAll - Whether to withdraw all assets
-     * @param {Object} params - Withdraw parameters
+     * @param {RequestWithdrawVaultArgs} requestWithdrawArgs - Arguments for withdrawing from the vault
+     * @param {BN} requestWithdrawArgs.amount - Amount of LP tokens to withdraw
+     * @param {boolean} requestWithdrawArgs.isAmountInLp - Whether the amount is in LP tokens
+     * @param {boolean} requestWithdrawArgs.isWithdrawAll - Whether to withdraw all assets
+     * @param {Object} params - Request withdraw parameters
+     * @param {PublicKey} params.payer - Public key of the payer
      * @param {PublicKey} params.userAuthority - Public key of the user authority
      * @param {PublicKey} params.vault - Public key of the vault
-     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
-     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
      * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawal
      *
      * @throws {Error} If the instruction creation fails
      *
      * @example
-     * const ix = await client.createWithdrawVaultIx(
+     * const ix = await client.createRequestWithdrawVaultIx(
      *   {
      *     amount: new BN('1000000000'),
      *     isAmountInLp: true,
      *     isWithdrawAll: false,
      *   },
      *   {
+     *     payer: payerPubkey,
+     *     userAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *   }
+     * );
+     */
+    async createRequestWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }, { payer, userAuthority, vault, }) {
+        return await this.vaultProgram.methods
+            .requestWithdrawVault(amount, isAmountInLp, isWithdrawAll)
+            .accounts({
+            payer,
+            userTransferAuthority: userAuthority,
+            vault,
+        })
+            .instruction();
+    }
+    /**
+     * Creates a cancel withdraw instruction for a vault
+     *
+     * @param {Object} params - Cancel withdraw request parameters
+     * @param {PublicKey} params.userAuthority - Public key of the user authority
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawal
+     *
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * const ix = await client.createCancelRequestWithdrawVaultIx(
+     *   {
+     *     userAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *   }
+     * );
+     */
+    async createCancelRequestWithdrawVaultIx({ userAuthority, vault, }) {
+        return await this.vaultProgram.methods
+            .cancelRequestWithdrawVault()
+            .accounts({
+            userTransferAuthority: userAuthority,
+            vault,
+        })
+            .instruction();
+    }
+    /**
+     * Creates a withdraw instruction for a vault
+     *
+     * @param {Object} params - Withdraw parameters
+     * @param {PublicKey} params.userAuthority - Public key of the user authority
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawal
+     *
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * const ix = await client.createWithdrawVaultIx(
+     *   {
      *     userAuthority: userPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
@@ -395,9 +479,9 @@ class VoltrClient extends AccountUtils {
      *   }
      * );
      */
-    async createWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
+    async createWithdrawVaultIx({ userAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
         return await this.vaultProgram.methods
-            .withdrawVault(amount, isAmountInLp, isWithdrawAll)
+            .withdrawVault()
             .accounts({
             userTransferAuthority: userAuthority,
             vault,
@@ -662,10 +746,7 @@ class VoltrClient extends AccountUtils {
     }
     /**
      * Creates an instruction to withdraw assets from a direct withdraw strategy
-     * @param {DirectWithdrawStrategyArgs} directWithdrawArgs - Withdrawal arguments
-     * @param {BN} directWithdrawArgs.amount - Amount of assets to withdraw
-     * @param {boolean} directWithdrawArgs.isAmountInLp - Whether the amount is in LP tokens
-     * @param {boolean} directWithdrawArgs.isWithdrawAll - Whether to withdraw all assets
+     * @param {Object} directWithdrawArgs - Withdrawal arguments
      * @param {Buffer | null} [directWithdrawArgs.userArgs] - Optional user arguments for the instruction
      * @param {Object} params - Parameters for withdrawing assets from direct withdraw strategy
      * @param {PublicKey} params.user - Public key of the user
@@ -682,9 +763,6 @@ class VoltrClient extends AccountUtils {
      * ```typescript
      * const ix = await client.createDirectWithdrawStrategyIx(
      *   {
-     *     amount: new BN('1000000000'),
-     *     isAmountInLp: true,
-     *     isWithdrawAll: false,
      *     userArgs: Buffer.from('...')
      *   },
      *   {
@@ -699,9 +777,9 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createDirectWithdrawStrategyIx({ amount, isAmountInLp, isWithdrawAll, userArgs = null, }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createDirectWithdrawStrategyIx({ userArgs = null }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram = constants_1.LENDING_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
         return await this.vaultProgram.methods
-            .directWithdrawStrategy(amount, isAmountInLp, isWithdrawAll, userArgs)
+            .directWithdrawStrategy(userArgs)
             .accounts({
             userTransferAuthority: user,
             strategy,
@@ -815,6 +893,18 @@ class VoltrClient extends AccountUtils {
         return await this.vaultProgram.account.adaptorAddReceipt.fetch(adaptorAddReceipt, "confirmed");
     }
     // --------------------------------------- Helpers
+    calculateLockedProfit(lastUpdatedLockedProfit, lockedProfitDegradationDuration, currentTime) {
+        if (lockedProfitDegradationDuration.eq(new bn_js_1.default(0)))
+            return new bn_js_1.default(0);
+        const duration = currentTime.sub(lastUpdatedLockedProfit);
+        const lockedProfit = lastUpdatedLockedProfit
+            .mul(lockedProfitDegradationDuration.sub(duration))
+            .div(lockedProfitDegradationDuration);
+        if (duration.gt(lockedProfitDegradationDuration))
+            return new bn_js_1.default(0);
+        else
+            return lockedProfit;
+    }
     /**
      * Calculates the amount of assets that would be received for a given LP token amount
      *
@@ -834,33 +924,90 @@ class VoltrClient extends AccountUtils {
      * ```
      */
     async calculateAssetsForWithdraw(vaultPk, lpAmount) {
-        const vault = await this.fetchVaultAccount(vaultPk);
-        const totalValue = vault.asset.totalValue;
-        const lpMint = this.findVaultLpMint(vaultPk);
-        const lp = await (0, spl_token_1.getMint)(this.conn, lpMint);
-        const lpSupply = new anchor_1.BN(lp.supply.toString());
-        // Validate inputs
-        if (lpSupply <= new anchor_1.BN(0))
-            throw new Error("Invalid LP supply");
-        if (totalValue <= new anchor_1.BN(0))
-            throw new Error("Invalid total assets");
-        const amountPreRedemption = lpAmount.mul(totalValue).div(lpSupply);
-        const amount = amountPreRedemption
-            .mul(new anchor_1.BN(10000 - constants_1.REDEMPTION_FEE_PERCENTAGE_BPS))
-            .div(new anchor_1.BN(10000));
-        // Calculate: (lpAmount * totalValue) / totalLpSupply
         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);
             return amount;
         }
         catch (e) {
-            throw new Error("Math overflow in asset calculation");
+            throw new Error("Math overflow in asset calculation for withdraw");
+        }
+    }
+    /**
+     * Calculates the amount of LP tokens that would be burned for a given asset amount
+     *
+     * @param vaultPk - Public key of the vault
+     * @param assetAmount - Amount of assets to calculate for
+     * @returns Promise resolving to the amount of LP tokens that would be burned
+     *
+     * @throws {Error} If LP supply or total assets are invalid
+     * @throws {Error} If math overflow occurs during calculation
+     *
+     * @example
+     * ```typescript
+     * const lpTokensToBurn = await client.calculateLpForWithdraw(
+     *   vaultPubkey,
+     *   new BN('1000000000')
+     * );
+     * ```
+     */
+    async calculateLpForWithdraw(vaultPk, assetAmount) {
+        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);
+            // lp_to_burn_pre_fee = redeem_amount * (total_lp_supply_pre_withdraw / total_asset_pre_withdraw)
+            // lp_to_burn_post_fee = lp_to_burn_pre_fee  * (10000 / (10000 - redemption_fee_bps))
+            const lpToBurnNumerator = assetAmount
+                .mul(lpSupplyInclFees)
+                .mul(new bn_js_1.default(10000));
+            const lpToBurnDenominator = totalUnlockedValue.mul(new bn_js_1.default(10000 - vault.feeConfiguration.redemptionFee));
+            const lpToBurn = lpToBurnNumerator.div(lpToBurnDenominator);
+            return lpToBurn;
+        }
+        catch (e) {
+            throw new Error("Math overflow in LP token calculation for withdraw");
         }
     }
     /**
      * Calculates the amount of LP tokens that would be received for a given asset deposit
      *
-     * @param depositAmount - Amount of assets to deposit
      * @param vaultPk - Public key of the vault
+     * @param assetAmount - Amount of assets to deposit
      * @returns Promise resolving to the amount of LP tokens that would be received
      *
      * @throws {Error} If math overflow occurs during calculation
@@ -868,32 +1015,43 @@ class VoltrClient extends AccountUtils {
      * @example
      * ```typescript
      * const lpTokens = await client.calculateLpTokensForDeposit(
-     *   new BN('1000000000'),
      *   vaultPubkey
+     *   new BN('1000000000'),
      * );
      * ```
      */
-    async calculateLpTokensForDeposit(depositAmount, vaultPk) {
+    async calculateLpForDeposit(vaultPk, assetAmount) {
         const vault = await this.fetchVaultAccount(vaultPk);
         const totalValue = vault.asset.totalValue;
         const lpMint = this.findVaultLpMint(vaultPk);
         const lp = await (0, spl_token_1.getMint)(this.conn, lpMint);
-        const lpSupply = new anchor_1.BN(lp.supply.toString());
+        const lpSupply = new bn_js_1.default(lp.supply.toString());
+        const unharvestedFeesLp = vault.feeState.accumulatedLpAdminFees
+            .add(vault.feeState.accumulatedLpManagerFees)
+            .add(vault.feeState.accumulatedLpProtocolFees);
+        const lpSupplyInclFees = lpSupply.add(unharvestedFeesLp);
         // If the pool is empty, mint LP tokens 1:1 with deposit
-        if (totalValue <= new anchor_1.BN(0) && lpSupply <= new anchor_1.BN(0)) {
+        if (lpSupplyInclFees.eq(new bn_js_1.default(0))) {
             const assetMint = await (0, spl_token_1.getMint)(this.conn, vault.asset.mint);
             const assetDecimals = assetMint.decimals;
             const lpDecimals = lp.decimals;
-            return depositAmount
-                .mul(new anchor_1.BN(10 ** lpDecimals))
-                .div(new anchor_1.BN(10 ** assetDecimals));
+            return assetAmount
+                .mul(new bn_js_1.default(10 ** lpDecimals))
+                .div(new bn_js_1.default(10 ** assetDecimals));
         }
-        // Calculate: (depositAmount * totalLpSupply) / totalValue
         try {
-            return depositAmount.mul(lpSupply).div(totalValue);
+            const lpToMintNumerator = assetAmount
+                .mul(lpSupplyInclFees)
+                .mul(new bn_js_1.default(10000 - vault.feeConfiguration.issuanceFee));
+            const totalAssetPostDeposit = totalValue.add(assetAmount);
+            const lpToMintDenominator = totalAssetPostDeposit
+                .mul(new bn_js_1.default(10000))
+                .sub(assetAmount.mul(new bn_js_1.default(10000 - vault.feeConfiguration.issuanceFee)));
+            const lpToMint = lpToMintNumerator.div(lpToMintDenominator);
+            return lpToMint;
         }
         catch (e) {
-            throw new Error("Math overflow in LP token calculation");
+            throw new Error("Math overflow in LP token calculation for deposit");
         }
     }
 }

package/dist/constants.d.ts

@@ -2,12 +2,16 @@ import { PublicKey } from "@solana/web3.js";
 export declare const VAULT_PROGRAM_ID: PublicKey;
 export declare const LENDING_ADAPTOR_PROGRAM_ID: PublicKey;
 export declare const DRIFT_ADAPTOR_PROGRAM_ID: PublicKey;
-export declare const REDEMPTION_FEE_PERCENTAGE_BPS = 10;
 export declare const SEEDS: {
+    PROTOCOL: Buffer<ArrayBuffer>;
     VAULT_LP_MINT: Buffer<ArrayBuffer>;
+    VAULT_LP_MINT_AUTH: Buffer<ArrayBuffer>;
     VAULT_ASSET_IDLE_AUTH: Buffer<ArrayBuffer>;
-    STRATEGY: Buffer<ArrayBuffer>;
+    ADAPTOR_ADD_RECEIPT: Buffer<ArrayBuffer>;
     STRATEGY_INIT_RECEIPT: Buffer<ArrayBuffer>;
     VAULT_STRATEGY_AUTH: Buffer<ArrayBuffer>;
+    VAULT_STRATEGY: Buffer<ArrayBuffer>;
     DIRECT_WITHDRAW_INIT_RECEIPT_SEED: Buffer<ArrayBuffer>;
+    REQUEST_WITHDRAW_VAULT_RECEIPT: Buffer<ArrayBuffer>;
+    STRATEGY: Buffer<ArrayBuffer>;
 };

package/dist/constants.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEEDS = exports.REDEMPTION_FEE_PERCENTAGE_BPS = exports.DRIFT_ADAPTOR_PROGRAM_ID = exports.LENDING_ADAPTOR_PROGRAM_ID = exports.VAULT_PROGRAM_ID = void 0;
+exports.SEEDS = exports.DRIFT_ADAPTOR_PROGRAM_ID = exports.LENDING_ADAPTOR_PROGRAM_ID = exports.VAULT_PROGRAM_ID = void 0;
 const web3_js_1 = require("@solana/web3.js");
 exports.VAULT_PROGRAM_ID = new web3_js_1.PublicKey("vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8");
 exports.LENDING_ADAPTOR_PROGRAM_ID = new web3_js_1.PublicKey("aVoLTRCRt3NnnchvLYH6rMYehJHwM5m45RmLBZq7PGz");
 exports.DRIFT_ADAPTOR_PROGRAM_ID = new web3_js_1.PublicKey("EBN93eXs5fHGBABuajQqdsKRkCgaqtJa8vEFD6vKXiP");
-exports.REDEMPTION_FEE_PERCENTAGE_BPS = 10;
 exports.SEEDS = {
+    PROTOCOL: Buffer.from("protocol"),
     VAULT_LP_MINT: Buffer.from("vault_lp_mint"),
+    VAULT_LP_MINT_AUTH: Buffer.from("vault_lp_mint_auth"),
     VAULT_ASSET_IDLE_AUTH: Buffer.from("vault_asset_idle_auth"),
-    STRATEGY: Buffer.from("strategy"),
+    ADAPTOR_ADD_RECEIPT: Buffer.from("adaptor_add_receipt"),
     STRATEGY_INIT_RECEIPT: Buffer.from("strategy_init_receipt"),
     VAULT_STRATEGY_AUTH: Buffer.from("vault_strategy_auth"),
+    VAULT_STRATEGY: Buffer.from("vault_strategy"),
     DIRECT_WITHDRAW_INIT_RECEIPT_SEED: Buffer.from("direct_withdraw_init_receipt"),
+    REQUEST_WITHDRAW_VAULT_RECEIPT: Buffer.from("request_withdraw_vault_receipt"),
+    // TODO: Remove this
+    STRATEGY: Buffer.from("strategy"),
 };