@voltr/vault-sdk 1.0.19 → 1.0.21

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, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, RequestWithdrawVaultArgs, VaultConfigField } from "./types";
+import { VaultParams, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs, InitializeDirectWithdrawStrategyArgs, RequestWithdrawVaultArgs, InstantWithdrawVaultArgs, InstantWithdrawStrategyArgs, VaultConfigField, ProtocolConfigField, ProtocolFeeField } from "./types";
 declare class AccountUtils {
     conn: Connection;
     constructor(conn: Connection);
@@ -135,6 +135,92 @@ export declare class VoltrClient extends AccountUtils {
      * ```
      */
     findLpMetadataAccount(vault: PublicKey): PublicKey;
+    /**
+     * Finds the protocol PDA address
+     * @returns The PDA for the protocol account
+     *
+     * @example
+     * ```typescript
+     * const protocol = client.findProtocol();
+     * ```
+     */
+    findProtocol(): PublicKey;
+    /**
+     * Creates an instruction to initialize the protocol
+     *
+     * @param {number} operationalState - Bitflags for allowed operations (e.g., CREATE_VAULT = 1, DEPOSIT_VAULT = 2, etc.)
+     * @param {Object} params - Parameters for initializing the protocol
+     * @param {PublicKey} params.payer - Public key of the fee payer
+     * @param {PublicKey} params.admin - Public key of the protocol admin
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for initializing the protocol
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInitProtocolIx(
+     *   0xFFFF, // enable all operations
+     *   {
+     *     payer: payerPubkey,
+     *     admin: adminPubkey,
+     *   }
+     * );
+     * ```
+     */
+    createInitProtocolIx(operationalState: number, { payer, admin, }: {
+        payer: PublicKey;
+        admin: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to update the protocol configuration
+     *
+     * @param {ProtocolConfigField} field - The protocol configuration field to update
+     * @param {Buffer} data - The serialized data for the new value
+     * @param {Object} params - Parameters for updating the protocol
+     * @param {PublicKey} params.admin - Public key of the protocol admin
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for updating the protocol
+     *
+     * @throws {Error} If the field is unknown
+     *
+     * @example Update operational state
+     * ```typescript
+     * const data = Buffer.alloc(2);
+     * data.writeUInt16LE(0xFFFF, 0);
+     * const ix = await client.createUpdateProtocolIx(
+     *   ProtocolConfigField.OperationalState,
+     *   data,
+     *   { admin: adminPubkey }
+     * );
+     * ```
+     *
+     * @example Set pending admin for 2-step transfer
+     * ```typescript
+     * const data = newAdmin.toBuffer();
+     * const ix = await client.createUpdateProtocolIx(
+     *   ProtocolConfigField.PendingAdmin,
+     *   data,
+     *   { admin: adminPubkey }
+     * );
+     * ```
+     */
+    createUpdateProtocolIx(field: ProtocolConfigField, data: Buffer, { admin, }: {
+        admin: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to accept a protocol admin transfer (2-step admin transfer)
+     *
+     * @param {Object} params - Parameters for accepting protocol admin
+     * @param {PublicKey} params.pendingAdmin - Public key of the pending admin (must be signer)
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for accepting protocol admin
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createAcceptProtocolAdminIx({
+     *   pendingAdmin: pendingAdminPubkey,
+     * });
+     * ```
+     */
+    createAcceptProtocolAdminIx({ pendingAdmin, }: {
+        pendingAdmin: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to initialize a new vault
      *
@@ -399,6 +485,45 @@ export declare class VoltrClient extends AccountUtils {
         vaultAssetMint: PublicKey;
         assetTokenProgram: PublicKey;
     }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instant withdraw instruction for a vault (no waiting period required)
+     *
+     * @param {InstantWithdrawVaultArgs} args - Instant withdrawal arguments
+     * @param {BN} args.amount - Amount to withdraw (in LP tokens or asset, depending on isAmountInLp)
+     * @param {boolean} args.isAmountInLp - Whether the amount is denominated in LP tokens
+     * @param {boolean} args.isWithdrawAll - Whether to withdraw all user's LP tokens
+     * @param {Object} params - Instant withdraw parameters
+     * @param {PublicKey} params.userTransferAuthority - Public key of the user's transfer authority
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for instant withdrawal
+     *
+     * @throws {Error} If the vault's withdrawal waiting period is not zero
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInstantWithdrawVaultIx(
+     *   {
+     *     amount: new BN('1000000000'),
+     *     isAmountInLp: true,
+     *     isWithdrawAll: false,
+     *   },
+     *   {
+     *     userTransferAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     assetTokenProgram: tokenProgramPubkey,
+     *   }
+     * );
+     * ```
+     */
+    createInstantWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }: InstantWithdrawVaultArgs, { userTransferAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+        userTransferAuthority: PublicKey;
+        vault: PublicKey;
+        vaultAssetMint: PublicKey;
+        assetTokenProgram: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to add an adaptor to a vault
      * @param {Object} params - Parameters for adding adaptor to vault
@@ -424,7 +549,7 @@ export declare class VoltrClient extends AccountUtils {
         vault: PublicKey;
         payer: PublicKey;
         admin: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to initialize a strategy to a vault
@@ -464,7 +589,7 @@ export declare class VoltrClient extends AccountUtils {
         vault: PublicKey;
         manager: PublicKey;
         strategy: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
         remainingAccounts: Array<{
             pubkey: PublicKey;
             isSigner: boolean;
@@ -515,7 +640,7 @@ export declare class VoltrClient extends AccountUtils {
         vaultAssetMint: PublicKey;
         strategy: PublicKey;
         assetTokenProgram: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
         remainingAccounts: Array<{
             pubkey: PublicKey;
             isSigner: boolean;
@@ -564,7 +689,7 @@ export declare class VoltrClient extends AccountUtils {
         vaultAssetMint: PublicKey;
         strategy: PublicKey;
         assetTokenProgram: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
         remainingAccounts: Array<{
             pubkey: PublicKey;
             isSigner: boolean;
@@ -592,7 +717,7 @@ export declare class VoltrClient extends AccountUtils {
     createRemoveAdaptorIx({ vault, admin, adaptorProgram, }: {
         vault: PublicKey;
         admin: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to initialize a direct withdraw strategy
@@ -632,7 +757,7 @@ export declare class VoltrClient extends AccountUtils {
         admin: PublicKey;
         vault: PublicKey;
         strategy: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
     }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to withdraw assets from a direct withdraw strategy
@@ -675,7 +800,7 @@ export declare class VoltrClient extends AccountUtils {
         strategy: PublicKey;
         vaultAssetMint: PublicKey;
         assetTokenProgram: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
         remainingAccounts: Array<{
             pubkey: PublicKey;
             isSigner: boolean;
@@ -683,19 +808,20 @@ export declare class VoltrClient extends AccountUtils {
         }>;
     }): Promise<TransactionInstruction>;
     /**
-     * Creates an instruction to withdraw assets from a strategy via direct withdrawal with tolerance
-     * @param {Object} args - Arguments for the withdrawal
-     * @param {Buffer | null} args.userArgs - Optional user arguments
-     * @param {BN} args.tolerance - Tolerance amount for the withdrawal
+     * Creates an instruction to withdraw assets from a direct withdraw strategy with slippage tolerance
+     *
+     * @param {Object} directWithdrawArgs - Withdrawal arguments
+     * @param {Buffer | null} [directWithdrawArgs.userArgs] - Optional user arguments for the instruction
+     * @param {BN} directWithdrawArgs.tolerance - Slippage tolerance in asset amount (max difference between requested and actual)
      * @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 {PublicKey} [params.adaptorProgram] - Public key of the adaptor program (defaults to lending adaptor)
      * @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 with tolerance
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for direct withdraw with tolerance
      * @throws {Error} If instruction creation fails
      *
      * @example
@@ -703,7 +829,7 @@ export declare class VoltrClient extends AccountUtils {
      * const ix = await client.createDirectWithdrawStrategyWithToleranceIx(
      *   {
      *     userArgs: Buffer.from('...'),
-     *     tolerance: new BN(1)
+     *     tolerance: new BN(1000),
      *   },
      *   {
      *     user: userPubkey,
@@ -711,8 +837,7 @@ export declare class VoltrClient extends AccountUtils {
      *     strategy: strategyPubkey,
      *     vaultAssetMint: mintPubkey,
      *     assetTokenProgram: tokenProgramPubkey,
-     *     adaptorProgram: adaptorProgramPubkey,
-     *     remainingAccounts: []
+     *     remainingAccounts: [],
      *   }
      * );
      * ```
@@ -726,7 +851,113 @@ export declare class VoltrClient extends AccountUtils {
         strategy: PublicKey;
         vaultAssetMint: PublicKey;
         assetTokenProgram: PublicKey;
-        adaptorProgram?: PublicKey;
+        adaptorProgram: PublicKey;
+        remainingAccounts: Array<{
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instant withdraw instruction for a strategy (no waiting period, withdraws directly from strategy)
+     *
+     * @param {InstantWithdrawStrategyArgs} args - Instant withdrawal arguments
+     * @param {BN} args.amount - Amount to withdraw (in LP tokens or asset, depending on isAmountInLp)
+     * @param {boolean} args.isAmountInLp - Whether the amount is denominated in LP tokens
+     * @param {boolean} args.isWithdrawAll - Whether to withdraw all user's LP tokens
+     * @param {Buffer | null} [args.userArgs] - Optional user arguments passed to the adaptor
+     * @param {Object} params - Instant withdraw strategy parameters
+     * @param {PublicKey} params.userTransferAuthority - Public key of the user's transfer authority
+     * @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 (defaults to lending adaptor)
+     * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for instant strategy withdrawal
+     * @throws {Error} If the vault's withdrawal waiting period is not zero
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInstantWithdrawStrategyIx(
+     *   {
+     *     amount: new BN('1000000000'),
+     *     isAmountInLp: true,
+     *     isWithdrawAll: false,
+     *   },
+     *   {
+     *     userTransferAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *     strategy: strategyPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     assetTokenProgram: tokenProgramPubkey,
+     *     remainingAccounts: [],
+     *   }
+     * );
+     * ```
+     */
+    createInstantWithdrawStrategyIx({ amount, isAmountInLp, isWithdrawAll, userArgs, }: InstantWithdrawStrategyArgs, { userTransferAuthority, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        userTransferAuthority: PublicKey;
+        vault: PublicKey;
+        strategy: PublicKey;
+        vaultAssetMint: PublicKey;
+        assetTokenProgram: PublicKey;
+        adaptorProgram: PublicKey;
+        remainingAccounts: Array<{
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instant withdraw instruction for a strategy with slippage tolerance
+     *
+     * @param {InstantWithdrawStrategyArgs & { tolerance: BN }} args - Instant withdrawal arguments with tolerance
+     * @param {BN} args.amount - Amount to withdraw (in LP tokens or asset, depending on isAmountInLp)
+     * @param {boolean} args.isAmountInLp - Whether the amount is denominated in LP tokens
+     * @param {boolean} args.isWithdrawAll - Whether to withdraw all user's LP tokens
+     * @param {Buffer | null} [args.userArgs] - Optional user arguments passed to the adaptor
+     * @param {BN} args.tolerance - Slippage tolerance in asset amount (max difference between requested and actual)
+     * @param {Object} params - Instant withdraw strategy parameters
+     * @param {PublicKey} params.userTransferAuthority - Public key of the user's transfer authority
+     * @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 (defaults to lending adaptor)
+     * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for instant strategy withdrawal with tolerance
+     * @throws {Error} If the vault's withdrawal waiting period is not zero
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInstantWithdrawStrategyWithToleranceIx(
+     *   {
+     *     amount: new BN('1000000000'),
+     *     isAmountInLp: true,
+     *     isWithdrawAll: false,
+     *     tolerance: new BN(1000),
+     *   },
+     *   {
+     *     userTransferAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *     strategy: strategyPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     assetTokenProgram: tokenProgramPubkey,
+     *     remainingAccounts: [],
+     *   }
+     * );
+     * ```
+     */
+    createInstantWithdrawStrategyWithToleranceIx({ amount, isAmountInLp, isWithdrawAll, userArgs, tolerance, }: InstantWithdrawStrategyArgs & {
+        tolerance: BN;
+    }, { userTransferAuthority, vault, strategy, vaultAssetMint, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        userTransferAuthority: PublicKey;
+        vault: PublicKey;
+        strategy: PublicKey;
+        vaultAssetMint: PublicKey;
+        assetTokenProgram: PublicKey;
+        adaptorProgram: PublicKey;
         remainingAccounts: Array<{
             pubkey: PublicKey;
             isSigner: boolean;
@@ -808,6 +1039,26 @@ export declare class VoltrClient extends AccountUtils {
         vault: PublicKey;
         admin: PublicKey;
     }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to calibrate the high water mark without fee clawback (unsafe)
+     * @param {Object} params - Parameters for calibrating the high water mark
+     * @param {PublicKey} params.vault - Public key of the vault (must be whitelisted)
+     * @param {PublicKey} params.admin - Public key of the admin
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for unsafe calibration
+     * @throws {Error} If instruction creation fails or vault is not whitelisted
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createCalibrateHighWaterMarkUnsafeIx({
+     *   vault: vaultPubkey,
+     *   admin: adminPubkey,
+     * });
+     * ```
+     */
+    createCalibrateHighWaterMarkUnsafeIx({ vault, admin, }: {
+        vault: PublicKey;
+        admin: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Creates an instruction to create LP metadata
      * @param {Object} createLpMetadataArgs - Parameters for creating LP metadata
@@ -839,6 +1090,34 @@ export declare class VoltrClient extends AccountUtils {
         admin: PublicKey;
         vault: PublicKey;
     }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to update per-vault protocol fees (admin-only, protocol level)
+     *
+     * @param {ProtocolFeeField} field - The protocol fee field to update
+     * @param {number} feeBps - The new fee value in basis points
+     * @param {Object} params - Parameters for updating the protocol fee
+     * @param {PublicKey} params.admin - Public key of the protocol admin
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for updating the protocol fee
+     *
+     * @throws {Error} If the total fee (protocol + admin + manager) exceeds 10000 BPS
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createUpdateVaultProtocolFeeIx(
+     *   ProtocolFeeField.ProtocolPerformanceFee,
+     *   500, // 5%
+     *   {
+     *     admin: protocolAdminPubkey,
+     *     vault: vaultPubkey,
+     *   }
+     * );
+     * ```
+     */
+    createUpdateVaultProtocolFeeIx(field: ProtocolFeeField, feeBps: number, { admin, vault, }: {
+        admin: PublicKey;
+        vault: PublicKey;
+    }): Promise<TransactionInstruction>;
     /**
      * Fetches all strategy init receipt accounts
      * @returns Promise resolving to an array of strategy init receipt accounts
@@ -925,6 +1204,24 @@ export declare class VoltrClient extends AccountUtils {
      * @param vault - Public key of the vault
      * @returns Promise resolving to the vault account data
      */
+    /**
+     * Fetches the protocol account's data
+     * @returns Promise resolving to the protocol account data
+     *
+     * @example
+     * ```typescript
+     * const protocolAccount = await client.fetchProtocolAccount();
+     * ```
+     */
+    fetchProtocolAccount(): Promise<{
+        admin: PublicKey;
+        operationalState: number;
+        padding1: number[];
+        bump: number;
+        padding0: number[];
+        pendingAdmin: PublicKey;
+        reserved: number[];
+    }>;
     fetchVaultAccount(vault: PublicKey): Promise<{
         name: number[];
         description: number[];
@@ -1087,6 +1384,17 @@ export declare class VoltrClient extends AccountUtils {
      * ```
      */
     getAccumulatedManagerFeesForVault(vault: PublicKey): Promise<BN>;
+    /**
+     * Fetches the accumulated protocol fees for a vault
+     * @param vault - Public key of the vault
+     * @returns Promise resolving to the accumulated protocol fees
+     *
+     * @example
+     * ```typescript
+     * const accumulatedProtocolFees = await client.getAccumulatedProtocolFeesForVault(vaultPubkey);
+     * ```
+     */
+    getAccumulatedProtocolFeesForVault(vault: PublicKey): Promise<BN>;
     /**
      * Fetches the current asset per LP for a vault
      * @param vault - Public key of the vault
@@ -1175,7 +1483,7 @@ export declare class VoltrClient extends AccountUtils {
      * Helper to calculate only the pending (unrealised) LP fees based on time elapsed.
      */
     private calculateUnrealisedLpFees;
-    calculateAssetsForWithdrawHelper(vaultTotalValue: BN, vaultLastUpdatedLockedProfit: BN, vaultLockedProfitDegradationDuration: BN, vaultAccumulatedLpAdminFees: BN, vaultAccumulatedLpManagerFees: BN, vaultAccumulatedLpProtocolFees: BN, vaultRedemptionFeeBps: number, vaultManagementFeeBps: number, vaultLastManagementFeeUpdateTs: BN, lpSupply: BN, lpAmount: BN): BN;
+    calculateAssetsForWithdrawHelper(vaultTotalValue: BN, vaultLastUpdatedLockedProfit: BN, vaultLockedProfitDegradationDuration: BN, vaultAccumulatedLpAdminFees: BN, vaultAccumulatedLpManagerFees: BN, vaultAccumulatedLpProtocolFees: BN, vaultRedemptionFeeBps: number, vaultManagementFeeBps: number, vaultLastManagementFeeUpdateTs: BN, lpSupply: BN, lpAmount: BN, deadWeight?: BN): BN;
     /**
      * Calculates the amount of assets that would be received for a given LP token amount
      *