@voltr/vault-sdk 1.0.13 → 1.0.14

package/README.md

@@ -64,6 +64,86 @@ const ix = await client.createInitializeVaultIx(vaultParams, {
 });
 ```
 
+### Update Vault Configuration
+
+```typescript
+import { VaultConfigField } from "@voltr/vault-sdk";
+
+// Update max cap
+const maxCapData = client.serializeU64(new BN(20_000_000_000_000));
+const maxCapIx = await client.createUpdateVaultConfigIx(
+  VaultConfigField.MaxCap,
+  maxCapData,
+  {
+    vault: vaultPubkey,
+    admin: adminPubkey,
+  }
+);
+
+// Update withdrawal waiting period
+const waitingPeriodData = client.serializeU64(new BN(5_000));
+const waitingPeriodIx = await client.createUpdateVaultConfigIx(
+  VaultConfigField.WithdrawalWaitingPeriod,
+  waitingPeriodData,
+  {
+    vault: vaultPubkey,
+    admin: adminPubkey,
+  }
+);
+
+// Update manager management fee (requires LP mint)
+const vaultLpMint = client.findVaultLpMint(vaultPubkey);
+const feeData = client.serializeU16(1000); // 10%
+const feeIx = await client.createUpdateVaultConfigIx(
+  VaultConfigField.ManagerManagementFee,
+  feeData,
+  {
+    vault: vaultPubkey,
+    admin: adminPubkey,
+    vaultLpMint: vaultLpMint,
+  }
+);
+
+// Update issuance fee
+const issuanceFeeData = client.serializeU16(75); // 0.75%
+const issuanceFeeIx = await client.createUpdateVaultConfigIx(
+  VaultConfigField.IssuanceFee,
+  issuanceFeeData,
+  {
+    vault: vaultPubkey,
+    admin: adminPubkey,
+  }
+);
+
+// Update vault manager
+const newManager = new PublicKey("...");
+const managerData = client.serializePubkey(newManager);
+const managerIx = await client.createUpdateVaultConfigIx(
+  VaultConfigField.Manager,
+  managerData,
+  {
+    vault: vaultPubkey,
+    admin: adminPubkey,
+  }
+);
+```
+
+#### Available Vault Config Fields
+
+- `VaultConfigField.MaxCap` - Maximum vault capacity (u64)
+- `VaultConfigField.StartAtTs` - Vault start timestamp (u64)
+- `VaultConfigField.LockedProfitDegradationDuration` - Locked profit degradation duration (u64)
+- `VaultConfigField.WithdrawalWaitingPeriod` - Withdrawal waiting period (u64)
+- `VaultConfigField.ManagerPerformanceFee` - Manager performance fee in BPS (u16)
+- `VaultConfigField.AdminPerformanceFee` - Admin performance fee in BPS (u16)
+- `VaultConfigField.ManagerManagementFee` - Manager management fee in BPS (u16, requires LP mint)
+- `VaultConfigField.AdminManagementFee` - Admin management fee in BPS (u16, requires LP mint)
+- `VaultConfigField.RedemptionFee` - Redemption fee in BPS (u16)
+- `VaultConfigField.IssuanceFee` - Issuance fee in BPS (u16)
+- `VaultConfigField.Manager` - Vault manager (PublicKey)
+
+> **Note:** When updating `ManagerManagementFee` or `AdminManagementFee`, you must provide the `vaultLpMint` parameter as these operations charge management fees and require reading the LP mint supply.
+
 ### Strategy Management
 
 ```typescript
@@ -234,6 +314,67 @@ pendingWithdrawals.forEach((withdrawal, index) => {
     );
   }
 });
+
+// Get pending withdrawal for a specific user
+const userWithdrawal = await client.getPendingWithdrawalForUser(
+  vaultPubkey,
+  userPubkey
+);
+console.log(`User withdrawal amount: ${userWithdrawal.amountAssetToWithdrawEffective}`);
+```
+
+### Fee Management
+
+```typescript
+// Calibrate high water mark (admin only)
+const calibrateIx = await client.createCalibrateHighWaterMarkIx({
+  vault: vaultPubkey,
+  admin: adminPubkey,
+});
+
+// Get current high water mark
+const highWaterMark = await client.getHighWaterMarkForVault(vaultPubkey);
+console.log(`Highest asset per LP: ${highWaterMark.highestAssetPerLp}`);
+console.log(
+  `Last updated: ${new Date(highWaterMark.lastUpdatedTs * 1000).toLocaleString()}`
+);
+
+// Get current asset per LP
+const currentAssetPerLp =
+  await client.getCurrentAssetPerLpForVault(vaultPubkey);
+console.log(`Current asset per LP: ${currentAssetPerLp}`);
+
+// Harvest accumulated fees
+const harvestIx = await client.createHarvestFeeIx({
+  harvester: harvesterPubkey,
+  vaultManager: managerPubkey,
+  vaultAdmin: adminPubkey,
+  protocolAdmin: protocolAdminPubkey,
+  vault: vaultPubkey,
+});
+
+// Get accumulated fees
+const adminFees = await client.getAccumulatedAdminFeesForVault(vaultPubkey);
+const managerFees = await client.getAccumulatedManagerFeesForVault(vaultPubkey);
+console.log(`Admin fees: ${adminFees.toString()}`);
+console.log(`Manager fees: ${managerFees.toString()}`);
+```
+
+## Helper Methods
+
+### Serialization Helpers
+
+The SDK provides helper methods to serialize values for vault configuration updates:
+
+```typescript
+// Serialize u64 values (for amounts, timestamps, etc.)
+const u64Data = client.serializeU64(new BN(20_000_000_000_000));
+
+// Serialize u16 values (for fee percentages in basis points)
+const u16Data = client.serializeU16(1000); // 10%
+
+// Serialize PublicKey values (for manager updates)
+const pubkeyData = client.serializePubkey(new PublicKey("..."));
 ```
 
 ## API Reference
@@ -242,61 +383,71 @@ pendingWithdrawals.forEach((withdrawal, index) => {
 
 #### Vault Management
 
-- `createInitializeVaultIx(vaultParams, params)`
-- `createUpdateVaultIx(vaultConfig, params)`
-- `createDepositVaultIx(amount, params)`
-- `createRequestWithdrawVaultIx(requestWithdrawArgs, params)`
-- `createCancelRequestWithdrawVaultIx(params)`
-- `createWithdrawVaultIx(params)`
-- `createHarvestFeeIx(params)`
-- `createCreateLpMetadataIx(createLpMetadataArgs, params)`
+- `createInitializeVaultIx(vaultParams, params)` - Initialize a new vault
+- `createUpdateVaultIx(vaultConfig, params)` - **Deprecated:** Update vault (use `createUpdateVaultConfigIx` instead)
+- `createUpdateVaultConfigIx(field, data, params)` - Update a specific vault configuration field
+- `createDepositVaultIx(amount, params)` - Deposit assets into vault
+- `createRequestWithdrawVaultIx(requestWithdrawArgs, params)` - Request withdrawal from vault
+- `createCancelRequestWithdrawVaultIx(params)` - Cancel a pending withdrawal request
+- `createWithdrawVaultIx(params)` - Execute a withdrawal from vault
+- `createHarvestFeeIx(params)` - Harvest accumulated fees
+- `createCalibrateHighWaterMarkIx(params)` - Calibrate the high water mark
+- `createCreateLpMetadataIx(createLpMetadataArgs, params)` - Create LP token metadata
 
 #### Strategy Management
 
-- `createAddAdaptorIx(params)`
-- `createInitializeStrategyIx(initArgs, params)`
-- `createDepositStrategyIx(depositArgs, params)`
-- `createWithdrawStrategyIx(withdrawArgs, params)`
-- `createInitializeDirectWithdrawStrategyIx(initArgs, params)`
-- `createDirectWithdrawStrategyIx(withdrawArgs, params)`
-- `createCloseStrategyIx(params)`
-- `createRemoveAdaptorIx(params)`
+- `createAddAdaptorIx(params)` - Add an adaptor to a vault
+- `createInitializeStrategyIx(initArgs, params)` - Initialize a new strategy
+- `createDepositStrategyIx(depositArgs, params)` - Deposit assets into a strategy
+- `createWithdrawStrategyIx(withdrawArgs, params)` - Withdraw assets from a strategy
+- `createInitializeDirectWithdrawStrategyIx(initArgs, params)` - Initialize direct withdraw for a strategy
+- `createDirectWithdrawStrategyIx(withdrawArgs, params)` - Execute direct withdrawal from a strategy
+- `createCloseStrategyIx(params)` - Close a strategy
+- `createRemoveAdaptorIx(params)` - Remove an adaptor from a vault
 
 #### Account Data
 
-- `fetchVaultAccount(vault)`
-- `fetchStrategyInitReceiptAccount(strategyInitReceipt)`
-- `fetchAdaptorAddReceiptAccount(adaptorAddReceipt)`
-- `fetchRequestWithdrawVaultReceiptAccount(requestWithdrawVaultReceipt)`
-- `fetchAllStrategyInitReceiptAccounts()`
-- `fetchAllStrategyInitReceiptAccountsOfVault(vault)`
-- `fetchAllAdaptorAddReceiptAccountsOfVault(vault)`
-- `fetchAllRequestWithdrawVaultReceiptsOfVault(vault)`
-- `getPositionAndTotalValuesForVault(vault)`
-- `getAccumulatedAdminFeesForVault(vault)`
-- `getAccumulatedManagerFeesForVault(vault)`
-- `getPendingWithdrawalForUser(vault, user)`
-- `getAllPendingWithdrawalsForVault(vault)`
-- `getCurrentAssetPerLpForVault(vault)`
-- `getHighWaterMarkForVault(vault)`
+- `fetchVaultAccount(vault)` - Fetch vault account data
+- `fetchStrategyInitReceiptAccount(strategyInitReceipt)` - Fetch strategy initialization receipt
+- `fetchAdaptorAddReceiptAccount(adaptorAddReceipt)` - Fetch adaptor add receipt
+- `fetchRequestWithdrawVaultReceiptAccount(requestWithdrawVaultReceipt)` - Fetch withdrawal request receipt
+- `fetchAllStrategyInitReceiptAccounts()` - Fetch all strategy receipts
+- `fetchAllStrategyInitReceiptAccountsOfVault(vault)` - Fetch all strategy receipts for a vault
+- `fetchAllAdaptorAddReceiptAccountsOfVault(vault)` - Fetch all adaptor receipts for a vault
+- `fetchAllRequestWithdrawVaultReceiptsOfVault(vault)` - Fetch all withdrawal requests for a vault
+- `getPositionAndTotalValuesForVault(vault)` - Get position values and total vault value
+- `getAccumulatedAdminFeesForVault(vault)` - Get accumulated admin fees
+- `getAccumulatedManagerFeesForVault(vault)` - Get accumulated manager fees
+- `getPendingWithdrawalForUser(vault, user)` - Get pending withdrawal for a specific user
+- `getAllPendingWithdrawalsForVault(vault)` - Get all pending withdrawals for a vault
+- `getCurrentAssetPerLpForVault(vault)` - Get current asset per LP ratio
+- `getHighWaterMarkForVault(vault)` - Get high water mark information
 
 #### PDA Finding
 
-- `findVaultLpMint(vault)`
-- `findVaultAssetIdleAuth(vault)`
-- `findVaultAddresses(vault)`
-- `findVaultStrategyAuth(vault, strategy)`
-- `findStrategyInitReceipt(vault, strategy)`
-- `findDirectWithdrawInitReceipt(vault, strategy)`
-- `findVaultStrategyAddresses(vault, strategy)`
-- `findRequestWithdrawVaultReceipt(vault, user)`
+- `findVaultLpMint(vault)` - Find vault LP mint address
+- `findVaultAssetIdleAuth(vault)` - Find vault asset idle authority
+- `findVaultAddresses(vault)` - Find all vault-related addresses
+- `findVaultStrategyAuth(vault, strategy)` - Find vault strategy authority
+- `findStrategyInitReceipt(vault, strategy)` - Find strategy initialization receipt
+- `findDirectWithdrawInitReceipt(vault, strategy)` - Find direct withdraw receipt
+- `findVaultStrategyAddresses(vault, strategy)` - Find all strategy-related addresses
+- `findRequestWithdrawVaultReceipt(vault, user)` - Find withdrawal request receipt
+- `findLpMetadataAccount(vault)` - Find LP metadata account
 
 #### Calculations
 
-- `calculateAssetsForWithdraw(vaultPk, lpAmount)`
-- `calculateLpForWithdraw(vaultPk, assetAmount)`
-- `calculateLpForDeposit(vaultPk, assetAmount)`
+- `calculateAssetsForWithdraw(vaultPk, lpAmount)` - Calculate asset amount for LP tokens
+- `calculateLpForWithdraw(vaultPk, assetAmount)` - Calculate LP tokens needed for asset amount
+- `calculateLpForDeposit(vaultPk, assetAmount)` - Calculate LP tokens received for deposit
+
+#### Helper Methods
+
+- `serializeU64(value)` - Serialize a u64 value to Buffer
+- `serializeU16(value)` - Serialize a u16 value to Buffer
+- `serializePubkey(pubkey)` - Serialize a PublicKey to Buffer
+- `getBalance(publicKey)` - Get account balance in lamports
 
 ## License
 
-[MIT](https://choosealicense.com/licenses/mit/)
+[MIT](https://choosealicense.com/licenses/mit/)

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { Program, AnchorProvider, Idl } from "@coral-xyz/anchor";
 import BN from "bn.js";
 import { ConfirmOptions, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { VaultParams, VaultConfig, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, RequestWithdrawVaultArgs } from "./types";
+import { VaultParams, VaultConfig, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, RequestWithdrawVaultArgs, VaultConfigField } from "./types";
 declare class AccountUtils {
     conn: Connection;
     constructor(conn: Connection);
@@ -198,6 +198,10 @@ export declare class VoltrClient extends AccountUtils {
     }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to update a vault
+     *
+     * @deprecated Since version 1.0.14. Use `createUpdateVaultConfigIx` instead for more granular configuration updates.
+     * This method will be removed in a future version.
+     *
      * @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
@@ -212,6 +216,7 @@ export declare class VoltrClient extends AccountUtils {
      *
      * @example
      * ```typescript
+     * // DEPRECATED - Use createUpdateVaultConfigIx instead
      * const ix = await client.createUpdateVaultIx(
      *   {
      *     maxCap: new BN('1000000000'),
@@ -223,12 +228,88 @@ export declare class VoltrClient extends AccountUtils {
      *   },
      *   { vault: vaultPubkey, admin: adminPubkey }
      * );
+     *
+     * // NEW WAY - Update individual fields:
+     * const newMaxCap = new BN('1000000000');
+     * const data = newMaxCap.toArrayLike(Buffer, 'le', 8);
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.MaxCap,
+     *   data,
+     *   { vault: vaultPubkey, admin: adminPubkey }
+     * );
      * ```
      */
     createUpdateVaultIx(vaultConfig: VaultConfig, { vault, admin, }: {
         vault: PublicKey;
         admin: PublicKey;
     }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to update a specific vault configuration field
+     *
+     * @param {VaultConfigField} field - The configuration field to update
+     * @param {Buffer} data - The serialized data for the new value
+     * @param {Object} params - Parameters for updating the vault config
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.admin - Public key of the vault admin
+     * @param {PublicKey} [params.vaultLpMint] - Required when updating management fees
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for updating the vault config
+     *
+     * @throws {Error} If the field requires LP mint but it's not provided
+     *
+     * @example Update max cap
+     * ```typescript
+     * const newMaxCap = new BN(20_000_000_000_000);
+     * const data = newMaxCap.toArrayLike(Buffer, "le", 8);
+     *
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.MaxCap,
+     *   data,
+     *   {
+     *     vault: vaultPubkey,
+     *     admin: adminPubkey
+     *   }
+     * );
+     * ```
+     *
+     * @example Update manager management fee (requires LP mint)
+     * ```typescript
+     * const newManagerManagementFee = 1000; // 10%
+     * const data = Buffer.alloc(2);
+     * data.writeUInt16LE(newManagerManagementFee, 0);
+     *
+     * const vaultLpMint = client.findVaultLpMint(vaultPubkey);
+     *
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.ManagerManagementFee,
+     *   data,
+     *   {
+     *     vault: vaultPubkey,
+     *     admin: adminPubkey,
+     *     vaultLpMint: vaultLpMint
+     *   }
+     * );
+     * ```
+     *
+     * @example Update manager (requires Pubkey)
+     * ```typescript
+     * const newManager = new PublicKey('...');
+     * const data = newManager.toBuffer();
+     *
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.Manager,
+     *   data,
+     *   {
+     *     vault: vaultPubkey,
+     *     admin: adminPubkey
+     *   }
+     * );
+     * ```
+     */
+    createUpdateVaultConfigIx(field: VaultConfigField, data: Buffer, { vault, admin, vaultLpMint, }: {
+        vault: PublicKey;
+        admin: PublicKey;
+        vaultLpMint?: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Creates a deposit instruction for a vault
      *

package/dist/client.js

@@ -42,6 +42,7 @@ const bn_js_1 = __importDefault(require("bn.js"));
 const web3_js_1 = require("@solana/web3.js");
 const spl_token_1 = require("@solana/spl-token");
 const constants_1 = require("./constants");
+const types_1 = require("./types");
 // Import IDL files
 const vaultIdl = __importStar(require("./idl/voltr_vault.json"));
 const decimals_1 = require("./decimals");
@@ -340,6 +341,10 @@ class VoltrClient extends AccountUtils {
     }
     /**
      * Creates an instruction to update a vault
+     *
+     * @deprecated Since version 1.0.14. Use `createUpdateVaultConfigIx` instead for more granular configuration updates.
+     * This method will be removed in a future version.
+     *
      * @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
@@ -354,6 +359,7 @@ class VoltrClient extends AccountUtils {
      *
      * @example
      * ```typescript
+     * // DEPRECATED - Use createUpdateVaultConfigIx instead
      * const ix = await client.createUpdateVaultIx(
      *   {
      *     maxCap: new BN('1000000000'),
@@ -365,6 +371,15 @@ class VoltrClient extends AccountUtils {
      *   },
      *   { vault: vaultPubkey, admin: adminPubkey }
      * );
+     *
+     * // NEW WAY - Update individual fields:
+     * const newMaxCap = new BN('1000000000');
+     * const data = newMaxCap.toArrayLike(Buffer, 'le', 8);
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.MaxCap,
+     *   data,
+     *   { vault: vaultPubkey, admin: adminPubkey }
+     * );
      * ```
      */
     async createUpdateVaultIx(vaultConfig, { vault, admin, }) {
@@ -380,6 +395,114 @@ class VoltrClient extends AccountUtils {
         ])
             .instruction();
     }
+    /**
+     * Creates an instruction to update a specific vault configuration field
+     *
+     * @param {VaultConfigField} field - The configuration field to update
+     * @param {Buffer} data - The serialized data for the new value
+     * @param {Object} params - Parameters for updating the vault config
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.admin - Public key of the vault admin
+     * @param {PublicKey} [params.vaultLpMint] - Required when updating management fees
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for updating the vault config
+     *
+     * @throws {Error} If the field requires LP mint but it's not provided
+     *
+     * @example Update max cap
+     * ```typescript
+     * const newMaxCap = new BN(20_000_000_000_000);
+     * const data = newMaxCap.toArrayLike(Buffer, "le", 8);
+     *
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.MaxCap,
+     *   data,
+     *   {
+     *     vault: vaultPubkey,
+     *     admin: adminPubkey
+     *   }
+     * );
+     * ```
+     *
+     * @example Update manager management fee (requires LP mint)
+     * ```typescript
+     * const newManagerManagementFee = 1000; // 10%
+     * const data = Buffer.alloc(2);
+     * data.writeUInt16LE(newManagerManagementFee, 0);
+     *
+     * const vaultLpMint = client.findVaultLpMint(vaultPubkey);
+     *
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.ManagerManagementFee,
+     *   data,
+     *   {
+     *     vault: vaultPubkey,
+     *     admin: adminPubkey,
+     *     vaultLpMint: vaultLpMint
+     *   }
+     * );
+     * ```
+     *
+     * @example Update manager (requires Pubkey)
+     * ```typescript
+     * const newManager = new PublicKey('...');
+     * const data = newManager.toBuffer();
+     *
+     * const ix = await client.createUpdateVaultConfigIx(
+     *   VaultConfigField.Manager,
+     *   data,
+     *   {
+     *     vault: vaultPubkey,
+     *     admin: adminPubkey
+     *   }
+     * );
+     * ```
+     */
+    async createUpdateVaultConfigIx(field, data, { vault, admin, vaultLpMint, }) {
+        // Check if LP mint is required for this field
+        const requiresLpMint = field === types_1.VaultConfigField.ManagerManagementFee ||
+            field === types_1.VaultConfigField.AdminManagementFee;
+        if (requiresLpMint && !vaultLpMint) {
+            throw new Error(`LP mint is required when updating ${field}. Please provide vaultLpMint parameter.`);
+        }
+        // Build remaining accounts array
+        const remainingAccounts = [];
+        if (requiresLpMint && vaultLpMint) {
+            remainingAccounts.push({
+                pubkey: vaultLpMint,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
+        const fieldToVariant = {
+            [types_1.VaultConfigField.MaxCap]: { maxCap: {} },
+            [types_1.VaultConfigField.StartAtTs]: { startAtTs: {} },
+            [types_1.VaultConfigField.LockedProfitDegradationDuration]: {
+                lockedProfitDegradationDuration: {},
+            },
+            [types_1.VaultConfigField.WithdrawalWaitingPeriod]: {
+                withdrawalWaitingPeriod: {},
+            },
+            [types_1.VaultConfigField.ManagerPerformanceFee]: { managerPerformanceFee: {} },
+            [types_1.VaultConfigField.AdminPerformanceFee]: { adminPerformanceFee: {} },
+            [types_1.VaultConfigField.ManagerManagementFee]: { managerManagementFee: {} },
+            [types_1.VaultConfigField.AdminManagementFee]: { adminManagementFee: {} },
+            [types_1.VaultConfigField.RedemptionFee]: { redemptionFee: {} },
+            [types_1.VaultConfigField.IssuanceFee]: { issuanceFee: {} },
+            [types_1.VaultConfigField.Manager]: { manager: {} },
+        };
+        const fieldVariant = fieldToVariant[field];
+        if (!fieldVariant) {
+            throw new Error(`Unknown vault config field: ${field}`);
+        }
+        return await this.vaultProgram.methods
+            .updateVaultConfig(fieldVariant, data)
+            .accountsPartial({
+            admin,
+            vault,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
     /**
      * Creates a deposit instruction for a vault
      *

package/dist/idl/voltr_vault.json

@@ -2,7 +2,7 @@
     "address": "vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8",
     "metadata": {
         "name": "voltr_vault",
-        "version": "0.1.0",
+        "version": "0.2.0",
         "spec": "0.1.0",
         "description": "Created with Anchor"
     },
@@ -3274,6 +3274,70 @@
                 }
             ]
         },
+        {
+            "name": "update_vault_config",
+            "discriminator": [
+                122,
+                3,
+                21,
+                222,
+                158,
+                255,
+                238,
+                157
+            ],
+            "accounts": [
+                {
+                    "name": "admin",
+                    "signer": true,
+                    "relations": [
+                        "vault"
+                    ]
+                },
+                {
+                    "name": "protocol",
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const",
+                                "value": [
+                                    112,
+                                    114,
+                                    111,
+                                    116,
+                                    111,
+                                    99,
+                                    111,
+                                    108
+                                ]
+                            }
+                        ]
+                    }
+                },
+                {
+                    "name": "vault",
+                    "writable": true
+                },
+                {
+                    "name": "rent",
+                    "address": "SysvarRent111111111111111111111111111111111"
+                }
+            ],
+            "args": [
+                {
+                    "name": "field",
+                    "type": {
+                        "defined": {
+                            "name": "VaultConfigField"
+                        }
+                    }
+                },
+                {
+                    "name": "data",
+                    "type": "bytes"
+                }
+            ]
+        },
         {
             "name": "withdraw_strategy",
             "discriminator": [
@@ -4291,6 +4355,19 @@
                 237
             ]
         },
+        {
+            "name": "UpdateVaultConfigEvent",
+            "discriminator": [
+                61,
+                92,
+                206,
+                151,
+                162,
+                40,
+                237,
+                103
+            ]
+        },
         {
             "name": "UpdateVaultEvent",
             "discriminator": [
@@ -4401,6 +4478,11 @@
             "code": 6013,
             "name": "InvalidInput",
             "msg": "Invalid input."
+        },
+        {
+            "code": 6014,
+            "name": "DivisionByZero",
+            "msg": "Division by zero."
         }
     ],
     "types": [
@@ -5656,6 +5738,38 @@
                 ]
             }
         },
+        {
+            "name": "UpdateVaultConfigEvent",
+            "type": {
+                "kind": "struct",
+                "fields": [
+                    {
+                        "name": "admin",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "vault",
+                        "type": "pubkey"
+                    },
+                    {
+                        "name": "field",
+                        "type": "string"
+                    },
+                    {
+                        "name": "old_value",
+                        "type": "string"
+                    },
+                    {
+                        "name": "new_value",
+                        "type": "string"
+                    },
+                    {
+                        "name": "updated_ts",
+                        "type": "u64"
+                    }
+                ]
+            }
+        },
         {
             "name": "UpdateVaultEvent",
             "type": {
@@ -5981,6 +6095,47 @@
                 ]
             }
         },
+        {
+            "name": "VaultConfigField",
+            "type": {
+                "kind": "enum",
+                "variants": [
+                    {
+                        "name": "MaxCap"
+                    },
+                    {
+                        "name": "StartAtTs"
+                    },
+                    {
+                        "name": "LockedProfitDegradationDuration"
+                    },
+                    {
+                        "name": "WithdrawalWaitingPeriod"
+                    },
+                    {
+                        "name": "ManagerPerformanceFee"
+                    },
+                    {
+                        "name": "AdminPerformanceFee"
+                    },
+                    {
+                        "name": "ManagerManagementFee"
+                    },
+                    {
+                        "name": "AdminManagementFee"
+                    },
+                    {
+                        "name": "RedemptionFee"
+                    },
+                    {
+                        "name": "IssuanceFee"
+                    },
+                    {
+                        "name": "Manager"
+                    }
+                ]
+            }
+        },
         {
             "name": "VaultConfiguration",
             "serialization": "bytemuckunsafe",

package/dist/types/vault.d.ts

@@ -34,3 +34,16 @@ export interface RequestWithdrawVaultArgs {
     isAmountInLp: boolean;
     isWithdrawAll: boolean;
 }
+export declare enum VaultConfigField {
+    MaxCap = "maxCap",
+    StartAtTs = "startAtTs",
+    LockedProfitDegradationDuration = "lockedProfitDegradationDuration",
+    WithdrawalWaitingPeriod = "withdrawalWaitingPeriod",
+    ManagerPerformanceFee = "managerPerformanceFee",
+    AdminPerformanceFee = "adminPerformanceFee",
+    ManagerManagementFee = "managerManagementFee",
+    AdminManagementFee = "adminManagementFee",
+    RedemptionFee = "redemptionFee",
+    IssuanceFee = "issuanceFee",
+    Manager = "manager"
+}

package/dist/types/vault.js

@@ -1,2 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultConfigField = void 0;
+var VaultConfigField;
+(function (VaultConfigField) {
+    VaultConfigField["MaxCap"] = "maxCap";
+    VaultConfigField["StartAtTs"] = "startAtTs";
+    VaultConfigField["LockedProfitDegradationDuration"] = "lockedProfitDegradationDuration";
+    VaultConfigField["WithdrawalWaitingPeriod"] = "withdrawalWaitingPeriod";
+    VaultConfigField["ManagerPerformanceFee"] = "managerPerformanceFee";
+    VaultConfigField["AdminPerformanceFee"] = "adminPerformanceFee";
+    VaultConfigField["ManagerManagementFee"] = "managerManagementFee";
+    VaultConfigField["AdminManagementFee"] = "adminManagementFee";
+    VaultConfigField["RedemptionFee"] = "redemptionFee";
+    VaultConfigField["IssuanceFee"] = "issuanceFee";
+    VaultConfigField["Manager"] = "manager";
+})(VaultConfigField || (exports.VaultConfigField = VaultConfigField = {}));

package/dist/types/voltr_vault.d.ts

@@ -8,7 +8,7 @@ export type VoltrVault = {
     "address": "vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8";
     "metadata": {
         "name": "voltrVault";
-        "version": "0.1.0";
+        "version": "0.2.0";
         "spec": "0.1.0";
         "description": "Created with Anchor";
     };
@@ -3280,6 +3280,70 @@ export type VoltrVault = {
                 }
             ];
         },
+        {
+            "name": "updateVaultConfig";
+            "discriminator": [
+                122,
+                3,
+                21,
+                222,
+                158,
+                255,
+                238,
+                157
+            ];
+            "accounts": [
+                {
+                    "name": "admin";
+                    "signer": true;
+                    "relations": [
+                        "vault"
+                    ];
+                },
+                {
+                    "name": "protocol";
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    112,
+                                    114,
+                                    111,
+                                    116,
+                                    111,
+                                    99,
+                                    111,
+                                    108
+                                ];
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "vault";
+                    "writable": true;
+                },
+                {
+                    "name": "rent";
+                    "address": "SysvarRent111111111111111111111111111111111";
+                }
+            ];
+            "args": [
+                {
+                    "name": "field";
+                    "type": {
+                        "defined": {
+                            "name": "vaultConfigField";
+                        };
+                    };
+                },
+                {
+                    "name": "data";
+                    "type": "bytes";
+                }
+            ];
+        },
         {
             "name": "withdrawStrategy";
             "discriminator": [
@@ -4297,6 +4361,19 @@ export type VoltrVault = {
                 237
             ];
         },
+        {
+            "name": "updateVaultConfigEvent";
+            "discriminator": [
+                61,
+                92,
+                206,
+                151,
+                162,
+                40,
+                237,
+                103
+            ];
+        },
         {
             "name": "updateVaultEvent";
             "discriminator": [
@@ -4407,6 +4484,11 @@ export type VoltrVault = {
             "code": 6013;
             "name": "invalidInput";
             "msg": "Invalid input.";
+        },
+        {
+            "code": 6014;
+            "name": "divisionByZero";
+            "msg": "Division by zero.";
         }
     ];
     "types": [
@@ -5662,6 +5744,38 @@ export type VoltrVault = {
                 ];
             };
         },
+        {
+            "name": "updateVaultConfigEvent";
+            "type": {
+                "kind": "struct";
+                "fields": [
+                    {
+                        "name": "admin";
+                        "type": "pubkey";
+                    },
+                    {
+                        "name": "vault";
+                        "type": "pubkey";
+                    },
+                    {
+                        "name": "field";
+                        "type": "string";
+                    },
+                    {
+                        "name": "oldValue";
+                        "type": "string";
+                    },
+                    {
+                        "name": "newValue";
+                        "type": "string";
+                    },
+                    {
+                        "name": "updatedTs";
+                        "type": "u64";
+                    }
+                ];
+            };
+        },
         {
             "name": "updateVaultEvent";
             "type": {
@@ -5987,6 +6101,47 @@ export type VoltrVault = {
                 ];
             };
         },
+        {
+            "name": "vaultConfigField";
+            "type": {
+                "kind": "enum";
+                "variants": [
+                    {
+                        "name": "maxCap";
+                    },
+                    {
+                        "name": "startAtTs";
+                    },
+                    {
+                        "name": "lockedProfitDegradationDuration";
+                    },
+                    {
+                        "name": "withdrawalWaitingPeriod";
+                    },
+                    {
+                        "name": "managerPerformanceFee";
+                    },
+                    {
+                        "name": "adminPerformanceFee";
+                    },
+                    {
+                        "name": "managerManagementFee";
+                    },
+                    {
+                        "name": "adminManagementFee";
+                    },
+                    {
+                        "name": "redemptionFee";
+                    },
+                    {
+                        "name": "issuanceFee";
+                    },
+                    {
+                        "name": "manager";
+                    }
+                ];
+            };
+        },
         {
             "name": "vaultConfiguration";
             "serialization": "bytemuckunsafe";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltr/vault-sdk",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "SDK for interacting with Voltr Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",