@voltr/vault-sdk 1.1.0 → 2.1.0

package/dist/client.d.ts

@@ -1,1544 +0,0 @@
-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, InstantWithdrawVaultArgs, InstantWithdrawStrategyArgs, VaultConfigField, ProtocolConfigField, ProtocolFeeField } from "./types";
-declare class AccountUtils {
-    conn: Connection;
-    constructor(conn: Connection);
-    /**
-     * Gets the balance of a Solana account
-     * @param publicKey - Public key to check balance for
-     * @returns Promise resolving to the account balance in lamports
-     * @throws {Error} If fetching balance fails
-     */
-    getBalance(publicKey: PublicKey): Promise<number>;
-}
-/**
- * Main client for interacting with the Voltr protocol
- *
- * @remarks
- * The VoltrClient provides methods for initializing and managing vaults,
- * handling strategies, and performing deposits/withdrawals. It requires
- * a Solana connection and optionally accepts a wallet for signing transactions.
- *
- * @example
- * ```typescript
- * import { VoltrClient } from '@voltr/vault-sdk';
- * import { Connection } from '@solana/web3.js';
- *
- * const connection = new Connection('https://api.mainnet-beta.solana.com');
- * const client = new VoltrClient(connection);
- * ```
- */
-export declare class VoltrClient extends AccountUtils {
-    provider: AnchorProvider;
-    vaultProgram: Program<VoltrVault>;
-    vaultIdl: Idl;
-    /**
-     * Creates a new VoltrClient instance
-     * @param conn - Solana connection instance
-     * @param wallet - Optional keypair for signing transactions
-     */
-    constructor(conn: Connection, wallet?: Keypair, opts?: ConfirmOptions);
-    private setProvider;
-    private setPrograms;
-    /**
-     * Finds the vault LP mint address for a given vault
-     * @param vault - Public key of the vault
-     * @returns The PDA for the vault's LP mint
-     */
-    findVaultLpMint(vault: PublicKey): PublicKey;
-    /**
-     * Finds the vault's asset idle authority address
-     * @param vault - Public key of the vault
-     * @returns The PDA for the vault's asset idle authority
-     */
-    findVaultAssetIdleAuth(vault: PublicKey): PublicKey;
-    /**
-     * Finds all vault-related addresses
-     * @param vault - Public key of the vault
-     * @returns Object containing all vault-related PDAs
-     *
-     * @example
-     * ```typescript
-     * const addresses = client.findVaultAddresses(vaultPubkey);
-     * console.log(addresses.vaultLpMint.toBase58());
-     * console.log(addresses.vaultAssetIdleAuth.toBase58());
-     * console.log(addresses.vaultLpFeeAuth.toBase58());
-     * ```
-     */
-    findVaultAddresses(vault: PublicKey): {
-        vaultLpMint: PublicKey;
-        vaultAssetIdleAuth: PublicKey;
-    };
-    /**
-     * Finds the vault strategy auth address
-     * @param vault - Public key of the vault
-     * @param strategy - Public key of the strategy
-     * @returns The PDA for the vault strategy auth
-     *
-     * @example
-     * ```typescript
-     * const vaultStrategyAuth = client.findVaultStrategyAuth(vaultPubkey, strategyPubkey);
-     * ```
-     */
-    findVaultStrategyAuth(vault: PublicKey, strategy: PublicKey): PublicKey;
-    /**
-     * Finds the strategy init receipt address
-     * @param vault - Public key of the vault
-     * @param strategy - Public key of the strategy
-     * @returns The PDA for the strategy init receipt
-     *
-     * @example
-     * ```typescript
-     * const strategyInitReceipt = client.findStrategyInitReceipt(vaultPubkey, strategyPubkey);
-     * ```
-     */
-    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;
-    };
-    /**
-     * Finds the request withdraw vault receipt address
-     * @param vault - Public key of the vault
-     * @param user - Public key of the user
-     * @returns The PDA for the request withdraw vault receipt
-     *
-     * @example
-     * ```typescript
-     * const requestWithdrawVaultReceipt = client.findRequestWithdrawVaultReceipt(vaultPubkey, userPubkey);
-     * ```
-     */
-    findRequestWithdrawVaultReceipt(vault: PublicKey, user: PublicKey): PublicKey;
-    /**
-     * Finds the LP metadata account for a given vault
-     * @param vault - Public key of the vault
-     * @returns The PDA for the LP metadata account
-     *
-     * @example
-     * ```typescript
-     * const lpMetadataAccount = client.findLpMetadataAccount(vaultPubkey);
-     * ```
-     */
-    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
-     *
-     * @param {VaultParams} vaultParams - Configuration parameters for the vault
-     * @param {VaultConfig} vaultParams.config - Vault configuration settings
-     * @param {BN} vaultParams.config.maxCap - Maximum capacity of the vault
-     * @param {BN} vaultParams.config.startAtTs - Vault start timestamp in seconds
-     * @param {BN} vaultParams.config.lockedProfitDegradationDuration - Locked profit degradation duration in seconds
-     * @param {number} vaultParams.config.managerManagementFee - Manager's management fee in basis points (e.g., 50 = 0.5%)
-     * @param {number} vaultParams.config.managerPerformanceFee - Manager's performance fee in basis points (e.g., 1000 = 10%)
-     * @param {number} vaultParams.config.adminManagementFee - Admin's management fee in basis points (e.g., 50 = 0.5%)
-     * @param {number} vaultParams.config.adminPerformanceFee - Admin's performance fee in basis points (e.g., 1000 = 10%)
-     * @param {number} vaultParams.config.redemptionFee - Redemption fee in basis points (e.g., 10 = 0.1%)
-     * @param {number} vaultParams.config.issuanceFee - Issuance fee in basis points (e.g., 10 = 0.1%)
-     * @param {BN} vaultParams.config.withdrawalWaitingPeriod - Withdrawal waiting period in seconds
-     * @param {string} vaultParams.name - Name of the vault
-     * @param {string} vaultParams.description - Description of the vault
-     * @param {Object} params - Additional parameters for initializing the vault
-     * @param {Keypair} params.vault - Keypair for the new vault
-     * @param {PublicKey} params.vaultAssetMint - Public key of the vault's asset mint
-     * @param {PublicKey} params.admin - Public key of the vault admin
-     * @param {PublicKey} params.manager - Public key of the vault manager
-     * @param {PublicKey} params.payer - Public key of the fee payer
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for initializing the vault
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createInitializeVaultIx(
-     *   {
-     *     config: {
-     *       maxCap: new BN('1000000000'),
-     *       startAtTs: new BN(Math.floor(Date.now() / 1000)),
-     *       lockedProfitDegradationDuration: new BN(3600), // 1 hour
-     *       redemptionFee: 10,
-     *       issuanceFee: 10,
-     *       withdrawalWaitingPeriod: new BN(3600), // 1 hour
-     *       managerManagementFee: 50,  // 0.5%
-     *       managerPerformanceFee: 1000,  // 10%
-     *       adminManagementFee: 50,  // 0.5%
-     *       adminPerformanceFee: 1000,  // 10%
-     *     },
-     *     name: "My Vault",
-     *     description: "Example vault"
-     *   },
-     *   {
-     *     vault: vaultKeypair,
-     *     vaultAssetMint: new PublicKey('...'),
-     *     admin: adminPubkey,
-     *     manager: managerPubkey,
-     *     payer: payerPubkey
-     *   }
-     * );
-     * ```
-     */
-    createInitializeVaultIx(vaultParams: VaultParams, { vault, vaultAssetMint, admin, manager, payer, }: {
-        vault: PublicKey;
-        vaultAssetMint: PublicKey;
-        admin: PublicKey;
-        manager: PublicKey;
-        payer: 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 an instruction for the pending admin to accept the vault admin role
-     *
-     * @param {Object} params - Parameters for accepting vault admin
-     * @param {PublicKey} params.pendingAdmin - Public key of the pending admin (must be signer)
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for accepting vault admin
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createAcceptVaultAdminIx({
-     *   pendingAdmin: pendingAdminPubkey,
-     *   vault: vaultPubkey,
-     * });
-     * ```
-     */
-    createAcceptVaultAdminIx({ pendingAdmin, vault, }: {
-        pendingAdmin: PublicKey;
-        vault: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates a deposit instruction for a vault
-     *
-     * @param {BN} amount - Amount of tokens to deposit
-     * @param {Object} params - Deposit 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 depositing tokens
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createDepositVaultIx(
-     *   new BN('1000000000'),
-     *   {
-     *     userTransferAuthority: userPubkey,
-     *     vault: vaultPubkey,
-     *     vaultAssetMint: mintPubkey,
-     *     assetTokenProgram: tokenProgramPubkey
-     *   }
-     * );
-     * ```
-     */
-    createDepositVaultIx(amount: BN, { userTransferAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
-        userTransferAuthority: PublicKey;
-        vault: PublicKey;
-        vaultAssetMint: PublicKey;
-        assetTokenProgram: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates a request withdraw instruction for a vault
-     *
-     * @param {RequestWithdrawVaultArgs} requestWithdrawArgs - Arguments for withdrawing from the vault
-     * @param {BN} requestWithdrawArgs.amount - Amount of LP tokens to withdraw
-     * @param {boolean} requestWithdrawArgs.isAmountInLp - Whether the amount is in LP tokens
-     * @param {boolean} requestWithdrawArgs.isWithdrawAll - Whether to withdraw all assets
-     * @param {Object} params - Request withdraw parameters
-     * @param {PublicKey} params.payer - Public key of the payer
-     * @param {PublicKey} params.userTransferAuthority - Public key of the user authority
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawal
-     *
-     * @throws {Error} If the instruction creation fails
-     *
-     * @example
-     * const ix = await client.createRequestWithdrawVaultIx(
-     *   {
-     *     amount: new BN('1000000000'),
-     *     isAmountInLp: true,
-     *     isWithdrawAll: false,
-     *   },
-     *   {
-     *     payer: payerPubkey,
-     *     userTransferAuthority: userPubkey,
-     *     vault: vaultPubkey,
-     *   }
-     * );
-     */
-    createRequestWithdrawVaultIx({ amount, isAmountInLp, isWithdrawAll }: RequestWithdrawVaultArgs, { payer, userTransferAuthority, vault, }: {
-        payer: PublicKey;
-        userTransferAuthority: PublicKey;
-        vault: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates a cancel withdraw instruction for a vault
-     *
-     * @param {Object} params - Cancel withdraw request parameters
-     * @param {PublicKey} params.userTransferAuthority - Public key of the user authority
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawal
-     *
-     * @throws {Error} If the instruction creation fails
-     *
-     * @example
-     * const ix = await client.createCancelRequestWithdrawVaultIx(
-     *   {
-     *     userTransferAuthority: userPubkey,
-     *     vault: vaultPubkey,
-     *   }
-     * );
-     */
-    createCancelRequestWithdrawVaultIx({ userTransferAuthority, vault, }: {
-        userTransferAuthority: PublicKey;
-        vault: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates a withdraw instruction for a vault
-     *
-     * @param {Object} params - Withdraw parameters
-     * @param {PublicKey} params.userTransferAuthority - Public key of the user 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 withdrawal
-     *
-     * @throws {Error} If the instruction creation fails
-     *
-     * @example
-     * const ix = await client.createWithdrawVaultIx(
-     *   {
-     *     userTransferAuthority: userPubkey,
-     *     vault: vaultPubkey,
-     *     vaultAssetMint: mintPubkey,
-     *     assetTokenProgram: tokenProgramPubkey
-     *   }
-     * );
-     */
-    createWithdrawVaultIx({ userTransferAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
-        userTransferAuthority: PublicKey;
-        vault: PublicKey;
-        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
-     * @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
-     *
-     * @throws {Error} If the instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createAddAdaptorIx({
-     *   vault: vaultPubkey,
-     *   payer: payerPubkey,
-     *   admin: adminPubkey,
-     *   adaptorProgram: adaptorProgramPubkey
-     * });
-     * ```
-     */
-    createAddAdaptorIx({ vault, payer, admin, adaptorProgram, }: {
-        vault: PublicKey;
-        payer: PublicKey;
-        admin: PublicKey;
-        adaptorProgram: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates an instruction to initialize a strategy to a vault
-     * @param {InitializeStrategyArgs} initArgs - Arguments for strategy initialization
-     * @param {Buffer | null} [initArgs.instructionDiscriminator] - Optional discriminator for the instruction
-     * @param {Buffer | null} [initArgs.additionalArgs] - Optional additional arguments for the instruction
-     * @param {Object} params - Parameters for initializing strategy to vault
-     * @param {PublicKey} params.payer - Public key of the payer
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @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
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createInitializeStrategyIx(
-     *   {
-     *     instructionDiscriminator: Buffer.from('...'), // optional
-     *     additionalArgs: Buffer.from('...')           // optional
-     *   },
-     *   {
-     *     payer: payerPubkey,
-     *     vault: vaultPubkey,
-     *     manager: managerPubkey,
-     *     strategy: strategyPubkey,
-     *     adaptorProgram: adaptorProgramPubkey,
-     *     remainingAccounts: []
-     *   }
-     * );
-     * ```
-     */
-    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 {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
-     * @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 depositing assets into strategy
-     * @throws {Error} If the instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createDepositStrategyIx(
-     *   {
-     *     depositAmount: new BN('1000000000'),
-     *     instructionDiscriminator: Buffer.from('...'),
-     *     additionalArgs: Buffer.from('...')
-     *   },
-     *   {
-     *     manager: managerPubkey,
-     *     vault: vaultPubkey,
-     *     vaultAssetMint: mintPubkey,
-     *     strategy: strategyPubkey,
-     *     assetTokenProgram: tokenProgramPubkey,
-     *     adaptorProgram: adaptorProgramPubkey,
-     *     remainingAccounts: []
-     *   }
-     * );
-     * ```
-     */
-    createDepositStrategyIx({ depositAmount, instructionDiscriminator, additionalArgs, }: DepositStrategyArgs, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
-        manager: PublicKey;
-        vault: PublicKey;
-        vaultAssetMint: PublicKey;
-        strategy: PublicKey;
-        assetTokenProgram: PublicKey;
-        adaptorProgram: PublicKey;
-        remainingAccounts: Array<{
-            pubkey: PublicKey;
-            isSigner: boolean;
-            isWritable: boolean;
-        }>;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates an instruction to withdraw assets from a strategy
-     *
-     * @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
-     * @param {Object} params - Strategy withdrawal parameters
-     * @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
-     * @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 strategy
-     * @throws {Error} If the instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createWithdrawStrategyIx(
-     *   {
-     *     withdrawAmount: new BN('1000000000'),
-     *     instructionDiscriminator: Buffer.from('...'),
-     *     additionalArgs: Buffer.from('...')
-     *   },
-     *   {
-     *     vault: vaultPubkey,
-     *     vaultAssetMint: mintPubkey,
-     *     strategy: strategyPubkey,
-     *     assetTokenProgram: tokenProgramPubkey,
-     *     adaptorProgram: adaptorProgramPubkey,
-     *     remainingAccounts: []
-     *   }
-     * );
-     * ```
-     */
-    createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator, additionalArgs, }: WithdrawStrategyArgs, { manager, vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
-        manager: PublicKey;
-        vault: PublicKey;
-        vaultAssetMint: PublicKey;
-        strategy: PublicKey;
-        assetTokenProgram: PublicKey;
-        adaptorProgram: PublicKey;
-        remainingAccounts: Array<{
-            pubkey: PublicKey;
-            isSigner: boolean;
-            isWritable: boolean;
-        }>;
-    }): Promise<TransactionInstruction>;
-    /**
-     * 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 adaptor from vault
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createRemoveAdaptorIx({
-     *   vault: vaultPubkey,
-     *   admin: adminPubkey,
-     *   adaptorProgram: adaptorProgramPubkey
-     * });
-     * ```
-     */
-    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 {Object} directWithdrawArgs - Withdrawal arguments
-     * @param {Buffer | null} [directWithdrawArgs.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(
-     *   {
-     *     userArgs: Buffer.from('...')
-     *   },
-     *   {
-     *     user: userPubkey,
-     *     vault: vaultPubkey,
-     *     strategy: strategyPubkey,
-     *     vaultAssetMint: mintPubkey,
-     *     assetTokenProgram: tokenProgramPubkey,
-     *     adaptorProgram: adaptorProgramPubkey,
-     *     remainingAccounts: []
-     *   }
-     * );
-     * ```
-     */
-    createDirectWithdrawStrategyIx({ userArgs }: {
-        userArgs?: Buffer | null;
-    }, { 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>;
-    /**
-     * 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 (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 direct withdraw with tolerance
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createDirectWithdrawStrategyWithToleranceIx(
-     *   {
-     *     userArgs: Buffer.from('...'),
-     *     tolerance: new BN(1000),
-     *   },
-     *   {
-     *     user: userPubkey,
-     *     vault: vaultPubkey,
-     *     strategy: strategyPubkey,
-     *     vaultAssetMint: mintPubkey,
-     *     assetTokenProgram: tokenProgramPubkey,
-     *     remainingAccounts: [],
-     *   }
-     * );
-     * ```
-     */
-    createDirectWithdrawStrategyWithToleranceIx({ userArgs, tolerance }: {
-        userArgs?: Buffer | null;
-        tolerance: BN;
-    }, { 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>;
-    /**
-     * 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;
-            isWritable: boolean;
-        }>;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates an instruction to harvest fees from a vault
-     * @param {Object} params - Parameters for harvesting fees
-     * @param {PublicKey} params.harvester - Public key of the harvester
-     * @param {PublicKey} params.vaultManager - Public key of the vault manager
-     * @param {PublicKey} params.vaultAdmin - Public key of the vault admin
-     * @param {PublicKey} params.protocolAdmin - Public key of the protocol admin
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for harvesting fees
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createHarvestFeeIx({
-     *   harvester: harvesterPubkey,
-     *   vaultManager: vaultManagerPubkey,
-     *   vaultAdmin: vaultAdminPubkey,
-     *   protocolAdmin: protocolAdminPubkey,
-     *   vault: vaultPubkey,
-     * });
-     * ```
-     */
-    createHarvestFeeIx({ harvester, vaultManager, vaultAdmin, protocolAdmin, vault, }: {
-        harvester: PublicKey;
-        vaultManager: PublicKey;
-        vaultAdmin: PublicKey;
-        protocolAdmin: PublicKey;
-        vault: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates an instruction to close a strategy
-     * @param {Object} params - Parameters for closing strategy
-     * @param {PublicKey} params.payer - Public key of the payer
-     * @param {PublicKey} params.manager - Public key of the manager
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @param {PublicKey} params.strategy - Public key of the strategy
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for closing strategy
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createCloseStrategyIx({
-     *   payer: payerPubkey,
-     *   manager: managerPubkey,
-     *   vault: vaultPubkey,
-     *   strategy: strategyPubkey,
-     * });
-     * ```
-     */
-    createCloseStrategyIx({ payer, manager, vault, strategy, }: {
-        payer: PublicKey;
-        manager: PublicKey;
-        vault: PublicKey;
-        strategy: PublicKey;
-    }): Promise<TransactionInstruction>;
-    /**
-     * Creates an instruction to calibrate the high water mark
-     * @param {Object} params - Parameters for calibrating the high water mark
-     * @param {PublicKey} params.vault - Public key of the vault
-     * @param {PublicKey} params.admin - Public key of the admin
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for calibrating the high water mark
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createCalibrateHighWaterMarkIx({
-     *   vault: vaultPubkey,
-     *   admin: adminPubkey,
-     * });
-     * ```
-     */
-    createCalibrateHighWaterMarkIx({ vault, admin, }: {
-        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
-     * @param {string} createLpMetadataArgs.name - Name of the LP
-     * @param {string} createLpMetadataArgs.symbol - Symbol of the LP
-     * @param {string} createLpMetadataArgs.uri - URI of the LP metadata
-     * @param {Object} params - Parameters for creating LP metadata
-     * @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
-     * @returns {Promise<TransactionInstruction>} Transaction instruction for creating LP metadata
-     * @throws {Error} If instruction creation fails
-     *
-     * @example
-     * ```typescript
-     * const ix = await client.createCreateLpMetadataIx({
-     *   name: "My LP",
-     *   symbol: "MYLP",
-     *   uri: "https://mylp.com/metadata",
-     * });
-     * ```
-     */
-    createCreateLpMetadataIx({ name, symbol, uri, }: {
-        name: string;
-        symbol: string;
-        uri: string;
-    }, { payer, admin, vault, }: {
-        payer: PublicKey;
-        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
-     *
-     * @example
-     * ```typescript
-     * const strategyInitReceiptAccounts = await client.fetchAllStrategyInitReceiptAccounts();
-     * ```
-     */
-    fetchAllStrategyInitReceiptAccounts(): Promise<import("@coral-xyz/anchor").ProgramAccount<{
-        vault: PublicKey;
-        strategy: PublicKey;
-        adaptorProgram: PublicKey;
-        positionValue: BN;
-        lastUpdatedTs: BN;
-        version: number;
-        bump: number;
-        vaultStrategyAuthBump: number;
-        padding0: number[];
-        reserved: number[];
-    }>[]>;
-    /**
-     * Fetches all strategy init receipt accounts of a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to an array of strategy init receipt accounts
-     *
-     * @example
-     * ```typescript
-     * const strategyInitReceiptAccounts = await client.fetchAllStrategyInitReceiptAccountsOfVault(vaultPubkey);
-     * ```
-     */
-    fetchAllStrategyInitReceiptAccountsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
-        vault: PublicKey;
-        strategy: PublicKey;
-        adaptorProgram: PublicKey;
-        positionValue: BN;
-        lastUpdatedTs: BN;
-        version: number;
-        bump: number;
-        vaultStrategyAuthBump: number;
-        padding0: number[];
-        reserved: number[];
-    }>[]>;
-    /**
-     * Fetches all request withdraw vault receipt accounts of a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to an array of request withdraw vault receipt accounts
-     *
-     * @example
-     * ```typescript
-     * const requestWithdrawVaultReceiptAccounts = await client.fetchAllRequestWithdrawVaultReceiptsOfVault(vaultPubkey);
-     * ```
-     */
-    fetchAllRequestWithdrawVaultReceiptsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
-        vault: PublicKey;
-        user: PublicKey;
-        amountLpEscrowed: BN;
-        amountAssetToWithdrawDecimalBits: BN;
-        withdrawableFromTs: BN;
-        bump: number;
-        version: number;
-    }>[]>;
-    /**
-     * Fetches all adaptor add receipt accounts of a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to an array of adaptor add receipt accounts
-     *
-     * @example
-     * ```typescript
-     * const adaptorAddReceiptAccounts = await client.fetchAllAdaptorAddReceiptAccountsOfVault(vaultPubkey);
-     * ```
-     */
-    fetchAllAdaptorAddReceiptAccountsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
-        vault: PublicKey;
-        adaptorProgram: PublicKey;
-        version: number;
-        bump: number;
-        padding0: number[];
-        lastUpdatedEpoch: BN;
-        reserved: number[];
-    }>[]>;
-    /**
-     * Fetches a vault account's data
-     * @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[];
-        asset: {
-            mint: PublicKey;
-            idleAta: PublicKey;
-            totalValue: BN;
-            idleAtaAuthBump: number;
-            reserved: number[];
-        };
-        lp: {
-            mint: PublicKey;
-            mintBump: number;
-            mintAuthBump: number;
-            reserved: number[];
-        };
-        pendingAdmin: PublicKey;
-        manager: PublicKey;
-        admin: PublicKey;
-        vaultConfiguration: {
-            maxCap: BN;
-            startAtTs: BN;
-            lockedProfitDegradationDuration: BN;
-            withdrawalWaitingPeriod: BN;
-            disabledOperations: number;
-            reserved: number[];
-        };
-        feeConfiguration: {
-            managerPerformanceFee: number;
-            adminPerformanceFee: number;
-            managerManagementFee: number;
-            adminManagementFee: number;
-            redemptionFee: number;
-            issuanceFee: number;
-            protocolPerformanceFee: number;
-            protocolManagementFee: number;
-            reserved: number[];
-        };
-        feeUpdate: {
-            lastPerformanceFeeUpdateTs: BN;
-            lastManagementFeeUpdateTs: BN;
-        };
-        feeState: {
-            accumulatedLpManagerFees: BN;
-            accumulatedLpAdminFees: BN;
-            accumulatedLpProtocolFees: BN;
-            reserved: number[];
-        };
-        deadWeight: BN;
-        highWaterMark: {
-            highestAssetPerLpDecimalBits: BN;
-            lastUpdatedTs: BN;
-            reserved: number[];
-        };
-        lastUpdatedTs: BN;
-        version: number;
-        padding0: number[];
-        lockedProfitState: {
-            lastUpdatedLockedProfit: BN;
-            lastReport: BN;
-        };
-        reserved: number[];
-    }>;
-    /**
-     * Fetches a strategy init receipt account's data
-     * @param strategyInitReceipt - Public key of the strategy init receipt account
-     * @returns Promise resolving to the strategy init receipt account data
-     *
-     * @example
-     * ```typescript
-     * const strategyInitReceiptAccount = await client.fetchStrategyInitReceiptAccount(strategyInitReceiptPubkey);
-     * ```
-     */
-    fetchStrategyInitReceiptAccount(strategyInitReceipt: PublicKey): Promise<{
-        vault: PublicKey;
-        strategy: PublicKey;
-        adaptorProgram: PublicKey;
-        positionValue: BN;
-        lastUpdatedTs: BN;
-        version: number;
-        bump: number;
-        vaultStrategyAuthBump: number;
-        padding0: number[];
-        reserved: number[];
-    }>;
-    /**
-     * Fetches an adaptor add receipt account's data
-     * @param adaptorAddReceipt - Public key of the adaptor add receipt account
-     * @returns Promise resolving to the adaptor add receipt account data
-     *
-     * @example
-     * ```typescript
-     * const adaptorAddReceiptAccount = await client.fetchAdaptorAddReceiptAccount(adaptorAddReceiptPubkey);
-     * ```
-     */
-    fetchAdaptorAddReceiptAccount(adaptorAddReceipt: PublicKey): Promise<{
-        vault: PublicKey;
-        adaptorProgram: PublicKey;
-        version: number;
-        bump: number;
-        padding0: number[];
-        lastUpdatedEpoch: BN;
-        reserved: number[];
-    }>;
-    /**
-     * Fetches a request withdraw vault receipt account's data
-     * @param requestWithdrawVaultReceipt - Public key of the request withdraw vault receipt account
-     * @returns Promise resolving to the request withdraw vault receipt account data
-     *
-     * @example
-     * ```typescript
-     * const requestWithdrawVaultReceiptAccount = await client.fetchRequestWithdrawVaultReceiptAccount(requestWithdrawVaultReceiptPubkey);
-     * ```
-     */
-    fetchRequestWithdrawVaultReceiptAccount(requestWithdrawVaultReceipt: PublicKey): Promise<{
-        vault: PublicKey;
-        user: PublicKey;
-        amountLpEscrowed: BN;
-        amountAssetToWithdrawDecimalBits: BN;
-        withdrawableFromTs: BN;
-        bump: number;
-        version: number;
-    }>;
-    /**
-     * Fetches the position and total values for a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to the position and total values
-     *
-     * @example
-     * ```typescript
-     * const positionAndTotalValues = await client.getPositionAndTotalValuesForVault(vaultPubkey);
-     * ```
-     */
-    getPositionAndTotalValuesForVault(vault: PublicKey): Promise<{
-        totalValue: number;
-        strategies: {
-            strategyId: string;
-            amount: number;
-        }[];
-    }>;
-    /**
-     * Fetches the accumulated admin fees for a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to the accumulated admin fees
-     *
-     * @example
-     * ```typescript
-     * const accumulatedAdminFees = await client.getAccumulatedAdminFeesForVault(vaultPubkey);
-     * ```
-     */
-    getAccumulatedAdminFeesForVault(vault: PublicKey): Promise<BN>;
-    /**
-     * Fetches the accumulated manager fees for a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to the accumulated manager fees
-     *
-     * @example
-     * ```typescript
-     * const accumulatedManagerFees = await client.getAccumulatedManagerFeesForVault(vaultPubkey);
-     * ```
-     */
-    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
-     * @returns Promise resolving to the current asset per LP
-     *
-     * @example
-     * ```typescript
-     * const currentAssetPerLp = await client.getCurrentAssetPerLpForVault(vaultPubkey);
-     * ```
-     */
-    getCurrentAssetPerLpForVault(vault: PublicKey): Promise<number>;
-    /**
-     * Fetches the high water mark for a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to the high water mark
-     *
-     * @example
-     * ```typescript
-     * const highWaterMark = await client.getHighWaterMarkForVault(vaultPubkey);
-     * ```
-     */
-    getHighWaterMarkForVault(vault: PublicKey): Promise<{
-        highestAssetPerLp: number;
-        lastUpdatedTs: number;
-    }>;
-    /**
-     * Fetches the breakdown of the LP supply for a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to the breakdown of the LP supply
-     *
-     * @example
-     * ```typescript
-     * const lpSupplyBreakdown = await client.getVaultLpSupplyBreakdown(vaultPubkey);
-     * ```
-     */
-    getVaultLpSupplyBreakdown(vault: PublicKey): Promise<{
-        circulating: BN;
-        unharvestedFees: BN;
-        unrealisedFees: BN;
-        total: BN;
-    }>;
-    /**
-     * Processes a withdrawal receipt into a standardized withdrawal info object
-     * @private
-     */
-    private processWithdrawalReceipt;
-    /**
-     * Fetches the pending withdrawal for a user
-     * @param vault - Public key of the vault
-     * @param user - Public key of the user
-     * @returns Promise resolving to the pending withdrawal
-     *
-     * @example
-     * ```typescript
-     * const pendingWithdrawal = await client.getPendingWithdrawalForUser(vaultPubkey, userPubkey);
-     * ```
-     */
-    getPendingWithdrawalForUser(vault: PublicKey, user: PublicKey): Promise<{
-        user: PublicKey;
-        amountAssetToWithdrawEffective: number;
-        amountAssetToWithdrawAtRequest: number;
-        amountAssetToWithdrawAtPresent: number;
-        amountLpEscrowed: number;
-        withdrawableFromTs: number;
-    }>;
-    /**
-     * Fetches all pending withdrawals for a vault
-     * @param vault - Public key of the vault
-     * @returns Promise resolving to an array of pending withdrawals
-     *
-     * @example
-     * ```typescript
-     * const pendingWithdrawals = await client.getAllPendingWithdrawalsForVault(vaultPubkey);
-     * ```
-     */
-    getAllPendingWithdrawalsForVault(vault: PublicKey): Promise<{
-        user: PublicKey;
-        amountAssetToWithdrawEffective: number;
-        amountAssetToWithdrawAtRequest: number;
-        amountAssetToWithdrawAtPresent: number;
-        amountLpEscrowed: number;
-        withdrawableFromTs: number;
-    }[]>;
-    calculateLockedProfit(lastUpdatedLockedProfit: BN, lastReport: BN, lockedProfitDegradationDuration: BN, currentTime: BN): BN;
-    /**
-     * Helper to calculate only the pending (unrealised) LP fees based on time elapsed.
-     */
-    private calculateUnrealisedLpFees;
-    calculateAssetsForWithdrawHelper(vaultTotalValue: BN, vaultLastUpdatedLockedProfit: BN, vaultLastReport: 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
-     *
-     * @param vaultPk - Public key of the vault
-     * @param lpAmount - Amount of LP tokens to calculate for
-     * @returns Promise resolving to the amount of assets that would be received
-     *
-     * @throws {Error} If LP supply or total assets are invalid
-     * @throws {Error} If math overflow occurs during calculation
-     *
-     * @example
-     * ```typescript
-     * const assetsToReceive = await client.calculateAssetsForWithdraw(
-     *   vaultPubkey,
-     *   new BN('1000000000')
-     * );
-     * ```
-     */
-    calculateAssetsForWithdraw(vaultPk: PublicKey, lpAmount: BN): Promise<BN>;
-    /**
-     * Calculates the amount of LP tokens that would be burned for a given asset amount
-     *
-     * @param vaultPk - Public key of the vault
-     * @param assetAmount - Amount of assets to calculate for
-     * @returns Promise resolving to the amount of LP tokens that would be burned
-     *
-     * @throws {Error} If LP supply or total assets are invalid
-     * @throws {Error} If math overflow occurs during calculation
-     *
-     * @example
-     * ```typescript
-     * const lpTokensToBurn = await client.calculateLpForWithdraw(
-     *   vaultPubkey,
-     *   new BN('1000000000')
-     * );
-     * ```
-     */
-    calculateLpForWithdraw(vaultPk: PublicKey, assetAmount: BN): Promise<BN>;
-    /**
-     * Calculates the amount of LP tokens that would be received for a given asset deposit
-     *
-     * @param vaultPk - Public key of the vault
-     * @param assetAmount - Amount of assets to deposit
-     * @returns Promise resolving to the amount of LP tokens that would be received
-     *
-     * @throws {Error} If math overflow occurs during calculation
-     *
-     * @example
-     * ```typescript
-     * const lpTokens = await client.calculateLpTokensForDeposit(
-     *   vaultPubkey
-     *   new BN('1000000000'),
-     * );
-     * ```
-     */
-    calculateLpForDeposit(vaultPk: PublicKey, assetAmount: BN): Promise<BN>;
-}
-export {};