@voltr/vault-sdk 0.1.6 → 1.0.0

package/README.md

@@ -41,10 +41,14 @@ const vaultParams = {
   config: {
     maxCap: new BN("1000000000"),
     startAtTs: new BN(Math.floor(Date.now() / 1000)),
+    lockedProfitDegradationDuration: new BN(3600), // 1 hour
     managerManagementFee: 50, // 0.5%
     managerPerformanceFee: 1000, // 10%
     adminManagementFee: 50, // 0.5%
     adminPerformanceFee: 1000, // 10%
+    redemptionFeePercentageBps: 10, // 0.1%
+    issuanceFeePercentageBps: 10, // 0.1%
+    withdrawalWaitingPeriod: new BN(3600), // 1 hour
   },
   name: "My Vault",
   description: "Example vault",
@@ -116,8 +120,30 @@ const depositIx = await client.createDepositIx(new BN("1000000000"), {
   assetTokenProgram: tokenProgramPubkey,
 });
 
-// Withdraw assets
-const withdrawIx = await client.createWithdrawIx(new BN("1000000000"), {
+// Request withdraw assets
+const requestWithdrawIx = await client.createRequestWithdrawVaultIx(
+  {
+    amount: new BN("1000000000"),
+    isAmountInLp: false,
+    isWithdrawAll: false,
+  },
+  {
+    payer: payerPubkey,
+    userAuthority: userPubkey,
+    vault: vaultPubkey,
+  }
+);
+
+// Cancel withdraw request
+const cancelRequestWithdrawIx = await client.createCancelRequestWithdrawVaultIx(
+  {
+    userAuthority: userPubkey,
+    vault: vaultPubkey,
+  }
+);
+
+// Withdraw from vault
+const withdrawIx = await client.createWithdrawIx({
   userAuthority: userPubkey,
   vault: vaultPubkey,
   vaultAssetMint: mintPubkey,
@@ -127,7 +153,6 @@ const withdrawIx = await client.createWithdrawIx(new BN("1000000000"), {
 // Direct withdraw from strategy
 const directWithdrawIx = await client.createDirectWithdrawStrategyIx(
   {
-    withdrawAmount: new BN("1000000000"),
     userArgs: null,
   },
   {
@@ -158,8 +183,9 @@ console.log("Strategy Positions:", values.strategies);
 #### Vault Management
 
 - `createInitializeVaultIx(vaultParams, params)`
-- `createDepositIx(amount, params)`
-- `createWithdrawIx(amount, params)`
+- `createRequestWithdrawVaultIx(requestWithdrawArgs, params)`
+- `createCancelRequestWithdrawVaultIx(params)`
+- `createWithdrawVaultIx(params)`
 
 #### Strategy Management
 
@@ -191,7 +217,8 @@ console.log("Strategy Positions:", values.strategies);
 #### Calculations
 
 - `calculateAssetsForWithdraw(vaultPk, lpAmount)`
-- `calculateLpTokensForDeposit(depositAmount, vaultPk)`
+- `calculateLpForWithdraw(vaultPk, assetAmount)`
+- `calculateLpForDeposit(vaultPk, assetAmount)`
 
 ## License
 

package/dist/client.d.ts

@@ -1,6 +1,7 @@
-import { Program, AnchorProvider, Idl, BN } from "@coral-xyz/anchor";
+import { Program, AnchorProvider, Idl } from "@coral-xyz/anchor";
+import BN from "bn.js";
 import { Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { VaultParams, VaultConfig, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, DirectWithdrawStrategyArgs, WithdrawVaultArgs } from "./types";
+import { VaultParams, VaultConfig, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, RequestWithdrawVaultArgs } from "./types";
 declare class AccountUtils {
     conn: Connection;
     constructor(conn: Connection);
@@ -111,6 +112,18 @@ export declare class VoltrClient extends AccountUtils {
         strategyInitReceipt: PublicKey;
         directWithdrawInitReceipt: PublicKey;
     };
+    /**
+     * 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: PublicKey, user: PublicKey): PublicKey;
     /**
      * Creates an instruction to initialize a new vault
      *
@@ -118,10 +131,14 @@ export declare 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
@@ -139,6 +156,10 @@ export declare 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%
@@ -229,29 +250,76 @@ export declare class VoltrClient extends AccountUtils {
         assetTokenProgram: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
-     * 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,
+     *   }
+     * );
+     */
+    createRequestWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }: RequestWithdrawVaultArgs, { payer, userAuthority, vault, }: {
+        payer: PublicKey;
+        userAuthority: PublicKey;
+        vault: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * 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,
+     *   }
+     * );
+     */
+    createCancelRequestWithdrawVaultIx({ userAuthority, vault, }: {
+        userAuthority: PublicKey;
+        vault: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * 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,
@@ -259,7 +327,7 @@ export declare class VoltrClient extends AccountUtils {
      *   }
      * );
      */
-    createWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }: WithdrawVaultArgs, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+    createWithdrawVaultIx({ userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
         userAuthority: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
@@ -502,10 +570,7 @@ export declare class VoltrClient extends AccountUtils {
     }): Promise<TransactionInstruction>;
     /**
      * 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
@@ -522,9 +587,6 @@ export declare class VoltrClient extends AccountUtils {
      * ```typescript
      * const ix = await client.createDirectWithdrawStrategyIx(
      *   {
-     *     amount: new BN('1000000000'),
-     *     isAmountInLp: true,
-     *     isWithdrawAll: false,
      *     userArgs: Buffer.from('...')
      *   },
      *   {
@@ -539,7 +601,9 @@ export declare class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    createDirectWithdrawStrategyIx({ amount, isAmountInLp, isWithdrawAll, userArgs, }: DirectWithdrawStrategyArgs, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+    createDirectWithdrawStrategyIx({ userArgs }: {
+        userArgs?: Buffer | null;
+    }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
         user: PublicKey;
         vault: PublicKey;
         strategy: PublicKey;
@@ -616,10 +680,10 @@ export declare class VoltrClient extends AccountUtils {
         reserved: number[];
     }>[]>;
     getPositionAndTotalValuesForVault(vault: PublicKey): Promise<{
-        totalValue: any;
+        totalValue: number;
         strategies: {
             strategyId: string;
-            amount: any;
+            amount: number;
         }[];
     }>;
     /**
@@ -630,16 +694,55 @@ export declare class VoltrClient extends AccountUtils {
     fetchVaultAccount(vault: PublicKey): Promise<{
         name: number[];
         description: number[];
-        asset: any;
-        lp: any;
+        asset: {
+            mint: PublicKey;
+            idleAta: PublicKey;
+            totalValue: BN;
+            idleAtaAuthBump: number;
+            reserved: number[];
+        };
+        lp: {
+            mint: PublicKey;
+            mintBump: number;
+            mintAuthBump: number;
+            reserved: number[];
+        };
         manager: PublicKey;
         admin: PublicKey;
-        vaultConfiguration: any;
-        feeConfiguration: any;
-        feeState: any;
+        vaultConfiguration: {
+            maxCap: BN;
+            startAtTs: BN;
+            lockedProfitDegradationDuration: BN;
+            withdrawalWaitingPeriod: BN;
+            reserved: number[];
+        };
+        feeConfiguration: {
+            managerPerformanceFee: number;
+            adminPerformanceFee: number;
+            managerManagementFee: number;
+            adminManagementFee: number;
+            redemptionFee: number;
+            issuanceFee: number;
+            reserved: number[];
+        };
+        feeState: {
+            accumulatedLpManagerFees: BN;
+            accumulatedLpAdminFees: BN;
+            accumulatedLpProtocolFees: BN;
+            reserved: number[];
+        };
+        highWaterMark: {
+            highestAssetPerLpDecimalBits: BN;
+            lastUpdatedTs: BN;
+            reserved: number[];
+        };
         lastUpdatedTs: BN;
         version: number;
         padding0: number[];
+        lockedProfitState: {
+            lastUpdatedLockedProfit: BN;
+            lastReport: BN;
+        };
         reserved: number[];
     }>;
     /**
@@ -684,6 +787,7 @@ export declare class VoltrClient extends AccountUtils {
         lastUpdatedEpoch: BN;
         reserved: number[];
     }>;
+    calculateLockedProfit(lastUpdatedLockedProfit: BN, lockedProfitDegradationDuration: BN, currentTime: BN): BN;
     /**
      * Calculates the amount of assets that would be received for a given LP token amount
      *
@@ -703,11 +807,30 @@ export declare class VoltrClient extends AccountUtils {
      * ```
      */
     calculateAssetsForWithdraw(vaultPk: PublicKey, lpAmount: BN): Promise<BN>;
+    /**
+     * 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')
+     * );
+     * ```
+     */
+    calculateLpForWithdraw(vaultPk: PublicKey, assetAmount: BN): Promise<BN>;
     /**
      * 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
@@ -715,11 +838,11 @@ export declare class VoltrClient extends AccountUtils {
      * @example
      * ```typescript
      * const lpTokens = await client.calculateLpTokensForDeposit(
-     *   new BN('1000000000'),
      *   vaultPubkey
+     *   new BN('1000000000'),
      * );
      * ```
      */
-    calculateLpTokensForDeposit(depositAmount: BN, vaultPk: PublicKey): Promise<BN>;
+    calculateLpForDeposit(vaultPk: PublicKey, assetAmount: BN): Promise<BN>;
 }
 export {};