@voltr/vault-sdk 0.1.1 → 0.1.2

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, 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
      *
@@ -225,6 +230,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 +241,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 +263,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 +279,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 +324,7 @@ export declare class VoltrClient extends AccountUtils {
      *     additionalArgs: Buffer.from('...')
      *   },
      *   {
+     *     manager: managerPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
      *     strategy: strategyPubkey,
@@ -318,7 +335,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 +351,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 +384,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 +401,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 +520,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 +542,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 +566,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 +592,7 @@ export declare class VoltrClient extends AccountUtils {
         admin: PublicKey;
         vaultConfiguration: any;
         feeConfiguration: any;
+        feeState: any;
         lastUpdatedTs: BN;
         version: number;
         padding0: number[];
@@ -496,6 +611,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 +635,9 @@ export declare class VoltrClient extends AccountUtils {
         adaptorProgram: PublicKey;
         version: number;
         bump: number;
+        isActive: boolean;
         padding0: number[];
+        lastUpdatedEpoch: BN;
         reserved: number[];
     }>;
     /**

package/dist/client.js

@@ -147,20 +147,6 @@ class VoltrClient extends AccountUtils {
         const [vaultAssetIdleAuth] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.SEEDS.VAULT_ASSET_IDLE_AUTH, vault.toBuffer()], this.vaultProgram.programId);
         return vaultAssetIdleAuth;
     }
-    /**
-     * 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) {
-        const [vaultLpFeeAuth] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.SEEDS.VAULT_LP_FEE_AUTH, vault.toBuffer()], this.vaultProgram.programId);
-        return vaultLpFeeAuth;
-    }
     /**
      * Finds all vault-related addresses
      * @param vault - Public key of the vault
@@ -177,11 +163,9 @@ class VoltrClient extends AccountUtils {
     findVaultAddresses(vault) {
         const vaultLpMint = this.findVaultLpMint(vault);
         const vaultAssetIdleAuth = this.findVaultAssetIdleAuth(vault);
-        const vaultLpFeeAuth = this.findVaultLpFeeAuth(vault);
         return {
             vaultLpMint,
             vaultAssetIdleAuth,
-            vaultLpFeeAuth,
         };
     }
     /**
@@ -214,6 +198,35 @@ class VoltrClient extends AccountUtils {
         const [strategyInitReceipt] = web3_js_1.PublicKey.findProgramAddressSync([constants_1.SEEDS.STRATEGY_INIT_RECEIPT, vault.toBuffer(), strategy.toBuffer()], this.vaultProgram.programId);
         return strategyInitReceipt;
     }
+    /**
+     * 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, strategy) {
+        const [directWithdrawInitReceipt] = web3_js_1.PublicKey.findProgramAddressSync([
+            constants_1.SEEDS.DIRECT_WITHDRAW_INIT_RECEIPT_SEED,
+            vault.toBuffer(),
+            strategy.toBuffer(),
+        ], this.vaultProgram.programId);
+        return directWithdrawInitReceipt;
+    }
+    findVaultStrategyAddresses(vault, strategy) {
+        const vaultStrategyAuth = this.findVaultStrategyAuth(vault, strategy);
+        const strategyInitReceipt = this.findStrategyInitReceipt(vault, strategy);
+        const directWithdrawInitReceipt = this.findDirectWithdrawInitReceipt(vault, strategy);
+        return {
+            vaultStrategyAuth,
+            strategyInitReceipt,
+            directWithdrawInitReceipt,
+        };
+    }
     // --------------------------------------- Vault Instructions
     /**
      * Creates an instruction to initialize a new vault
@@ -264,7 +277,6 @@ class VoltrClient extends AccountUtils {
     async createInitializeVaultIx(vaultParams, { vault, vaultAssetMint, admin, manager, payer, }) {
         const addresses = this.findVaultAddresses(vault.publicKey);
         const vaultAssetIdleAta = (0, spl_token_1.getAssociatedTokenAddressSync)(vaultAssetMint, addresses.vaultAssetIdleAuth, true);
-        const vaultLpFeeAta = (0, spl_token_1.getAssociatedTokenAddressSync)(addresses.vaultLpMint, addresses.vaultLpFeeAuth, true);
         return await this.vaultProgram.methods
             .initialize(vaultParams.config, vaultParams.name, vaultParams.description)
             .accounts({
@@ -274,7 +286,6 @@ class VoltrClient extends AccountUtils {
             vault: vault.publicKey,
             vaultAssetMint,
             vaultAssetIdleAta,
-            vaultLpFeeAta,
             assetTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         })
             .instruction();
@@ -356,6 +367,7 @@ 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
      *
@@ -366,15 +378,17 @@ class VoltrClient extends AccountUtils {
      * const ix = await client.createAddAdaptorIx({
      *   vault: vaultPubkey,
      *   payer: payerPubkey,
+     *   admin: adminPubkey,
      *   adaptorProgram: adaptorProgramPubkey
      * });
      * ```
      */
-    async createAddAdaptorIx({ vault, payer, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, }) {
+    async createAddAdaptorIx({ vault, payer, admin, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, }) {
         return await this.vaultProgram.methods
             .addAdaptor()
-            .accounts({
+            .accountsPartial({
             payer,
+            admin,
             vault,
             adaptorProgram,
         })
@@ -391,6 +405,7 @@ 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
      *
@@ -406,12 +421,13 @@ class VoltrClient extends AccountUtils {
      *     vault: vaultPubkey,
      *     manager: managerPubkey,
      *     strategy: strategyPubkey,
-     *     adaptorProgram: adaptorProgramPubkey
+     *     adaptorProgram: adaptorProgramPubkey,
+     *     remainingAccounts: []
      *   }
      * );
      * ```
      */
-    async createInitializeStrategyIx({ instructionDiscriminator = null, additionalArgs = null, }, { payer, vault, manager, strategy, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, }) {
+    async createInitializeStrategyIx({ instructionDiscriminator = null, additionalArgs = null, }, { payer, vault, manager, strategy, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .initializeStrategy(instructionDiscriminator ?? null, additionalArgs ?? null)
             .accounts({
@@ -421,16 +437,18 @@ class VoltrClient extends AccountUtils {
             strategy,
             adaptorProgram,
         })
+            .remainingAccounts(remainingAccounts)
             .instruction();
     }
     /**
      * 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
@@ -449,6 +467,7 @@ class VoltrClient extends AccountUtils {
      *     additionalArgs: Buffer.from('...')
      *   },
      *   {
+     *     manager: managerPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
      *     strategy: strategyPubkey,
@@ -459,10 +478,11 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createDepositStrategyIx({ depositAmount, instructionDiscriminator = null, additionalArgs = null, }, { vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createDepositStrategyIx({ depositAmount, instructionDiscriminator = null, additionalArgs = null, }, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .depositStrategy(depositAmount, instructionDiscriminator, additionalArgs)
             .accounts({
+            manager,
             vault,
             vaultAssetMint,
             adaptorProgram,
@@ -475,7 +495,7 @@ 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
@@ -508,10 +528,11 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator = null, additionalArgs = null, }, { vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+    async createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator = null, additionalArgs = null, }, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
         return await this.vaultProgram.methods
             .withdrawStrategy(withdrawAmount, instructionDiscriminator, additionalArgs)
             .accounts({
+            manager,
             vault,
             vaultAssetMint,
             adaptorProgram,
@@ -525,25 +546,122 @@ 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
      * });
      * ```
      */
-    async createRemoveStrategyIx({ vault, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, }) {
+    async createRemoveAdaptorIx({ vault, admin, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, }) {
         return await this.vaultProgram.methods
             .removeAdaptor()
-            .accounts({
+            .accountsPartial({
+            vault,
+            admin,
+            adaptorProgram,
+        })
+            .instruction();
+    }
+    /**
+     * 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
+     *   }
+     * );
+     * ```
+     */
+    async createInitializeDirectWithdrawStrategyIx({ instructionDiscriminator = null, additionalArgs = null, allowUserArgs = false, }, { payer, admin, vault, strategy, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, }) {
+        return await this.vaultProgram.methods
+            .initializeDirectWithdrawStrategy(instructionDiscriminator, additionalArgs, allowUserArgs)
+            .accountsPartial({
+            payer,
+            admin,
             vault,
+            strategy,
+            adaptorProgram,
+        })
+            .instruction();
+    }
+    /**
+     * 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: []
+     *   }
+     * );
+     * ```
+     */
+    async createDirectWithdrawStrategyIx({ withdrawAmount, userArgs = null }, { user, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram = constants_1.DEFAULT_ADAPTOR_PROGRAM_ID, remainingAccounts, }) {
+        return await this.vaultProgram.methods
+            .directWithdrawStrategy(withdrawAmount, userArgs)
+            .accounts({
+            userTransferAuthority: user,
+            strategy,
             adaptorProgram,
+            vault,
+            vaultAssetMint,
+            assetTokenProgram,
         })
+            .remainingAccounts(remainingAccounts)
             .instruction();
     }
     // --------------------------------------- Account Fetching All
@@ -677,9 +795,13 @@ class VoltrClient extends AccountUtils {
             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 {
-            return lpAmount.mul(totalValue).div(lpSupply);
+            return amount;
         }
         catch (e) {
             throw new Error("Math overflow in asset calculation");

package/dist/constants.d.ts

@@ -1,11 +1,12 @@
 import { PublicKey } from "@solana/web3.js";
 export declare const VAULT_PROGRAM_ID: PublicKey;
 export declare const DEFAULT_ADAPTOR_PROGRAM_ID: PublicKey;
+export declare const REDEMPTION_FEE_PERCENTAGE_BPS = 10;
 export declare const SEEDS: {
     VAULT_LP_MINT: Buffer<ArrayBuffer>;
-    VAULT_LP_FEE_AUTH: Buffer<ArrayBuffer>;
     VAULT_ASSET_IDLE_AUTH: Buffer<ArrayBuffer>;
     STRATEGY: Buffer<ArrayBuffer>;
     STRATEGY_INIT_RECEIPT: Buffer<ArrayBuffer>;
     VAULT_STRATEGY_AUTH: Buffer<ArrayBuffer>;
+    DIRECT_WITHDRAW_INIT_RECEIPT_SEED: Buffer<ArrayBuffer>;
 };