@voltr/vault-sdk 0.2.0 → 1.0.1

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%
+    redemptionFee: 10, // 0.1%
+    issuanceFee: 10, // 0.1%
+    withdrawalWaitingPeriod: new BN(3600), // 1 hour
   },
   name: "My Vault",
   description: "Example vault",
@@ -109,16 +113,38 @@ const initDirectWithdrawIx =
 
 ```typescript
 // Deposit assets
-const depositIx = await client.createDepositIx(new BN("1000000000"), {
-  userAuthority: userPubkey,
+const depositIx = await client.createDepositVaultIx(new BN("1000000000"), {
+  userTransferAuthority: userPubkey,
   vault: vaultPubkey,
   vaultAssetMint: mintPubkey,
   assetTokenProgram: tokenProgramPubkey,
 });
 
-// Withdraw assets
-const withdrawIx = await client.createWithdrawIx(new BN("1000000000"), {
-  userAuthority: userPubkey,
+// Request withdraw assets
+const requestWithdrawIx = await client.createRequestWithdrawVaultIx(
+  {
+    amount: new BN("1000000000"),
+    isAmountInLp: false,
+    isWithdrawAll: false,
+  },
+  {
+    payer: payerPubkey,
+    userTransferAuthority: userPubkey,
+    vault: vaultPubkey,
+  }
+);
+
+// Cancel withdraw request
+const cancelRequestWithdrawIx = await client.createCancelRequestWithdrawVaultIx(
+  {
+    userTransferAuthority: userPubkey,
+    vault: vaultPubkey,
+  }
+);
+
+// Withdraw from vault
+const withdrawIx = await client.createWithdrawVaultIx({
+  userTransferAuthority: userPubkey,
   vault: vaultPubkey,
   vaultAssetMint: mintPubkey,
   assetTokenProgram: tokenProgramPubkey,
@@ -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,
   },
   {
@@ -151,6 +176,66 @@ console.log(`Total Value: ${values.totalValue}`);
 console.log("Strategy Positions:", values.strategies);
 ```
 
+### Asset Calculation Utilities
+
+```typescript
+// Calculate the amount of assets that would be received for a given LP token amount
+const assetsToReceive = await client.calculateAssetsForWithdraw(
+  vaultPubkey,
+  new BN("1000000000")
+);
+console.log(`Assets to receive: ${assetsToReceive.toString()}`);
+
+// Calculate the amount of LP tokens needed to withdraw a specific asset amount
+const lpTokensRequired = await client.calculateLpForWithdraw(
+  vaultPubkey,
+  new BN("1000000000")
+);
+console.log(`LP tokens required: ${lpTokensRequired.toString()}`);
+
+// Calculate the amount of LP tokens that would be received for a deposit
+const lpTokensToReceive = await client.calculateLpForDeposit(
+  vaultPubkey,
+  new BN("1000000000")
+);
+console.log(`LP tokens to receive: ${lpTokensToReceive.toString()}`);
+```
+
+### Querying Pending Withdrawals
+
+```typescript
+// Get all pending withdrawals for a vault
+const pendingWithdrawals = await client.getAllPendingWithdrawalsForVault(
+  vaultPubkey
+);
+
+// Process the pending withdrawals
+pendingWithdrawals.forEach((withdrawal, index) => {
+  console.log(`Withdrawal ${index + 1}:`);
+  console.log(`  Asset amount: ${withdrawal.amountAssetToWithdraw}`);
+
+  // Check if withdrawal is available yet
+  const withdrawableTimestamp = withdrawal.withdrawableFromTs.toNumber();
+  const currentTime = Math.floor(Date.now() / 1000);
+  const isWithdrawable = currentTime >= withdrawableTimestamp;
+
+  console.log(
+    `  Withdrawable from: ${new Date(
+      withdrawableTimestamp * 1000
+    ).toLocaleString()}`
+  );
+  console.log(`  Status: ${isWithdrawable ? "Available now" : "Pending"}`);
+  if (!isWithdrawable) {
+    const timeRemaining = Math.max(0, withdrawableTimestamp - currentTime);
+    console.log(
+      `  Time remaining: ${Math.floor(timeRemaining / 3600)}h ${Math.floor(
+        (timeRemaining % 3600) / 60
+      )}m`
+    );
+  }
+});
+```
+
 ## API Reference
 
 ### VoltrClient Methods
@@ -158,8 +243,10 @@ console.log("Strategy Positions:", values.strategies);
 #### Vault Management
 
 - `createInitializeVaultIx(vaultParams, params)`
-- `createDepositIx(amount, params)`
-- `createWithdrawIx(amount, params)`
+- `createUpdateVaultIx(vaultConfig, params)`
+- `createRequestWithdrawVaultIx(requestWithdrawArgs, params)`
+- `createCancelRequestWithdrawVaultIx(params)`
+- `createWithdrawVaultIx(params)`
 
 #### Strategy Management
 
@@ -191,7 +278,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%
@@ -202,7 +223,7 @@ export declare class VoltrClient extends AccountUtils {
      *
      * @param {BN} amount - Amount of tokens to deposit
      * @param {Object} params - Deposit parameters
-     * @param {PublicKey} params.userAuthority - Public key of the user's transfer authority
+     * @param {PublicKey} params.userTransferAuthority - Public key of the user's transfer 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
@@ -214,7 +235,7 @@ export declare class VoltrClient extends AccountUtils {
      * const ix = await client.createDepositVaultIx(
      *   new BN('1000000000'),
      *   {
-     *     userAuthority: userPubkey,
+     *     userTransferAuthority: userPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
      *     assetTokenProgram: tokenProgramPubkey
@@ -222,45 +243,92 @@ export declare class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    createDepositVaultIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
-        userAuthority: PublicKey;
+    createDepositVaultIx(amount: BN, { userTransferAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+        userTransferAuthority: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
         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 {PublicKey} params.userAuthority - Public key of the user authority
+     * @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.userTransferAuthority - 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,
      *   },
      *   {
-     *     userAuthority: userPubkey,
+     *     payer: payerPubkey,
+     *     userTransferAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *   }
+     * );
+     */
+    createRequestWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }: RequestWithdrawVaultArgs, { payer, userTransferAuthority, vault, }: {
+        payer: PublicKey;
+        userTransferAuthority: PublicKey;
+        vault: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates a cancel withdraw instruction for a vault
+     *
+     * @param {Object} params - Cancel withdraw request parameters
+     * @param {PublicKey} params.userTransferAuthority - 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(
+     *   {
+     *     userTransferAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *   }
+     * );
+     */
+    createCancelRequestWithdrawVaultIx({ userTransferAuthority, vault, }: {
+        userTransferAuthority: PublicKey;
+        vault: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates a withdraw instruction for a vault
+     *
+     * @param {Object} params - Withdraw parameters
+     * @param {PublicKey} params.userTransferAuthority - 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(
+     *   {
+     *     userTransferAuthority: userPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
      *     assetTokenProgram: tokenProgramPubkey
      *   }
      * );
      */
-    createWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }: WithdrawVaultArgs, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
-        userAuthority: PublicKey;
+    createWithdrawVaultIx({ userTransferAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+        userTransferAuthority: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
         assetTokenProgram: 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;
@@ -595,6 +659,25 @@ export declare class VoltrClient extends AccountUtils {
         padding0: number[];
         reserved: number[];
     }>[]>;
+    /**
+     * Fetches all request withdraw vault receipt accounts of a vault
+     * @param vault - Public key of the vault
+     * @returns Promise resolving to an array of request withdraw vault receipt accounts
+     *
+     * @example
+     * ```typescript
+     * const requestWithdrawVaultReceiptAccounts = await client.fetchAllRequestWithdrawVaultReceiptsOfVault(vaultPubkey);
+     * ```
+     */
+    fetchAllRequestWithdrawVaultReceiptsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        vault: PublicKey;
+        user: PublicKey;
+        amountLpEscrowed: BN;
+        amountAssetToWithdrawDecimalBits: BN;
+        withdrawableFromTs: BN;
+        bump: number;
+        version: number;
+    }>[]>;
     /**
      * Fetches all adaptor add receipt accounts of a vault
      * @param vault - Public key of the vault
@@ -616,10 +699,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,18 +713,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;
-        highWaterMark: 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: any;
+        lockedProfitState: {
+            lastUpdatedLockedProfit: BN;
+            lastReport: BN;
+        };
         reserved: number[];
     }>;
     /**
@@ -686,6 +806,21 @@ export declare class VoltrClient extends AccountUtils {
         lastUpdatedEpoch: BN;
         reserved: number[];
     }>;
+    /**
+     * Fetches all pending withdrawals for a vault
+     * @param vault - Public key of the vault
+     * @returns Promise resolving to an array of pending withdrawals
+     *
+     * @example
+     * ```typescript
+     * const pendingWithdrawals = await client.getAllPendingWithdrawalsForVault(vaultPubkey);
+     * ```
+     */
+    getAllPendingWithdrawalsForVault(vault: PublicKey): Promise<{
+        amountAssetToWithdraw: number;
+        withdrawableFromTs: BN;
+    }[]>;
+    calculateLockedProfit(lastUpdatedLockedProfit: BN, lockedProfitDegradationDuration: BN, currentTime: BN): BN;
     /**
      * Calculates the amount of assets that would be received for a given LP token amount
      *
@@ -705,11 +840,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
@@ -717,11 +871,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 {};