@voltr/vault-sdk 0.1.1 → 0.1.3

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,9 +277,8 @@ 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)
+            .initializeVault(vaultParams.config, vaultParams.name, vaultParams.description)
             .accounts({
             payer,
             admin,
@@ -274,13 +286,50 @@ class VoltrClient extends AccountUtils {
             vault: vault.publicKey,
             vaultAssetMint,
             vaultAssetIdleAta,
-            vaultLpFeeAta,
             assetTokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
         })
             .instruction();
     }
     /**
-     * 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 }
+     * );
+     * ```
+     */
+    async createUpdateVaultIx(vaultConfig, { vault, admin, }) {
+        return await this.vaultProgram.methods
+            .updateVault(vaultConfig)
+            .accountsPartial({
+            admin,
+            vault,
+        })
+            .instruction();
+    }
+    /**
+     * Creates a deposit instruction for a vault
      *
      * @param {BN} amount - Amount of tokens to deposit
      * @param {Object} params - Deposit parameters
@@ -293,7 +342,7 @@ class VoltrClient extends AccountUtils {
      *
      * @example
      * ```typescript
-     * const ix = await client.createDepositIx(
+     * const ix = await client.createDepositVaultIx(
      *   new BN('1000000000'),
      *   {
      *     userAuthority: userPubkey,
@@ -304,9 +353,9 @@ class VoltrClient extends AccountUtils {
      * );
      * ```
      */
-    async createDepositIx(amount, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
+    async createDepositVaultIx(amount, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
         return await this.vaultProgram.methods
-            .deposit(amount)
+            .depositVault(amount)
             .accounts({
             userTransferAuthority: userAuthority,
             vault,
@@ -316,7 +365,7 @@ class VoltrClient extends AccountUtils {
             .instruction();
     }
     /**
-     * Creates a withdraw instruction
+     * Creates a withdraw instruction for a vault
      *
      * @param amount - Amount of LP tokens to withdraw
      * @param {Object} params - Withdraw parameters
@@ -329,7 +378,7 @@ 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,
@@ -339,9 +388,9 @@ class VoltrClient extends AccountUtils {
      *   }
      * );
      */
-    async createWithdrawIx(amount, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
+    async createWithdrawVaultIx(amount, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }) {
         return await this.vaultProgram.methods
-            .withdraw(amount)
+            .withdrawVault(amount)
             .accounts({
             userTransferAuthority: userAuthority,
             vault,
@@ -356,6 +405,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 +416,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 +443,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 +459,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 +475,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 +505,7 @@ class VoltrClient extends AccountUtils {
      *     additionalArgs: Buffer.from('...')
      *   },
      *   {
+     *     manager: managerPubkey,
      *     vault: vaultPubkey,
      *     vaultAssetMint: mintPubkey,
      *     strategy: strategyPubkey,
@@ -459,10 +516,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 +533,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 +566,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,27 +584,124 @@ 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
     /**
      * Fetches all strategy init receipt accounts
@@ -677,9 +833,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>;
 };

package/dist/constants.js

@@ -1,14 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEEDS = exports.DEFAULT_ADAPTOR_PROGRAM_ID = exports.VAULT_PROGRAM_ID = void 0;
+exports.SEEDS = exports.REDEMPTION_FEE_PERCENTAGE_BPS = exports.DEFAULT_ADAPTOR_PROGRAM_ID = exports.VAULT_PROGRAM_ID = void 0;
 const web3_js_1 = require("@solana/web3.js");
 exports.VAULT_PROGRAM_ID = new web3_js_1.PublicKey("vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8");
 exports.DEFAULT_ADAPTOR_PROGRAM_ID = new web3_js_1.PublicKey("aVoLTRCRt3NnnchvLYH6rMYehJHwM5m45RmLBZq7PGz");
+exports.REDEMPTION_FEE_PERCENTAGE_BPS = 10;
 exports.SEEDS = {
     VAULT_LP_MINT: Buffer.from("vault_lp_mint"),
-    VAULT_LP_FEE_AUTH: Buffer.from("vault_lp_fee_auth"),
     VAULT_ASSET_IDLE_AUTH: Buffer.from("vault_asset_idle_auth"),
     STRATEGY: Buffer.from("strategy"),
     STRATEGY_INIT_RECEIPT: Buffer.from("strategy_init_receipt"),
     VAULT_STRATEGY_AUTH: Buffer.from("vault_strategy_auth"),
+    DIRECT_WITHDRAW_INIT_RECEIPT_SEED: Buffer.from("direct_withdraw_init_receipt"),
 };