@voltr/vault-sdk 0.1.1 → 0.1.3

package/README.md

@@ -6,10 +6,10 @@ A TypeScript SDK for interacting with the Voltr protocol on Solana.
 
 - Complete TypeScript support with type definitions
 - Comprehensive vault management functionality
-- Strategy handling and execution
-- Asset deposit and withdrawal operations
-- PDA (Program Derived Address) utilities
-- Account data fetching and parsing
+- Strategy handling and execution with adaptor support
+- Asset deposit and withdrawal operations with direct withdraw capability
+- Account data fetching and PDA (Program Derived Address) utilities
+- Position and total value tracking
 
 ## Installation
 
@@ -60,28 +60,6 @@ const ix = await client.createInitializeVaultIx(vaultParams, {
 });
 ```
 
-### Deposit Assets
-
-```typescript
-const depositIx = await client.createDepositIx(new BN("1000000000"), {
-  userAuthority: userPubkey,
-  vault: vaultPubkey,
-  vaultAssetMint: mintPubkey,
-  assetTokenProgram: tokenProgramPubkey,
-});
-```
-
-### Withdraw Assets
-
-```typescript
-const withdrawIx = await client.createWithdrawIx(new BN("1000000000"), {
-  userAuthority: userPubkey,
-  vault: vaultPubkey,
-  vaultAssetMint: mintPubkey,
-  assetTokenProgram: tokenProgramPubkey,
-});
-```
-
 ### Strategy Management
 
 ```typescript
@@ -89,6 +67,7 @@ const withdrawIx = await client.createWithdrawIx(new BN("1000000000"), {
 const addAdaptorIx = await client.createAddAdaptorIx({
   vault: vaultPubkey,
   payer: payerPubkey,
+  admin: adminPubkey,
   adaptorProgram: adaptorProgramPubkey,
 });
 
@@ -104,20 +83,58 @@ const initStrategyIx = await client.createInitializeStrategyIx(
     manager: managerPubkey,
     strategy: strategyPubkey,
     adaptorProgram: adaptorProgramPubkey,
+    remainingAccounts: [],
   }
 );
 
-// Deposit into a strategy
-const depositStrategyIx = await client.createDepositStrategyIx(
+// Initialize direct withdraw strategy
+const initDirectWithdrawIx =
+  await client.createInitializeDirectWithdrawStrategyIx(
+    {
+      instructionDiscriminator: null,
+      additionalArgs: null,
+      allowUserArgs: true,
+    },
+    {
+      payer: payerPubkey,
+      admin: adminPubkey,
+      vault: vaultPubkey,
+      strategy: strategyPubkey,
+      adaptorProgram: adaptorProgramPubkey,
+    }
+  );
+```
+
+### Asset Operations
+
+```typescript
+// Deposit assets
+const depositIx = await client.createDepositIx(new BN("1000000000"), {
+  userAuthority: userPubkey,
+  vault: vaultPubkey,
+  vaultAssetMint: mintPubkey,
+  assetTokenProgram: tokenProgramPubkey,
+});
+
+// Withdraw assets
+const withdrawIx = await client.createWithdrawIx(new BN("1000000000"), {
+  userAuthority: userPubkey,
+  vault: vaultPubkey,
+  vaultAssetMint: mintPubkey,
+  assetTokenProgram: tokenProgramPubkey,
+});
+
+// Direct withdraw from strategy
+const directWithdrawIx = await client.createDirectWithdrawStrategyIx(
   {
-    depositAmount: new BN("1000000000"),
-    instructionDiscriminator: null,
-    additionalArgs: null,
+    withdrawAmount: new BN("1000000000"),
+    userArgs: null,
   },
   {
+    user: userPubkey,
     vault: vaultPubkey,
-    vaultAssetMint: mintPubkey,
     strategy: strategyPubkey,
+    vaultAssetMint: mintPubkey,
     assetTokenProgram: tokenProgramPubkey,
     adaptorProgram: adaptorProgramPubkey,
     remainingAccounts: [],
@@ -125,53 +142,56 @@ const depositStrategyIx = await client.createDepositStrategyIx(
 );
 ```
 
-## API Reference
-
-### VoltrClient
-
-The main client class for interacting with the Voltr protocol.
-
-#### Constructor
+### Position and Value Tracking
 
 ```typescript
-constructor(conn: Connection, wallet?: Keypair)
+// Get position and total values for a vault
+const values = await client.getPositionAndTotalValuesForVault(vaultPubkey);
+console.log(`Total Value: ${values.totalValue}`);
+console.log("Strategy Positions:", values.strategies);
 ```
 
-#### Vault Management Methods
+## API Reference
+
+### VoltrClient Methods
+
+#### Vault Management
 
-- `createInitializeVaultIx(vaultParams: VaultParams, params: InitializeParams)`
-- `createDepositIx(amount: BN, params: DepositParams)`
-- `createWithdrawIx(amount: BN, params: WithdrawParams)`
+- `createInitializeVaultIx(vaultParams, params)`
+- `createDepositIx(amount, params)`
+- `createWithdrawIx(amount, params)`
 
-#### Strategy Management Methods
+#### Strategy Management
 
-- `createAddAdaptorIx(params: AddAdaptorParams)`
-- `createInitializeStrategyIx(initArgs: InitializeStrategyArgs, params: InitStrategyParams)`
-- `createDepositStrategyIx(depositArgs: depositStrategyArgs, params: DepositStrategyParams)`
-- `createWithdrawStrategyIx(withdrawArgs: withdrawStrategyArgs, params: WithdrawStrategyParams)`
-- `createRemoveStrategyIx(params: RemoveStrategyParams)`
+- `createAddAdaptorIx(params)`
+- `createInitializeStrategyIx(initArgs, params)`
+- `createDepositStrategyIx(depositArgs, params)`
+- `createWithdrawStrategyIx(withdrawArgs, params)`
+- `createInitializeDirectWithdrawStrategyIx(initArgs, params)`
+- `createDirectWithdrawStrategyIx(withdrawArgs, params)`
+- `createRemoveAdaptorIx(params)`
 
-#### Account Fetching Methods
+#### Account Data
 
-- `fetchVaultAccount(vault: PublicKey)`
+- `fetchVaultAccount(vault)`
 - `fetchAllStrategyInitReceiptAccounts()`
-- `fetchAllStrategyInitReceiptAccountsOfVault(vault: PublicKey)`
-- `fetchAllAdaptorAddReceiptAccountsOfVault(vault: PublicKey)`
-- `getPositionAndTotalValuesForVault(vault: PublicKey)`
+- `fetchAllStrategyInitReceiptAccountsOfVault(vault)`
+- `fetchAllAdaptorAddReceiptAccountsOfVault(vault)`
+- `getPositionAndTotalValuesForVault(vault)`
 
-#### PDA Finding Methods
+#### PDA Finding
 
-- `findVaultLpMint(vault: PublicKey)`
-- `findVaultAssetIdleAuth(vault: PublicKey)`
-- `findVaultLpFeeAuth(vault: PublicKey)`
-- `findVaultAddresses(vault: PublicKey)`
-- `findVaultStrategyAuth(vault: PublicKey, strategy: PublicKey)`
-- `findStrategyInitReceipt(vault: PublicKey, strategy: PublicKey)`
+- `findVaultLpMint(vault)`
+- `findVaultAssetIdleAuth(vault)`
+- `findVaultAddresses(vault)`
+- `findVaultStrategyAuth(vault, strategy)`
+- `findStrategyInitReceipt(vault, strategy)`
+- `findDirectWithdrawInitReceipt(vault, strategy)`
 
-#### Calculation Methods
+#### Calculations
 
-- `calculateAssetsForWithdraw(vaultPk: PublicKey, lpAmount: BN)`
-- `calculateLpTokensForDeposit(depositAmount: BN, vaultPk: PublicKey)`
+- `calculateAssetsForWithdraw(vaultPk, lpAmount)`
+- `calculateLpTokensForDeposit(depositAmount, vaultPk)`
 
 ## License
 

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { Program, AnchorProvider, Idl, BN } from "@coral-xyz/anchor";
 import { Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { VaultParams, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs } from "./types";
+import { VaultParams, VaultConfig, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, DirectWithdrawStrategyArgs } from "./types";
 declare class AccountUtils {
     conn: Connection;
     constructor(conn: Connection);
@@ -53,17 +53,6 @@ export declare class VoltrClient extends AccountUtils {
      * @returns The PDA for the vault's asset idle authority
      */
     findVaultAssetIdleAuth(vault: PublicKey): PublicKey;
-    /**
-     * Finds the vault's LP fee authority address
-     * @param vault - Public key of the vault
-     * @returns The PDA for the vault's LP fee authority
-     *
-     * @example
-     * ```typescript
-     * const feeAuth = client.findVaultLpFeeAuth(vaultPubkey);
-     * ```
-     */
-    findVaultLpFeeAuth(vault: PublicKey): PublicKey;
     /**
      * Finds all vault-related addresses
      * @param vault - Public key of the vault
@@ -80,7 +69,6 @@ export declare class VoltrClient extends AccountUtils {
     findVaultAddresses(vault: PublicKey): {
         vaultLpMint: PublicKey;
         vaultAssetIdleAuth: PublicKey;
-        vaultLpFeeAuth: PublicKey;
     };
     /**
      * Finds the vault strategy auth address
@@ -106,6 +94,23 @@ export declare class VoltrClient extends AccountUtils {
      * ```
      */
     findStrategyInitReceipt(vault: PublicKey, strategy: PublicKey): PublicKey;
+    /**
+     * Finds the direct withdraw init receipt address
+     * @param vault - Public key of the vault
+     * @param strategy - Public key of the strategy
+     * @returns The PDA for the direct withdraw init receipt
+     *
+     * @example
+     * ```typescript
+     * const directWithdrawInitReceipt = client.findDirectWithdrawInitReceipt(vaultPubkey, strategyPubkey);
+     * ```
+     */
+    findDirectWithdrawInitReceipt(vault: PublicKey, strategy: PublicKey): PublicKey;
+    findVaultStrategyAddresses(vault: PublicKey, strategy: PublicKey): {
+        vaultStrategyAuth: PublicKey;
+        strategyInitReceipt: PublicKey;
+        directWithdrawInitReceipt: PublicKey;
+    };
     /**
      * Creates an instruction to initialize a new vault
      *
@@ -160,7 +165,40 @@ export declare class VoltrClient extends AccountUtils {
         payer: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
-     * Creates a deposit instruction
+     * Creates an instruction to update a vault
+     * @param {VaultConfig} vaultConfig - Configuration parameters for the vault
+     * @param {BN} vaultConfig.maxCap - Maximum capacity of the vault
+     * @param {BN} vaultConfig.startAtTs - Vault start timestamp in seconds
+     * @param {number} vaultConfig.managerManagementFee - Manager's management fee in basis points (e.g., 50 = 0.5%)
+     * @param {number} vaultConfig.managerPerformanceFee - Manager's performance fee in basis points (e.g., 1000 = 10%)
+     * @param {number} vaultConfig.adminManagementFee - Admin's management fee in basis points (e.g., 50 = 0.5%)
+     * @param {number} vaultConfig.adminPerformanceFee - Admin's performance fee in basis points (e.g., 1000 = 10%)
+     * @param {Object} params - Parameters for updating the vault
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.admin - Public key of the vault admin
+     * @returns Transaction instruction for updating the vault
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createUpdateVaultIx(
+     *   {
+     *     maxCap: new BN('1000000000'),
+     *     startAtTs: new BN(Math.floor(Date.now() / 1000)),
+     *     managerManagementFee: 50,
+     *     managerPerformanceFee: 1000,
+     *     adminManagementFee: 50,
+     *     adminPerformanceFee: 1000,
+     *   },
+     *   { vault: vaultPubkey, admin: adminPubkey }
+     * );
+     * ```
+     */
+    createUpdateVaultIx(vaultConfig: VaultConfig, { vault, admin, }: {
+        vault: PublicKey;
+        admin: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates a deposit instruction for a vault
      *
      * @param {BN} amount - Amount of tokens to deposit
      * @param {Object} params - Deposit parameters
@@ -173,7 +211,7 @@ export declare class VoltrClient extends AccountUtils {
      *
      * @example
      * ```typescript
-     * const ix = await client.createDepositIx(
+     * const ix = await client.createDepositVaultIx(
      *   new BN('1000000000'),
      *   {
      *     userAuthority: userPubkey,
@@ -184,14 +222,14 @@ export declare class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    createDepositIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+    createDepositVaultIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
         userAuthority: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
         assetTokenProgram: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
-     * Creates a withdraw instruction
+     * Creates a withdraw instruction for a vault
      *
      * @param amount - Amount of LP tokens to withdraw
      * @param {Object} params - Withdraw parameters
@@ -204,7 +242,7 @@ export declare class VoltrClient extends AccountUtils {
      * @throws {Error} If the instruction creation fails
      *
      * @example
-     * const ix = await client.createWithdrawIx(
+     * const ix = await client.createWithdrawVaultIx(
      *   new BN('1000000000'),
      *   {
      *     userAuthority: userPubkey,
@@ -214,7 +252,7 @@ export declare class VoltrClient extends AccountUtils {
      *   }
      * );
      */
-    createWithdrawIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+    createWithdrawVaultIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
         userAuthority: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
@@ -225,6 +263,7 @@ export declare class VoltrClient extends AccountUtils {
      * @param {Object} params - Parameters for adding adaptor to vault
      * @param {PublicKey} params.vault - Public key of the vault
      * @param {PublicKey} params.payer - Public key of the payer
+     * @param {PublicKey} params.admin - Public key of the admin
      * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
      * @returns {Promise<TransactionInstruction>} Transaction instruction for adding adaptor to vault
      *
@@ -235,13 +274,15 @@ export declare class VoltrClient extends AccountUtils {
      * const ix = await client.createAddAdaptorIx({
      *   vault: vaultPubkey,
      *   payer: payerPubkey,
+     *   admin: adminPubkey,
      *   adaptorProgram: adaptorProgramPubkey
      * });
      * ```
      */
-    createAddAdaptorIx({ vault, payer, adaptorProgram, }: {
+    createAddAdaptorIx({ vault, payer, admin, adaptorProgram, }: {
         vault: PublicKey;
         payer: PublicKey;
+        admin: PublicKey;
         adaptorProgram?: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
@@ -255,6 +296,7 @@ export declare class VoltrClient extends AccountUtils {
      * @param {PublicKey} params.manager - Public key of the manager
      * @param {PublicKey} params.strategy - Public key of the strategy
      * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
      * @returns {Promise<TransactionInstruction>} Transaction instruction for initializing strategy to vault
      * @throws {Error} If the instruction creation fails
      *
@@ -270,26 +312,33 @@ export declare class VoltrClient extends AccountUtils {
      *     vault: vaultPubkey,
      *     manager: managerPubkey,
      *     strategy: strategyPubkey,
-     *     adaptorProgram: adaptorProgramPubkey
+     *     adaptorProgram: adaptorProgramPubkey,
+     *     remainingAccounts: []
      *   }
      * );
      * ```
      */
-    createInitializeStrategyIx({ instructionDiscriminator, additionalArgs, }: InitializeStrategyArgs, { payer, vault, manager, strategy, adaptorProgram, }: {
+    createInitializeStrategyIx({ instructionDiscriminator, additionalArgs, }: InitializeStrategyArgs, { payer, vault, manager, strategy, adaptorProgram, remainingAccounts, }: {
         payer: PublicKey;
         vault: PublicKey;
         manager: PublicKey;
         strategy: PublicKey;
         adaptorProgram?: PublicKey;
+        remainingAccounts: Array<{
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
     }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to deposit assets into a strategy
      *
-     * @param {Object} depositArgs - Deposit arguments
+     * @param {DepositStrategyArgs} depositArgs - Deposit arguments
      * @param {BN} depositArgs.depositAmount - Amount of assets to deposit
      * @param {Buffer | null} [depositArgs.instructionDiscriminator] - Optional discriminator for the instruction
      * @param {Buffer | null} [depositArgs.additionalArgs] - Optional additional arguments for the instruction
      * @param {Object} params - Strategy deposit parameters
+     * @param {PublicKey} params.manager - Public key of the manager
      * @param {PublicKey} params.vault - Public key of the vault
      * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
      * @param {PublicKey} params.strategy - Public key of the strategy
@@ -308,6 +357,7 @@ export declare class VoltrClient extends AccountUtils {
      *     additionalArgs: Buffer.from('...')
      *   },
      *   {
+     *     manager: managerPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
      *     strategy: strategyPubkey,
@@ -318,7 +368,8 @@ export declare class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    createDepositStrategyIx({ depositAmount, instructionDiscriminator, additionalArgs, }: DepositStrategyArgs, { vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+    createDepositStrategyIx({ depositAmount, instructionDiscriminator, additionalArgs, }: DepositStrategyArgs, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        manager: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
         strategy: PublicKey;
@@ -333,7 +384,7 @@ export declare class VoltrClient extends AccountUtils {
     /**
      * Creates an instruction to withdraw assets from a strategy
      *
-     * @param {Object} withdrawArgs - Withdrawal arguments
+     * @param {WithdrawStrategyArgs} withdrawArgs - Withdrawal arguments
      * @param {BN} withdrawArgs.withdrawAmount - Amount of assets to withdraw
      * @param {Buffer | null} [withdrawArgs.instructionDiscriminator] - Optional discriminator for the instruction
      * @param {Buffer | null} [withdrawArgs.additionalArgs] - Optional additional arguments for the instruction
@@ -366,7 +417,8 @@ export declare class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator, additionalArgs, }: WithdrawStrategyArgs, { vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+    createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator, additionalArgs, }: WithdrawStrategyArgs, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        manager: PublicKey;
         vault: PublicKey;
         vaultAssetMint: PublicKey;
         strategy: PublicKey;
@@ -382,22 +434,113 @@ export declare class VoltrClient extends AccountUtils {
      * Creates an instruction to remove a strategy from a vault
      * @param {Object} params - Parameters for removing strategy
      * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.admin - Public key of the admin
      * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for removing strategy from vault
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for removing adaptor from vault
      * @throws {Error} If instruction creation fails
      *
      * @example
      * ```typescript
-     * const ix = await client.createRemoveStrategyIx({
+     * const ix = await client.createRemoveAdaptorIx({
      *   vault: vaultPubkey,
+     *   admin: adminPubkey,
      *   adaptorProgram: adaptorProgramPubkey
      * });
      * ```
      */
-    createRemoveStrategyIx({ vault, adaptorProgram, }: {
+    createRemoveAdaptorIx({ vault, admin, adaptorProgram, }: {
         vault: PublicKey;
+        admin: PublicKey;
         adaptorProgram?: PublicKey;
     }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to initialize a direct withdraw strategy
+     * @param {InitializeDirectWithdrawStrategyArgs} initArgs - Arguments for initializing direct withdraw strategy
+     * @param {Buffer | null} initArgs.instructionDiscriminator - Optional discriminator for the instruction
+     * @param {Buffer | null} initArgs.additionalArgs - Optional additional arguments for the instruction
+     * @param {boolean} initArgs.allowUserArgs - Whether to allow user arguments
+     * @param {Object} params - Parameters for initializing direct withdraw strategy
+     * @param {PublicKey} params.payer - Public key of the payer
+     * @param {PublicKey} params.admin - Public key of the admin
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.strategy - Public key of the strategy
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for initializing direct withdraw strategy
+     * @throws {Error} If instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInitializeDirectWithdrawStrategyIx(
+     *   {
+     *     instructionDiscriminator: Buffer.from('...'),
+     *     additionalArgs: Buffer.from('...'),
+     *     allowUserArgs: true
+     *   },
+     *   {
+     *     payer: payerPubkey,
+     *     admin: adminPubkey,
+     *     vault: vaultPubkey,
+     *     strategy: strategyPubkey,
+     *     adaptorProgram: adaptorProgramPubkey
+     *   }
+     * );
+     * ```
+     */
+    createInitializeDirectWithdrawStrategyIx({ instructionDiscriminator, additionalArgs, allowUserArgs, }: InitializeDirectWithdrawStrategyArgs, { payer, admin, vault, strategy, adaptorProgram, }: {
+        payer: PublicKey;
+        admin: PublicKey;
+        vault: PublicKey;
+        strategy: PublicKey;
+        adaptorProgram?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to withdraw assets from a direct withdraw strategy
+     * @param {DirectWithdrawStrategyArgs} withdrawArgs - Withdrawal arguments
+     * @param {BN} withdrawArgs.withdrawAmount - Amount of assets to withdraw
+     * @param {Buffer | null} [withdrawArgs.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
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.strategy - Public key of the strategy
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawing assets from direct withdraw strategy
+     * @throws {Error} If instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createDirectWithdrawStrategyIx(
+     *   {
+     *     withdrawAmount: new BN('1000000000'),
+     *     userArgs: Buffer.from('...')
+     *   },
+     *   {
+     *     user: userPubkey,
+     *     vault: vaultPubkey,
+     *     strategy: strategyPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     assetTokenProgram: tokenProgramPubkey,
+     *     adaptorProgram: adaptorProgramPubkey,
+     *     remainingAccounts: []
+     *   }
+     * );
+     * ```
+     */
+    createDirectWithdrawStrategyIx({ withdrawAmount, userArgs }: DirectWithdrawStrategyArgs, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        user: PublicKey;
+        vault: PublicKey;
+        strategy: PublicKey;
+        vaultAssetMint: PublicKey;
+        assetTokenProgram: PublicKey;
+        adaptorProgram?: PublicKey;
+        remainingAccounts: Array<{
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+    }): Promise<TransactionInstruction>;
     /**
      * Fetches all strategy init receipt accounts
      * @returns Promise resolving to an array of strategy init receipt accounts
@@ -410,6 +553,7 @@ export declare class VoltrClient extends AccountUtils {
     fetchAllStrategyInitReceiptAccounts(): Promise<import("@coral-xyz/anchor").ProgramAccount<{
         vault: PublicKey;
         strategy: PublicKey;
+        adaptorProgram: PublicKey;
         positionValue: BN;
         lastUpdatedTs: BN;
         version: number;
@@ -431,6 +575,7 @@ export declare class VoltrClient extends AccountUtils {
     fetchAllStrategyInitReceiptAccountsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
         vault: PublicKey;
         strategy: PublicKey;
+        adaptorProgram: PublicKey;
         positionValue: BN;
         lastUpdatedTs: BN;
         version: number;
@@ -454,7 +599,9 @@ export declare class VoltrClient extends AccountUtils {
         adaptorProgram: PublicKey;
         version: number;
         bump: number;
+        isActive: boolean;
         padding0: number[];
+        lastUpdatedEpoch: BN;
         reserved: number[];
     }>[]>;
     getPositionAndTotalValuesForVault(vault: PublicKey): Promise<{
@@ -478,6 +625,7 @@ export declare class VoltrClient extends AccountUtils {
         admin: PublicKey;
         vaultConfiguration: any;
         feeConfiguration: any;
+        feeState: any;
         lastUpdatedTs: BN;
         version: number;
         padding0: number[];
@@ -496,6 +644,7 @@ export declare class VoltrClient extends AccountUtils {
     fetchStrategyInitReceiptAccount(strategyInitReceipt: PublicKey): Promise<{
         vault: PublicKey;
         strategy: PublicKey;
+        adaptorProgram: PublicKey;
         positionValue: BN;
         lastUpdatedTs: BN;
         version: number;
@@ -519,7 +668,9 @@ export declare class VoltrClient extends AccountUtils {
         adaptorProgram: PublicKey;
         version: number;
         bump: number;
+        isActive: boolean;
         padding0: number[];
+        lastUpdatedEpoch: BN;
         reserved: number[];
     }>;
     /**