@hyr0-xyz/program 0.0.8 → 0.0.10

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Address, FixedSizeEncoder, FixedSizeDecoder, FixedSizeCodec, fetchEncodedAccount, FetchAccountConfig, Account, ReadonlyUint8Array, Option, TransactionSigner, ProgramDerivedAddress, Instruction, AccountMeta, InstructionWithData, InstructionWithAccounts, WritableSignerAccount, AccountSignerMeta, WritableAccount, ReadonlyAccount, Encoder, Decoder, Codec, ReadonlySignerAccount } from '@solana/kit';
+import { Address, FixedSizeEncoder, FixedSizeDecoder, FixedSizeCodec, fetchEncodedAccount, FetchAccountConfig, Account, ReadonlyUint8Array, Option, TransactionSigner, ProgramDerivedAddress, Instruction, AccountMeta, InstructionWithData, InstructionWithAccounts, WritableSignerAccount, AccountSignerMeta, WritableAccount, ReadonlyAccount, Encoder, Decoder, Codec, ReadonlySignerAccount, Rpc, GetProgramAccountsApi, GetMultipleAccountsApi } from '@solana/kit';
 export { Account, Address, MaybeAccount, ProgramDerivedAddress, TransactionSigner } from '@solana/kit';
 
 type TransactionAccount = {
@@ -51,9 +51,123 @@ declare enum Policy {
     Multisig = "Multisig"
 }
 
+/** Fee configuration - basis points for each fee type */
+type FeeConfig = {
+    lpFeeBps: number;
+    managerFeeBps: number;
+    protocolFeeBps: number;
+    performanceFeeBps: number;
+};
+type FeeConfigArgs = FeeConfig;
+declare function getFeeConfigEncoder(): FixedSizeEncoder<FeeConfigArgs>;
+declare function getFeeConfigDecoder(): FixedSizeDecoder<FeeConfig>;
+declare function getFeeConfigCodec(): FixedSizeCodec<FeeConfigArgs, FeeConfig>;
+
+/**
+ * Fee Recipients - v2 Fee Collection
+ *
+ * Verified addresses for each fee type recipient
+ */
+
+/** Fee recipients - verified addresses for each fee type */
+type FeeRecipients = {
+    lpRecipient: Address;
+    managerRecipient: Address;
+    protocolRecipient: Address;
+    performanceRecipient: Address;
+};
+type FeeRecipientsArgs = FeeRecipients;
+declare function getFeeRecipientsEncoder(): FixedSizeEncoder<FeeRecipientsArgs>;
+declare function getFeeRecipientsDecoder(): FixedSizeDecoder<FeeRecipients>;
+declare function getFeeRecipientsCodec(): FixedSizeCodec<FeeRecipientsArgs, FeeRecipients>;
+
+/**
+ * Fee Amounts - v2 Fee Collection
+ *
+ * Tracked amounts per fee type
+ */
+
+/** Fee amounts - tracked per fee type */
+type FeeAmounts = {
+    lp: bigint;
+    manager: bigint;
+    protocol: bigint;
+    performance: bigint;
+};
+type FeeAmountsArgs = {
+    lp: number | bigint;
+    manager: number | bigint;
+    protocol: number | bigint;
+    performance: number | bigint;
+};
+declare function getFeeAmountsEncoder(): FixedSizeEncoder<FeeAmountsArgs>;
+declare function getFeeAmountsDecoder(): FixedSizeDecoder<FeeAmounts>;
+declare function getFeeAmountsCodec(): FixedSizeCodec<FeeAmountsArgs, FeeAmounts>;
+
+/**
+ * Fee Type - v2 Fee Collection
+ *
+ * Enum for claiming specific fees
+ */
+
+/** Fee type enum for claiming specific fees */
+declare enum FeeType {
+    Lp = 0,
+    Manager = 1,
+    Protocol = 2,
+    Performance = 3
+}
+type FeeTypeArgs = FeeType;
+declare function getFeeTypeEncoder(): FixedSizeEncoder<FeeTypeArgs>;
+declare function getFeeTypeDecoder(): FixedSizeDecoder<FeeType>;
+declare function getFeeTypeCodec(): FixedSizeCodec<FeeTypeArgs, FeeType>;
+
+/**
+ * Fee Operation - v2 Fee Collection
+ *
+ * Fee calculation operation types
+ */
+
+/** Fee calculation operation types */
+declare enum FeeOperation {
+    Deposit = 0,
+    Withdraw = 1,
+    UseFunds = 2,
+    ReturnFunds = 3,
+    TimeBased = 4,
+    Performance = 5
+}
+type FeeOperationArgs = FeeOperation;
+declare function getFeeOperationEncoder(): FixedSizeEncoder<FeeOperationArgs>;
+declare function getFeeOperationDecoder(): FixedSizeDecoder<FeeOperation>;
+declare function getFeeOperationCodec(): FixedSizeCodec<FeeOperationArgs, FeeOperation>;
+
+/**
+ * Fraction Fee Config - v2 Fee Collection
+ *
+ * Fee configuration in basis points for fraction-based fee calculation
+ */
+
+/** Fee configuration - basis points for each fee type */
+type FractionFeeConfig = {
+    /** LP fee in basis points (100 = 1%) */
+    lpFeeBps: number;
+    /** Manager fee in basis points */
+    managerFeeBps: number;
+    /** Protocol fee in basis points */
+    protocolFeeBps: number;
+    /** Performance fee in basis points (applied to profits above high water mark) */
+    performanceFeeBps: number;
+};
+type FractionFeeConfigArgs = FractionFeeConfig;
+declare function getFractionFeeConfigEncoder(): FixedSizeEncoder<FractionFeeConfigArgs>;
+declare function getFractionFeeConfigDecoder(): FixedSizeDecoder<FractionFeeConfig>;
+declare function getFractionFeeConfigCodec(): FixedSizeCodec<FractionFeeConfigArgs, FractionFeeConfig>;
+
 type Vault$1 = {
     discriminator: ReadonlyUint8Array;
     policyProgram: Address;
+    feeCollectionProgram: Address;
     seed: string;
     authority: Address;
     shareMint: Address;
@@ -64,6 +178,7 @@ type Vault$1 = {
     onchainBalance: bigint;
     offchainBalance: bigint;
     totalBalance: bigint;
+    obtainedFees: bigint;
     lastBalanceUpdate: bigint;
     highWaterMark: bigint;
     totalFeesPaid: bigint;
@@ -84,10 +199,67 @@ type Transaction = {
 };
 declare function fetchTransaction<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Transaction, TAddress>>;
 
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type VaultFees = {
+    discriminator: ReadonlyUint8Array;
+    /** The vault this fee account belongs to */
+    vault: Address;
+    /** External program that calculates fees (fractions, time-based, all-in-one) */
+    feeCalcProgram: Address;
+    /** Verified recipients for each fee type */
+    recipients: FeeRecipients;
+    /** Unclaimed fees (accumulated from calculations) */
+    unclaimed: FeeAmounts;
+    /** Total fees collected over lifetime */
+    totalCollected: FeeAmounts;
+    /** Total fees claimed over lifetime */
+    totalClaimed: FeeAmounts;
+    /** High water mark for performance fees */
+    highWaterMark: bigint;
+    /** Last fee calculation timestamp */
+    lastUpdate: bigint;
+    /** Bump seed for PDA */
+    bump: number;
+};
+
 /**
  * High-level Vault class for easy vault operations
+ *
+ * Updated for Fee Collection v2:
+ * - Uses pluggable fee calculation programs (fractions, time-based, all-in-one)
+ * - Supports fee recipients configuration
+ * - Tracks unclaimed, collected, and claimed fees
  */
 
+/**
+ * Fee calculation program type for v2 fee collection
+ */
+declare enum FeeCalcProgram {
+    /** Fraction-based fees (percentage of amounts) */
+    Fractions = "fractions",
+    /** Time-based fees (periodic accrual) */
+    TimeBased = "time_based",
+    /** Combined fraction and time-based fees */
+    AllInOne = "all_in_one"
+}
+/**
+ * Fee collection v2 configuration
+ */
+interface FeeCollectionV2Config {
+    /** Fee calculation program to use */
+    feeCalcProgram: FeeCalcProgram;
+    /** Fee recipients for each fee type */
+    recipients: FeeRecipients;
+    /** Fee configuration (for fraction-based fees) */
+    feeConfig?: FractionFeeConfig;
+}
 declare class Vault {
     private _seed;
     private _signer;
@@ -97,13 +269,16 @@ declare class Vault {
     private _policyProgram;
     private _policyAccount?;
     private _params?;
+    private _feeCollectionV2Config?;
     /**
      * Create a new Vault instance
      * @param seed - The seed string for the vault
      * @param signer - The transaction signer
      * @param policy - The policy type to use for the vault
+     * @param params - Optional policy-specific parameters
+     * @param feeCollectionV2Config - Optional fee collection v2 configuration
      */
-    constructor(seed: string, signer: TransactionSigner, policy: Policy, params?: any);
+    constructor(seed: string, signer: TransactionSigner, policy: Policy, params?: any, feeCollectionV2Config?: FeeCollectionV2Config);
     private getPolicyProgramAddress;
     /**
      * Initialize the vault (lazy loads PDAs)
@@ -145,8 +320,32 @@ declare class Vault {
      * Get policy account address
      */
     private getPolicyAccountAddress;
+    /**
+     * Get the fee calculation program address based on the configured type
+     */
+    private getFeeCalcProgramAddress;
+    /**
+     * Get the default fee recipients (all pointing to signer)
+     */
+    private getDefaultFeeRecipients;
+    /**
+     * Get the default fraction fee config (all zero fees)
+     */
+    private getDefaultFractionFeeConfig;
+    /**
+     * Get Vault Fees PDA
+     */
+    getVaultFeesPda(): Promise<ProgramDerivedAddress>;
+    /**
+     * Get Fraction Config PDA
+     */
+    getFractionConfigPda(): Promise<ProgramDerivedAddress>;
     /**
      * Build initialize vault instruction
+     *
+     * This method now uses Fee Collection v2:
+     * - Initializes the vault fees account with recipients and fee calc program
+     * - Optionally initializes the fraction config for percentage-based fees
      */
     buildInitializeVaultInstruction(params: {
         underlyingMint: Address;
@@ -201,6 +400,14 @@ declare const HYRO_PROTOCOL_PROGRAM_ADDRESS: Address<"EGfondqUWdztf79joC5CBDi9HQ
 
 declare const DROPPER_PROGRAM_ADDRESS: Address<"5Lk3HERSPsH82FQH9xGnp6YXjoTczQs6jpJoyG7M5kiC">;
 
+declare const FEE_COLLECTION_PROGRAM_ADDRESS: Address<"4ZC5mGcbKC6HZPDX4aATLywoztyAoied2FojpE7KzAuv">;
+
+declare const FEE_COLLECTION_FRACTIONS_PROGRAM_ADDRESS: Address<"25GwpCDUHnXkLbwxKQuiYsV1isvjTGiCkKPmvmZif16W">;
+
+declare const FEE_COLLECTION_TIME_BASED_PROGRAM_ADDRESS: Address<"TimeBasedFee111111111111111111111111111111">;
+
+declare const FEE_COLLECTION_ALL_IN_ONE_PROGRAM_ADDRESS: Address<"7VrTQ4cqGADz7YcZx6tEGb8yrvNnk2vFE8eS8HoNbdqf">;
+
 /**
  * Allow Any Policy - Permits all transactions
  */
@@ -264,6 +471,309 @@ type ParsedTransferLamportsInstruction<TProgram extends string = typeof DROPPER_
 };
 declare function parseTransferLamportsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedTransferLamportsInstruction<TProgram, TAccountMetas>;
 
+declare const INITIALIZE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitializeDiscriminatorBytes(): ReadonlyUint8Array;
+type InitializeInstruction<TProgram extends string = typeof FEE_COLLECTION_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountVaultFees extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountVault extends string ? ReadonlyAccount<TAccountVault> : TAccountVault,
+    TAccountVaultFees extends string ? WritableAccount<TAccountVaultFees> : TAccountVaultFees,
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+type InitializeInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    config: FeeConfig;
+};
+type InitializeInstructionDataArgs = {
+    config: FeeConfigArgs;
+};
+declare function getInitializeInstructionDataEncoder(): FixedSizeEncoder<InitializeInstructionDataArgs>;
+declare function getInitializeInstructionDataDecoder(): FixedSizeDecoder<InitializeInstructionData>;
+declare function getInitializeInstructionDataCodec(): FixedSizeCodec<InitializeInstructionDataArgs, InitializeInstructionData>;
+type InitializeAsyncInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees?: Address<TAccountVaultFees>;
+    payer: TransactionSigner<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    config: InitializeInstructionDataArgs['config'];
+};
+declare function getInitializeInstructionAsync<TAccountVault extends string, TAccountVaultFees extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: InitializeAsyncInput<TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<InitializeInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>>;
+type InitializeInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees: Address<TAccountVaultFees>;
+    payer: TransactionSigner<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    config: InitializeInstructionDataArgs['config'];
+};
+declare function getInitializeInstruction<TAccountVault extends string, TAccountVaultFees extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: InitializeInput<TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): InitializeInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>;
+type ParsedInitializeInstruction<TProgram extends string = typeof FEE_COLLECTION_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        vault: TAccountMetas[0];
+        vaultFees: TAccountMetas[1];
+        payer: TAccountMetas[2];
+        systemProgram: TAccountMetas[3];
+    };
+    data: InitializeInstructionData;
+};
+declare function parseInitializeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeInstruction<TProgram, TAccountMetas>;
+
+/**
+ * Initialize Fee Collection V2
+ *
+ * Initializes a new fee collection account for a vault with recipients and fee calculation program.
+ * This is the v2 approach that uses pluggable fee calculation programs.
+ */
+
+declare const INITIALIZE_V2_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitializeV2DiscriminatorBytes(): ReadonlyUint8Array;
+type InitializeV2Instruction<TProgram extends string = typeof FEE_COLLECTION_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountVaultFees extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountVault extends string ? ReadonlyAccount<TAccountVault> : TAccountVault,
+    TAccountVaultFees extends string ? WritableAccount<TAccountVaultFees> : TAccountVaultFees,
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+type InitializeV2InstructionData = {
+    discriminator: ReadonlyUint8Array;
+    recipients: FeeRecipients;
+    feeCalcProgram: Address;
+};
+type InitializeV2InstructionDataArgs = {
+    recipients: FeeRecipientsArgs;
+    feeCalcProgram: Address;
+};
+declare function getInitializeV2InstructionDataEncoder(): FixedSizeEncoder<InitializeV2InstructionDataArgs>;
+declare function getInitializeV2InstructionDataDecoder(): FixedSizeDecoder<InitializeV2InstructionData>;
+declare function getInitializeV2InstructionDataCodec(): FixedSizeCodec<InitializeV2InstructionDataArgs, InitializeV2InstructionData>;
+type InitializeV2AsyncInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees?: Address<TAccountVaultFees>;
+    payer: TransactionSigner<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    recipients: InitializeV2InstructionDataArgs['recipients'];
+    feeCalcProgram: InitializeV2InstructionDataArgs['feeCalcProgram'];
+};
+declare function getInitializeV2InstructionAsync<TAccountVault extends string, TAccountVaultFees extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: InitializeV2AsyncInput<TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<InitializeV2Instruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>>;
+type InitializeV2Input<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees: Address<TAccountVaultFees>;
+    payer: TransactionSigner<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    recipients: InitializeV2InstructionDataArgs['recipients'];
+    feeCalcProgram: InitializeV2InstructionDataArgs['feeCalcProgram'];
+};
+declare function getInitializeV2Instruction<TAccountVault extends string, TAccountVaultFees extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: InitializeV2Input<TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): InitializeV2Instruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountPayer, TAccountSystemProgram>;
+
+/**
+ * Initialize Fraction Fee Config
+ *
+ * Initializes a fraction-based fee configuration for a vault.
+ * This sets up the fee percentages (in basis points) for each fee type.
+ */
+
+declare const INITIALIZE_FRACTION_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitializeFractionConfigDiscriminatorBytes(): ReadonlyUint8Array;
+type InitializeFractionConfigInstruction<TProgram extends string = typeof FEE_COLLECTION_FRACTIONS_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountConfigAccount extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountVault extends string ? ReadonlyAccount<TAccountVault> : TAccountVault,
+    TAccountConfigAccount extends string ? WritableAccount<TAccountConfigAccount> : TAccountConfigAccount,
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+type InitializeFractionConfigInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    config: FractionFeeConfig;
+};
+type InitializeFractionConfigInstructionDataArgs = {
+    config: FractionFeeConfigArgs;
+};
+declare function getInitializeFractionConfigInstructionDataEncoder(): FixedSizeEncoder<InitializeFractionConfigInstructionDataArgs>;
+declare function getInitializeFractionConfigInstructionDataDecoder(): FixedSizeDecoder<InitializeFractionConfigInstructionData>;
+declare function getInitializeFractionConfigInstructionDataCodec(): FixedSizeCodec<InitializeFractionConfigInstructionDataArgs, InitializeFractionConfigInstructionData>;
+type InitializeFractionConfigAsyncInput<TAccountVault extends string = string, TAccountConfigAccount extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    configAccount?: Address<TAccountConfigAccount>;
+    payer: TransactionSigner<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    config: InitializeFractionConfigInstructionDataArgs['config'];
+};
+declare function getInitializeFractionConfigInstructionAsync<TAccountVault extends string, TAccountConfigAccount extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_FRACTIONS_PROGRAM_ADDRESS>(input: InitializeFractionConfigAsyncInput<TAccountVault, TAccountConfigAccount, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<InitializeFractionConfigInstruction<TProgramAddress, TAccountVault, TAccountConfigAccount, TAccountPayer, TAccountSystemProgram>>;
+type InitializeFractionConfigInput<TAccountVault extends string = string, TAccountConfigAccount extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    configAccount: Address<TAccountConfigAccount>;
+    payer: TransactionSigner<TAccountPayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    config: InitializeFractionConfigInstructionDataArgs['config'];
+};
+declare function getInitializeFractionConfigInstruction<TAccountVault extends string, TAccountConfigAccount extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_FRACTIONS_PROGRAM_ADDRESS>(input: InitializeFractionConfigInput<TAccountVault, TAccountConfigAccount, TAccountPayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): InitializeFractionConfigInstruction<TProgramAddress, TAccountVault, TAccountConfigAccount, TAccountPayer, TAccountSystemProgram>;
+
+/**
+ * Charge Fees CPI Instruction
+ *
+ * Charges fees via CPI to an external fee calculation program.
+ * This is the core instruction for fee collection v2.
+ */
+
+declare const CHARGE_FEES_CPI_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getChargeFeesCpiDiscriminatorBytes(): ReadonlyUint8Array;
+type ChargeFeesCpiInstruction<TProgram extends string = typeof FEE_COLLECTION_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountVaultFees extends string | AccountMeta<string> = string, TAccountFeeCalcProgram extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountVault extends string ? ReadonlyAccount<TAccountVault> : TAccountVault,
+    TAccountVaultFees extends string ? WritableAccount<TAccountVaultFees> : TAccountVaultFees,
+    TAccountFeeCalcProgram extends string ? ReadonlyAccount<TAccountFeeCalcProgram> : TAccountFeeCalcProgram,
+    ...TRemainingAccounts
+]>;
+type ChargeFeesCpiInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    operation: FeeOperation;
+    amount: bigint;
+    totalBalance: bigint;
+    timestamp: bigint;
+    lastFeeTimestamp: bigint;
+    highWaterMark: bigint;
+};
+type ChargeFeesCpiInstructionDataArgs = {
+    operation: FeeOperationArgs;
+    amount: number | bigint;
+    totalBalance: number | bigint;
+    timestamp: number | bigint;
+    lastFeeTimestamp: number | bigint;
+    highWaterMark: number | bigint;
+};
+declare function getChargeFeesCpiInstructionDataEncoder(): FixedSizeEncoder<ChargeFeesCpiInstructionDataArgs>;
+declare function getChargeFeesCpiInstructionDataDecoder(): FixedSizeDecoder<ChargeFeesCpiInstructionData>;
+declare function getChargeFeesCpiInstructionDataCodec(): FixedSizeCodec<ChargeFeesCpiInstructionDataArgs, ChargeFeesCpiInstructionData>;
+type ChargeFeesCpiAsyncInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountFeeCalcProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees?: Address<TAccountVaultFees>;
+    feeCalcProgram: Address<TAccountFeeCalcProgram>;
+    operation: ChargeFeesCpiInstructionDataArgs['operation'];
+    amount: ChargeFeesCpiInstructionDataArgs['amount'];
+    totalBalance: ChargeFeesCpiInstructionDataArgs['totalBalance'];
+    timestamp: ChargeFeesCpiInstructionDataArgs['timestamp'];
+    lastFeeTimestamp: ChargeFeesCpiInstructionDataArgs['lastFeeTimestamp'];
+    highWaterMark: ChargeFeesCpiInstructionDataArgs['highWaterMark'];
+};
+declare function getChargeFeesCpiInstructionAsync<TAccountVault extends string, TAccountVaultFees extends string, TAccountFeeCalcProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: ChargeFeesCpiAsyncInput<TAccountVault, TAccountVaultFees, TAccountFeeCalcProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<ChargeFeesCpiInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountFeeCalcProgram>>;
+type ChargeFeesCpiInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountFeeCalcProgram extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees: Address<TAccountVaultFees>;
+    feeCalcProgram: Address<TAccountFeeCalcProgram>;
+    operation: ChargeFeesCpiInstructionDataArgs['operation'];
+    amount: ChargeFeesCpiInstructionDataArgs['amount'];
+    totalBalance: ChargeFeesCpiInstructionDataArgs['totalBalance'];
+    timestamp: ChargeFeesCpiInstructionDataArgs['timestamp'];
+    lastFeeTimestamp: ChargeFeesCpiInstructionDataArgs['lastFeeTimestamp'];
+    highWaterMark: ChargeFeesCpiInstructionDataArgs['highWaterMark'];
+};
+declare function getChargeFeesCpiInstruction<TAccountVault extends string, TAccountVaultFees extends string, TAccountFeeCalcProgram extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: ChargeFeesCpiInput<TAccountVault, TAccountVaultFees, TAccountFeeCalcProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): ChargeFeesCpiInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountFeeCalcProgram>;
+
+/**
+ * Claim Fees Instruction
+ *
+ * Claims accumulated fees for a specific fee type from the vault fees account.
+ */
+
+declare const CLAIM_FEES_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getClaimFeesDiscriminatorBytes(): ReadonlyUint8Array;
+type ClaimFeesInstruction<TProgram extends string = typeof FEE_COLLECTION_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountVaultFees extends string | AccountMeta<string> = string, TAccountRecipient extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountVault extends string ? ReadonlyAccount<TAccountVault> : TAccountVault,
+    TAccountVaultFees extends string ? WritableAccount<TAccountVaultFees> : TAccountVaultFees,
+    TAccountRecipient extends string ? ReadonlyAccount<TAccountRecipient> : TAccountRecipient,
+    ...TRemainingAccounts
+]>;
+type ClaimFeesInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    feeType: FeeType;
+    amount: bigint;
+};
+type ClaimFeesInstructionDataArgs = {
+    feeType: FeeTypeArgs;
+    amount: number | bigint;
+};
+declare function getClaimFeesInstructionDataEncoder(): FixedSizeEncoder<ClaimFeesInstructionDataArgs>;
+declare function getClaimFeesInstructionDataDecoder(): FixedSizeDecoder<ClaimFeesInstructionData>;
+declare function getClaimFeesInstructionDataCodec(): FixedSizeCodec<ClaimFeesInstructionDataArgs, ClaimFeesInstructionData>;
+type ClaimFeesAsyncInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountRecipient extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees?: Address<TAccountVaultFees>;
+    recipient: Address<TAccountRecipient>;
+    feeType: ClaimFeesInstructionDataArgs['feeType'];
+    amount: ClaimFeesInstructionDataArgs['amount'];
+};
+declare function getClaimFeesInstructionAsync<TAccountVault extends string, TAccountVaultFees extends string, TAccountRecipient extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: ClaimFeesAsyncInput<TAccountVault, TAccountVaultFees, TAccountRecipient>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<ClaimFeesInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountRecipient>>;
+type ClaimFeesInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountRecipient extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees: Address<TAccountVaultFees>;
+    recipient: Address<TAccountRecipient>;
+    feeType: ClaimFeesInstructionDataArgs['feeType'];
+    amount: ClaimFeesInstructionDataArgs['amount'];
+};
+declare function getClaimFeesInstruction<TAccountVault extends string, TAccountVaultFees extends string, TAccountRecipient extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: ClaimFeesInput<TAccountVault, TAccountVaultFees, TAccountRecipient>, config?: {
+    programAddress?: TProgramAddress;
+}): ClaimFeesInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountRecipient>;
+
+/**
+ * Update Recipients Instruction
+ *
+ * Updates the fee recipient addresses for a vault's fee collection account.
+ */
+
+declare const UPDATE_RECIPIENTS_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getUpdateRecipientsDiscriminatorBytes(): ReadonlyUint8Array;
+type UpdateRecipientsInstruction<TProgram extends string = typeof FEE_COLLECTION_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountVaultFees extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountVault extends string ? ReadonlyAccount<TAccountVault> : TAccountVault,
+    TAccountVaultFees extends string ? WritableAccount<TAccountVaultFees> : TAccountVaultFees,
+    TAccountAuthority extends string ? ReadonlyAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority,
+    ...TRemainingAccounts
+]>;
+type UpdateRecipientsInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    recipients: FeeRecipients;
+};
+type UpdateRecipientsInstructionDataArgs = {
+    recipients: FeeRecipientsArgs;
+};
+declare function getUpdateRecipientsInstructionDataEncoder(): FixedSizeEncoder<UpdateRecipientsInstructionDataArgs>;
+declare function getUpdateRecipientsInstructionDataDecoder(): FixedSizeDecoder<UpdateRecipientsInstructionData>;
+declare function getUpdateRecipientsInstructionDataCodec(): FixedSizeCodec<UpdateRecipientsInstructionDataArgs, UpdateRecipientsInstructionData>;
+type UpdateRecipientsAsyncInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountAuthority extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees?: Address<TAccountVaultFees>;
+    authority: TransactionSigner<TAccountAuthority>;
+    recipients: UpdateRecipientsInstructionDataArgs['recipients'];
+};
+declare function getUpdateRecipientsInstructionAsync<TAccountVault extends string, TAccountVaultFees extends string, TAccountAuthority extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: UpdateRecipientsAsyncInput<TAccountVault, TAccountVaultFees, TAccountAuthority>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<UpdateRecipientsInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountAuthority>>;
+type UpdateRecipientsInput<TAccountVault extends string = string, TAccountVaultFees extends string = string, TAccountAuthority extends string = string> = {
+    vault: Address<TAccountVault>;
+    vaultFees: Address<TAccountVaultFees>;
+    authority: TransactionSigner<TAccountAuthority>;
+    recipients: UpdateRecipientsInstructionDataArgs['recipients'];
+};
+declare function getUpdateRecipientsInstruction<TAccountVault extends string, TAccountVaultFees extends string, TAccountAuthority extends string, TProgramAddress extends Address = typeof FEE_COLLECTION_PROGRAM_ADDRESS>(input: UpdateRecipientsInput<TAccountVault, TAccountVaultFees, TAccountAuthority>, config?: {
+    programAddress?: TProgramAddress;
+}): UpdateRecipientsInstruction<TProgramAddress, TAccountVault, TAccountVaultFees, TAccountAuthority>;
+
 declare const CREATE_TX_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
 declare function getCreateTxDiscriminatorBytes(): ReadonlyUint8Array;
 type CreateTxInstruction<TProgram extends string = typeof HYRO_PROTOCOL_PROGRAM_ADDRESS, TAccountVault extends string | AccountMeta<string> = string, TAccountTransaction extends string | AccountMeta<string> = string, TAccountPolicyAccount extends string | AccountMeta<string> = string, TAccountPolicyProgram extends string | AccountMeta<string> = string, TAccountVaultSigner extends string | AccountMeta<string> = string, TAccountSigner extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
@@ -413,10 +923,12 @@ type InitializeVaultInstructionData = {
     discriminator: ReadonlyUint8Array;
     seed: string;
     policyProgram: Address;
+    feeCollectionProgram: Address;
 };
 type InitializeVaultInstructionDataArgs = {
     seed: string;
     policyProgram: Address;
+    feeCollectionProgram: Address;
 };
 declare function getInitializeVaultInstructionDataEncoder(): Encoder<InitializeVaultInstructionDataArgs>;
 declare function getInitializeVaultInstructionDataDecoder(): Decoder<InitializeVaultInstructionData>;
@@ -435,6 +947,7 @@ type InitializeVaultAsyncInput<TAccountVault extends string = string, TAccountAu
     rent?: Address<TAccountRent>;
     seed: InitializeVaultInstructionDataArgs['seed'];
     policyProgram: InitializeVaultInstructionDataArgs['policyProgram'];
+    feeCollectionProgram: InitializeVaultInstructionDataArgs['feeCollectionProgram'];
 };
 declare function getInitializeVaultInstructionAsync<TAccountVault extends string, TAccountAuthority extends string, TAccountSigner extends string, TAccountSystemProgram extends string, TAccountShareSignerPda extends string, TAccountShareMint extends string, TAccountVaultTokenAccount extends string, TAccountAuthorityTokenAccount extends string, TAccountUnderlyingMint extends string, TAccountTokenProgram extends string, TAccountRent extends string, TProgramAddress extends Address = typeof HYRO_PROTOCOL_PROGRAM_ADDRESS>(input: InitializeVaultAsyncInput<TAccountVault, TAccountAuthority, TAccountSigner, TAccountSystemProgram, TAccountShareSignerPda, TAccountShareMint, TAccountVaultTokenAccount, TAccountAuthorityTokenAccount, TAccountUnderlyingMint, TAccountTokenProgram, TAccountRent>, config?: {
     programAddress?: TProgramAddress;
@@ -453,6 +966,7 @@ type InitializeVaultInput<TAccountVault extends string = string, TAccountAuthori
     rent?: Address<TAccountRent>;
     seed: InitializeVaultInstructionDataArgs['seed'];
     policyProgram: InitializeVaultInstructionDataArgs['policyProgram'];
+    feeCollectionProgram: InitializeVaultInstructionDataArgs['feeCollectionProgram'];
 };
 declare function getInitializeVaultInstruction<TAccountVault extends string, TAccountAuthority extends string, TAccountSigner extends string, TAccountSystemProgram extends string, TAccountShareSignerPda extends string, TAccountShareMint extends string, TAccountVaultTokenAccount extends string, TAccountAuthorityTokenAccount extends string, TAccountUnderlyingMint extends string, TAccountTokenProgram extends string, TAccountRent extends string, TProgramAddress extends Address = typeof HYRO_PROTOCOL_PROGRAM_ADDRESS>(input: InitializeVaultInput<TAccountVault, TAccountAuthority, TAccountSigner, TAccountSystemProgram, TAccountShareSignerPda, TAccountShareMint, TAccountVaultTokenAccount, TAccountAuthorityTokenAccount, TAccountUnderlyingMint, TAccountTokenProgram, TAccountRent>, config?: {
     programAddress?: TProgramAddress;
@@ -705,5 +1219,374 @@ declare function getShareMintPda(vault: ProgramDerivedAddress): Promise<ProgramD
  */
 declare function getVaultTokenAccountPda(vault: ProgramDerivedAddress, underlyingMint: Address): Promise<ProgramDerivedAddress>;
 declare function getPolicyAccountPda(vault: ProgramDerivedAddress, policyprogram: Address): Promise<Address>;
+/**
+ * Get Vault Fees PDA (Fee Collection v2)
+ * @param vault - The vault address
+ * @returns The vault fees PDA
+ */
+declare function getVaultFeesPda(vault: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Get Fraction Config PDA (Fee Collection Fractions program)
+ * @param vault - The vault address
+ * @returns The fraction config PDA
+ */
+declare function getFractionConfigPda(vault: Address): Promise<ProgramDerivedAddress>;
+
+type RpcConfig = {
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+    minContextSlot?: bigint;
+};
+type VaultFilter = {
+    underlyingMint?: Address;
+    policyProgram?: Address;
+    manager?: Address;
+    parentVault?: Address;
+    /** Filter by fee collection program (v2) */
+    feeCollectionProgram?: Address;
+};
+type VaultQueryResult = Account<Vault$1>[];
+type VaultFeesFilter = {
+    /** Filter by vault address */
+    vault?: Address;
+    /** Filter by fee calculation program */
+    feeCalcProgram?: Address;
+    /** Filter by LP recipient */
+    lpRecipient?: Address;
+    /** Filter by manager recipient */
+    managerRecipient?: Address;
+    /** Filter by protocol recipient */
+    protocolRecipient?: Address;
+    /** Filter by performance recipient */
+    performanceRecipient?: Address;
+};
+type VaultFeesQueryResult = Account<VaultFees>[];
+
+declare const VAULT_ACCOUNT_OFFSETS: {
+    readonly DISCRIMINATOR: 0;
+    readonly POLICY_PROGRAM: 8;
+    readonly FEE_COLLECTION_PROGRAM: 40;
+    readonly SEED_LENGTH: 72;
+    readonly SEED_DATA: 76;
+};
+declare const VAULT_FIELD_SIZES: {
+    readonly DISCRIMINATOR: 8;
+    readonly ADDRESS: 32;
+    readonly U32: 4;
+    readonly U64: 8;
+    readonly U16: 2;
+    readonly OPTION_TAG: 1;
+};
+declare const FIXED_OFFSET_FIELDS: {
+    readonly DISCRIMINATOR: 0;
+    readonly POLICY_PROGRAM: 8;
+    readonly FEE_COLLECTION_PROGRAM: 40;
+};
+/**
+ * VaultFees account structure:
+ * - discriminator: 8 bytes
+ * - vault: 32 bytes (Address)
+ * - feeCalcProgram: 32 bytes (Address)
+ * - recipients: 128 bytes (4 x Address = 4 x 32)
+ *   - lpRecipient: 32 bytes
+ *   - managerRecipient: 32 bytes
+ *   - protocolRecipient: 32 bytes
+ *   - performanceRecipient: 32 bytes
+ * - unclaimed: 32 bytes (4 x u64 = 4 x 8)
+ *   - lp: 8 bytes
+ *   - manager: 8 bytes
+ *   - protocol: 8 bytes
+ *   - performance: 8 bytes
+ * - totalCollected: 32 bytes (4 x u64)
+ * - totalClaimed: 32 bytes (4 x u64)
+ * - highWaterMark: 8 bytes (u64)
+ * - lastUpdate: 8 bytes (i64)
+ * - bump: 1 byte
+ * Total: 313 bytes
+ */
+declare const VAULT_FEES_ACCOUNT_OFFSETS: {
+    readonly DISCRIMINATOR: 0;
+    readonly VAULT: 8;
+    readonly FEE_CALC_PROGRAM: 40;
+    readonly RECIPIENTS: 72;
+    readonly LP_RECIPIENT: 72;
+    readonly MANAGER_RECIPIENT: 104;
+    readonly PROTOCOL_RECIPIENT: 136;
+    readonly PERFORMANCE_RECIPIENT: 168;
+    readonly UNCLAIMED: 200;
+    readonly UNCLAIMED_LP: 200;
+    readonly UNCLAIMED_MANAGER: 208;
+    readonly UNCLAIMED_PROTOCOL: 216;
+    readonly UNCLAIMED_PERFORMANCE: 224;
+    readonly TOTAL_COLLECTED: 232;
+    readonly TOTAL_COLLECTED_LP: 232;
+    readonly TOTAL_COLLECTED_MANAGER: 240;
+    readonly TOTAL_COLLECTED_PROTOCOL: 248;
+    readonly TOTAL_COLLECTED_PERFORMANCE: 256;
+    readonly TOTAL_CLAIMED: 264;
+    readonly TOTAL_CLAIMED_LP: 264;
+    readonly TOTAL_CLAIMED_MANAGER: 272;
+    readonly TOTAL_CLAIMED_PROTOCOL: 280;
+    readonly TOTAL_CLAIMED_PERFORMANCE: 288;
+    readonly HIGH_WATER_MARK: 296;
+    readonly LAST_UPDATE: 304;
+    readonly BUMP: 312;
+};
+declare const VAULT_FEES_FIELD_SIZES: {
+    readonly DISCRIMINATOR: 8;
+    readonly VAULT: 32;
+    readonly FEE_CALC_PROGRAM: 32;
+    readonly RECIPIENTS: 128;
+    readonly UNCLAIMED: 32;
+    readonly TOTAL_COLLECTED: 32;
+    readonly TOTAL_CLAIMED: 32;
+    readonly HIGH_WATER_MARK: 8;
+    readonly LAST_UPDATE: 8;
+    readonly BUMP: 1;
+};
+declare const VAULT_FEES_ACCOUNT_SIZE = 313;
+
+type VaultRpcInterface = Rpc<GetProgramAccountsApi & GetMultipleAccountsApi>;
+declare function findVaultsByUnderlyingMint(rpc: VaultRpcInterface, underlyingMint: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+declare function findVaultsByPolicyProgram(rpc: VaultRpcInterface, policyProgram: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+declare function findVaultsByPolicyAccount(rpc: VaultRpcInterface, policyAccount: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+declare function findAllVaults(rpc: VaultRpcInterface, config?: RpcConfig): Promise<VaultQueryResult>;
+declare function findVaultsByManager(rpc: VaultRpcInterface, manager: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+declare function findChildVaults(rpc: VaultRpcInterface, parentVault: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+declare function findVaultsBySeedPrefix(rpc: VaultRpcInterface, seedPrefix: string, config?: RpcConfig): Promise<VaultQueryResult>;
+/**
+ * Find vaults by fee collection program (v2)
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultsByFeeCollectionProgram(rpc: VaultRpcInterface, feeCollectionProgram: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+/**
+ * Find vaults by policy program (v2)
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultsByPolicyProgramV2(rpc: VaultRpcInterface, policyProgram: Address, config?: RpcConfig): Promise<VaultQueryResult>;
+
+/**
+ * VaultFees Query Functions (Fee Collection v2)
+ *
+ * Query and filter VaultFees accounts using memcmp filters
+ */
+
+type VaultFeesRpcInterface = Rpc<GetProgramAccountsApi & GetMultipleAccountsApi>;
+/**
+ * Find all VaultFees accounts
+ */
+declare function findAllVaultFees(rpc: VaultFeesRpcInterface, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees account by vault address
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultFeesByVault(rpc: VaultFeesRpcInterface, vault: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees accounts by fee calculation program
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultFeesByFeeCalcProgram(rpc: VaultFeesRpcInterface, feeCalcProgram: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees accounts by LP recipient
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultFeesByLpRecipient(rpc: VaultFeesRpcInterface, lpRecipient: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees accounts by manager recipient
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultFeesByManagerRecipient(rpc: VaultFeesRpcInterface, managerRecipient: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees accounts by protocol recipient
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultFeesByProtocolRecipient(rpc: VaultFeesRpcInterface, protocolRecipient: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees accounts by performance recipient
+ * Uses RPC-level memcmp filter for efficiency (fixed offset)
+ */
+declare function findVaultFeesByPerformanceRecipient(rpc: VaultFeesRpcInterface, performanceRecipient: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+/**
+ * Find VaultFees accounts by any recipient address
+ * Searches all recipient fields (LP, manager, protocol, performance)
+ */
+declare function findVaultFeesByAnyRecipient(rpc: VaultFeesRpcInterface, recipient: Address, config?: RpcConfig): Promise<VaultFeesQueryResult>;
+
+declare function encodeBase58(bytes: Uint8Array | ReadonlyArray<number>): string;
+
+type MemcmpFilter = {
+    memcmp: {
+        offset: bigint;
+        bytes: string;
+        encoding: 'base58';
+    };
+};
+declare function createMemcmpFilter(offset: number, bytes: Uint8Array | ReadonlyArray<number>): MemcmpFilter;
+declare function createDiscriminatorFilter(discriminator: Uint8Array): MemcmpFilter;
+declare function createAddressFilter(offset: number, address: Address): MemcmpFilter;
+declare function createU8Filter(offset: number, value: number): MemcmpFilter;
+declare function createU16Filter(offset: number, value: number): MemcmpFilter;
+declare function createU32Filter(offset: number, value: number): MemcmpFilter;
+declare function createU64Filter(offset: number, value: number | bigint): MemcmpFilter;
+declare function createPartialBytesFilter(offset: number, bytes: Uint8Array | ReadonlyArray<number>, length?: number): MemcmpFilter;
+
+declare function fetchProgramAccountAddresses(rpc: Rpc<GetProgramAccountsApi>, programAddress: Address, filters: MemcmpFilter[], config?: RpcConfig): Promise<Address[]>;
+declare function fetchProgramAccountsWithData(rpc: Rpc<GetProgramAccountsApi>, programAddress: Address, filters: MemcmpFilter[], config?: RpcConfig): Promise<Array<{
+    pubkey: Address;
+    data: Uint8Array;
+}>>;
+
+declare function getSeedLength(data: Uint8Array): number | null;
+declare function getAuthorityOffset(seedLength: number): number;
+declare function getShareMintOffset(seedLength: number): number;
+declare function getUnderlyingMintOffset(seedLength: number): number;
+declare function getManagerOffset(seedLength: number): number;
+declare function getParentVaultOffset(seedLength: number, managerExists: boolean): number;
+declare function readOptionAddress(data: Uint8Array, offset: number): Uint8Array | null | undefined;
+declare function isOptionSome(data: Uint8Array, offset: number): boolean | undefined;
+/**
+ * Get the vault address offset in VaultFees account (offset: 8)
+ */
+declare function getVaultFeesVaultOffset(): number;
+/**
+ * Get the fee calc program offset in VaultFees account (offset: 40)
+ */
+declare function getVaultFeesFeeCalcProgramOffset(): number;
+/**
+ * Get the LP recipient offset in VaultFees account (offset: 72)
+ */
+declare function getVaultFeesLpRecipientOffset(): number;
+/**
+ * Get the manager recipient offset in VaultFees account (offset: 104)
+ */
+declare function getVaultFeesManagerRecipientOffset(): number;
+/**
+ * Get the protocol recipient offset in VaultFees account (offset: 136)
+ */
+declare function getVaultFeesProtocolRecipientOffset(): number;
+/**
+ * Get the performance recipient offset in VaultFees account (offset: 168)
+ */
+declare function getVaultFeesPerformanceRecipientOffset(): number;
+/**
+ * Get the unclaimed LP fees offset in VaultFees account (offset: 200)
+ */
+declare function getVaultFeesUnclaimedLpOffset(): number;
+/**
+ * Get the unclaimed manager fees offset in VaultFees account (offset: 208)
+ */
+declare function getVaultFeesUnclaimedManagerOffset(): number;
+/**
+ * Get the unclaimed protocol fees offset in VaultFees account (offset: 216)
+ */
+declare function getVaultFeesUnclaimedProtocolOffset(): number;
+/**
+ * Get the unclaimed performance fees offset in VaultFees account (offset: 224)
+ */
+declare function getVaultFeesUnclaimedPerformanceOffset(): number;
+/**
+ * Get the total collected offset in VaultFees account (offset: 232)
+ */
+declare function getVaultFeesTotalCollectedOffset(): number;
+/**
+ * Get the high water mark offset in VaultFees account (offset: 296)
+ */
+declare function getVaultFeesHighWaterMarkOffset(): number;
+/**
+ * Get the last update offset in VaultFees account (offset: 304)
+ */
+declare function getVaultFeesLastUpdateOffset(): number;
+/**
+ * Read a u64 value from VaultFees account data
+ */
+declare function readVaultFeesU64(data: Uint8Array, offset: number): bigint | null;
+/**
+ * Read an address from VaultFees account data
+ */
+declare function readVaultFeesAddress(data: Uint8Array, offset: number): Uint8Array | null;
+
+type AccountWithData = {
+    pubkey: Address;
+    data: Uint8Array;
+};
+declare function filterByUnderlyingMintMemcmp(accounts: AccountWithData[], underlyingMint: Address): Address[];
+declare function filterByManagerMemcmp(accounts: AccountWithData[], manager: Address): Address[];
+declare function filterByParentVaultMemcmp(accounts: AccountWithData[], parentVault: Address): Address[];
+declare function filterBySeedPrefixMemcmp(accounts: AccountWithData[], seedPrefix: string): Address[];
+declare function filterByMemcmp(accounts: AccountWithData[], offset: number, expectedBytes: Uint8Array): Address[];
+declare function filterByMemcmpDynamic(accounts: AccountWithData[], calculateOffset: (data: Uint8Array) => number | null, expectedBytes: Uint8Array): Address[];
+/**
+ * Filter VaultFees accounts by vault address (offset: 8)
+ */
+declare function filterVaultFeesByVaultMemcmp(accounts: AccountWithData[], vault: Address): Address[];
+/**
+ * Filter VaultFees accounts by fee calculation program (offset: 40)
+ */
+declare function filterVaultFeesByFeeCalcProgramMemcmp(accounts: AccountWithData[], feeCalcProgram: Address): Address[];
+/**
+ * Filter VaultFees accounts by LP recipient (offset: 72)
+ */
+declare function filterVaultFeesByLpRecipientMemcmp(accounts: AccountWithData[], lpRecipient: Address): Address[];
+/**
+ * Filter VaultFees accounts by manager recipient (offset: 104)
+ */
+declare function filterVaultFeesByManagerRecipientMemcmp(accounts: AccountWithData[], managerRecipient: Address): Address[];
+/**
+ * Filter VaultFees accounts by protocol recipient (offset: 136)
+ */
+declare function filterVaultFeesByProtocolRecipientMemcmp(accounts: AccountWithData[], protocolRecipient: Address): Address[];
+/**
+ * Filter VaultFees accounts by performance recipient (offset: 168)
+ */
+declare function filterVaultFeesByPerformanceRecipientMemcmp(accounts: AccountWithData[], performanceRecipient: Address): Address[];
+/**
+ * Filter Vault accounts by fee collection program (fixed offset)
+ */
+declare function filterByFeeCollectionProgramMemcmp(accounts: AccountWithData[], feeCollectionProgram: Address): Address[];
+
+declare function isValidVault(vault: any): vault is Account<Vault$1>;
+declare function filterByUnderlyingMint(vaults: any[], underlyingMint: Address): Account<Vault$1>[];
+declare function filterByManager(vaults: any[], manager: Address): Account<Vault$1>[];
+declare function filterByParentVault(vaults: any[], parentVault: Address): Account<Vault$1>[];
+declare function filterBySeedPrefix(vaults: any[], seedPrefix: string): Account<Vault$1>[];
+declare function filterValidVaults(vaults: any[]): Account<Vault$1>[];
+
+/**
+ * VaultFees Helper Filters (Fee Collection v2)
+ *
+ * Client-side filtering helpers for VaultFees accounts
+ */
+
+declare function isValidVaultFees(vaultFees: any): vaultFees is Account<VaultFees>;
+declare function filterValidVaultFees(vaultFees: any[]): Account<VaultFees>[];
+declare function filterVaultFeesByVault(vaultFees: any[], vault: Address): Account<VaultFees>[];
+declare function filterVaultFeesByFeeCalcProgram(vaultFees: any[], feeCalcProgram: Address): Account<VaultFees>[];
+declare function filterVaultFeesByLpRecipient(vaultFees: any[], lpRecipient: Address): Account<VaultFees>[];
+declare function filterVaultFeesByManagerRecipient(vaultFees: any[], managerRecipient: Address): Account<VaultFees>[];
+declare function filterVaultFeesByProtocolRecipient(vaultFees: any[], protocolRecipient: Address): Account<VaultFees>[];
+declare function filterVaultFeesByPerformanceRecipient(vaultFees: any[], performanceRecipient: Address): Account<VaultFees>[];
+/**
+ * Filter VaultFees by any recipient address
+ */
+declare function filterVaultFeesByAnyRecipient(vaultFees: any[], recipient: Address): Account<VaultFees>[];
+/**
+ * Filter VaultFees with unclaimed fees above threshold
+ */
+declare function filterVaultFeesWithAccumulatedFees(vaultFees: any[], minTotalFees?: bigint): Account<VaultFees>[];
+/**
+ * Filter VaultFees with claimable LP fees
+ */
+declare function filterVaultFeesWithClaimableLpFees(vaultFees: any[], minAmount?: bigint): Account<VaultFees>[];
+/**
+ * Filter VaultFees with claimable manager fees
+ */
+declare function filterVaultFeesWithClaimableManagerFees(vaultFees: any[], minAmount?: bigint): Account<VaultFees>[];
+/**
+ * Filter VaultFees with claimable protocol fees
+ */
+declare function filterVaultFeesWithClaimableProtocolFees(vaultFees: any[], minAmount?: bigint): Account<VaultFees>[];
+/**
+ * Filter VaultFees with claimable performance fees
+ */
+declare function filterVaultFeesWithClaimablePerformanceFees(vaultFees: any[], minAmount?: bigint): Account<VaultFees>[];
 
-export { APPROVE_DISCRIMINATOR, type ApproveInput, type ApproveInstruction, type ApproveInstructionData, type ApproveInstructionDataArgs, CREATE_TX_DISCRIMINATOR, type CreateTxAsyncInput, type CreateTxInput, type CreateTxInstruction, type CreateTxInstructionData, type CreateTxInstructionDataArgs, DROPPER_PROGRAM_ADDRESS, EXECUTE_TX_DISCRIMINATOR, type ExecuteTxAsyncInput, type ExecuteTxInput, type ExecuteTxInstruction, type ExecuteTxInstructionData, type ExecuteTxInstructionDataArgs, FeeCollectionFrequency, type FeeCollectionFrequencyArgs, HYRO_PROTOCOL_PROGRAM_ADDRESS, INITIALIZE_LIMIT_TRANSFER_DISCRIMINATOR, INITIALIZE_MULTISIG_DISCRIMINATOR, INITIALIZE_OWNERS_DISCRIMINATOR, INITIALIZE_VAULT_DISCRIMINATOR, type InitializeLimitTransferAsyncInput, type InitializeLimitTransferInput, type InitializeLimitTransferInstruction, type InitializeLimitTransferInstructionData, type InitializeLimitTransferInstructionDataArgs, type InitializeMultisigAsyncInput, type InitializeMultisigInput, type InitializeMultisigInstruction, type InitializeMultisigInstructionData, type InitializeMultisigInstructionDataArgs, type InitializeOwnersAsyncInput, type InitializeOwnersInput, type InitializeOwnersInstruction, type InitializeOwnersInstructionData, type InitializeOwnersInstructionDataArgs, type InitializeVaultAsyncInput, type InitializeVaultInput, type InitializeVaultInstruction, type InitializeVaultInstructionData, type InitializeVaultInstructionDataArgs, type ManagerFeeStructure, type ManagerFeeStructureArgs, POLICY_ALLOW_ANY_PROGRAM_ADDRESS, POLICY_CHALLENGES_PROGRAM_ADDRESS, POLICY_DENY_ALL_PROGRAM_ADDRESS, POLICY_LIMIT_TRANSFER_PROGRAM_ADDRESS, POLICY_MULTISIG_PROGRAM_ADDRESS, POLICY_OWNERS_PROGRAM_ADDRESS, type ParsedApproveInstruction, type ParsedCreateTxInstruction, type ParsedExecuteTxInstruction, type ParsedInitializeLimitTransferInstruction, type ParsedInitializeMultisigInstruction, type ParsedInitializeOwnersInstruction, type ParsedInitializeVaultInstruction, type ParsedTransferLamportsInstruction, Policy, TRANSFER_LAMPORTS_DISCRIMINATOR, type TransactionAccount, type TransactionAccountArgs, type TransferLamportsInput, type TransferLamportsInstruction, type TransferLamportsInstructionData, type TransferLamportsInstructionDataArgs, Vault, getApproveDiscriminatorBytes, getApproveInstruction, getApproveInstructionDataCodec, getApproveInstructionDataDecoder, getApproveInstructionDataEncoder, getCreateTxDiscriminatorBytes, getCreateTxInstruction, getCreateTxInstructionAsync, getCreateTxInstructionDataCodec, getCreateTxInstructionDataDecoder, getCreateTxInstructionDataEncoder, getExecuteTxDiscriminatorBytes, getExecuteTxInstruction, getExecuteTxInstructionAsync, getExecuteTxInstructionDataCodec, getExecuteTxInstructionDataDecoder, getExecuteTxInstructionDataEncoder, getFeeCollectionFrequencyCodec, getFeeCollectionFrequencyDecoder, getFeeCollectionFrequencyEncoder, getInitializeLimitTransferDiscriminatorBytes, getInitializeLimitTransferInstruction, getInitializeLimitTransferInstructionAsync, getInitializeLimitTransferInstructionDataCodec, getInitializeLimitTransferInstructionDataDecoder, getInitializeLimitTransferInstructionDataEncoder, getInitializeMultisigDiscriminatorBytes, getInitializeMultisigInstruction, getInitializeMultisigInstructionAsync, getInitializeMultisigInstructionDataCodec, getInitializeMultisigInstructionDataDecoder, getInitializeMultisigInstructionDataEncoder, getInitializeOwnersDiscriminatorBytes, getInitializeOwnersInstruction, getInitializeOwnersInstructionAsync, getInitializeOwnersInstructionDataCodec, getInitializeOwnersInstructionDataDecoder, getInitializeOwnersInstructionDataEncoder, getInitializeVaultDiscriminatorBytes, getInitializeVaultInstruction, getInitializeVaultInstructionAsync, getInitializeVaultInstructionDataCodec, getInitializeVaultInstructionDataDecoder, getInitializeVaultInstructionDataEncoder, getManagerFeeStructureCodec, getManagerFeeStructureDecoder, getManagerFeeStructureEncoder, getPolicyAccountPda, getShareMintPda, getShareSignerPda, getTransactionAccountCodec, getTransactionAccountDecoder, getTransactionAccountEncoder, getTransactionPda, getTransferLamportsDiscriminatorBytes, getTransferLamportsInstruction, getTransferLamportsInstructionDataCodec, getTransferLamportsInstructionDataDecoder, getTransferLamportsInstructionDataEncoder, getVaultPda, getVaultTokenAccountPda, parseApproveInstruction, parseCreateTxInstruction, parseExecuteTxInstruction, parseInitializeLimitTransferInstruction, parseInitializeMultisigInstruction, parseInitializeOwnersInstruction, parseInitializeVaultInstruction, parseTransferLamportsInstruction };
+export { APPROVE_DISCRIMINATOR, type AccountWithData, type ApproveInput, type ApproveInstruction, type ApproveInstructionData, type ApproveInstructionDataArgs, CHARGE_FEES_CPI_DISCRIMINATOR, CLAIM_FEES_DISCRIMINATOR, CREATE_TX_DISCRIMINATOR, type ChargeFeesCpiAsyncInput, type ChargeFeesCpiInput, type ChargeFeesCpiInstruction, type ChargeFeesCpiInstructionData, type ChargeFeesCpiInstructionDataArgs, type ClaimFeesAsyncInput, type ClaimFeesInput, type ClaimFeesInstruction, type ClaimFeesInstructionData, type ClaimFeesInstructionDataArgs, type CreateTxAsyncInput, type CreateTxInput, type CreateTxInstruction, type CreateTxInstructionData, type CreateTxInstructionDataArgs, DROPPER_PROGRAM_ADDRESS, EXECUTE_TX_DISCRIMINATOR, type ExecuteTxAsyncInput, type ExecuteTxInput, type ExecuteTxInstruction, type ExecuteTxInstructionData, type ExecuteTxInstructionDataArgs, FEE_COLLECTION_ALL_IN_ONE_PROGRAM_ADDRESS, FEE_COLLECTION_FRACTIONS_PROGRAM_ADDRESS, FEE_COLLECTION_PROGRAM_ADDRESS, FEE_COLLECTION_TIME_BASED_PROGRAM_ADDRESS, FIXED_OFFSET_FIELDS, type FeeAmounts, type FeeAmountsArgs, FeeCalcProgram, FeeCollectionFrequency, type FeeCollectionFrequencyArgs, type FeeCollectionV2Config, type FeeConfig, type FeeConfigArgs, FeeOperation, type FeeOperationArgs, type FeeRecipients, type FeeRecipientsArgs, FeeType, type FeeTypeArgs, type FractionFeeConfig, type FractionFeeConfigArgs, HYRO_PROTOCOL_PROGRAM_ADDRESS, INITIALIZE_DISCRIMINATOR, INITIALIZE_FRACTION_CONFIG_DISCRIMINATOR, INITIALIZE_LIMIT_TRANSFER_DISCRIMINATOR, INITIALIZE_MULTISIG_DISCRIMINATOR, INITIALIZE_OWNERS_DISCRIMINATOR, INITIALIZE_V2_DISCRIMINATOR, INITIALIZE_VAULT_DISCRIMINATOR, type InitializeAsyncInput, type InitializeFractionConfigAsyncInput, type InitializeFractionConfigInput, type InitializeFractionConfigInstruction, type InitializeFractionConfigInstructionData, type InitializeFractionConfigInstructionDataArgs, type InitializeInput, type InitializeInstruction, type InitializeInstructionData, type InitializeInstructionDataArgs, type InitializeLimitTransferAsyncInput, type InitializeLimitTransferInput, type InitializeLimitTransferInstruction, type InitializeLimitTransferInstructionData, type InitializeLimitTransferInstructionDataArgs, type InitializeMultisigAsyncInput, type InitializeMultisigInput, type InitializeMultisigInstruction, type InitializeMultisigInstructionData, type InitializeMultisigInstructionDataArgs, type InitializeOwnersAsyncInput, type InitializeOwnersInput, type InitializeOwnersInstruction, type InitializeOwnersInstructionData, type InitializeOwnersInstructionDataArgs, type InitializeV2AsyncInput, type InitializeV2Input, type InitializeV2Instruction, type InitializeV2InstructionData, type InitializeV2InstructionDataArgs, type InitializeVaultAsyncInput, type InitializeVaultInput, type InitializeVaultInstruction, type InitializeVaultInstructionData, type InitializeVaultInstructionDataArgs, type ManagerFeeStructure, type ManagerFeeStructureArgs, type MemcmpFilter, POLICY_ALLOW_ANY_PROGRAM_ADDRESS, POLICY_CHALLENGES_PROGRAM_ADDRESS, POLICY_DENY_ALL_PROGRAM_ADDRESS, POLICY_LIMIT_TRANSFER_PROGRAM_ADDRESS, POLICY_MULTISIG_PROGRAM_ADDRESS, POLICY_OWNERS_PROGRAM_ADDRESS, type ParsedApproveInstruction, type ParsedCreateTxInstruction, type ParsedExecuteTxInstruction, type ParsedInitializeInstruction, type ParsedInitializeLimitTransferInstruction, type ParsedInitializeMultisigInstruction, type ParsedInitializeOwnersInstruction, type ParsedInitializeVaultInstruction, type ParsedTransferLamportsInstruction, Policy, type RpcConfig, TRANSFER_LAMPORTS_DISCRIMINATOR, type TransactionAccount, type TransactionAccountArgs, type TransferLamportsInput, type TransferLamportsInstruction, type TransferLamportsInstructionData, type TransferLamportsInstructionDataArgs, UPDATE_RECIPIENTS_DISCRIMINATOR, type UpdateRecipientsAsyncInput, type UpdateRecipientsInput, type UpdateRecipientsInstruction, type UpdateRecipientsInstructionData, type UpdateRecipientsInstructionDataArgs, VAULT_ACCOUNT_OFFSETS, VAULT_FEES_ACCOUNT_OFFSETS, VAULT_FEES_ACCOUNT_SIZE, VAULT_FEES_FIELD_SIZES, VAULT_FIELD_SIZES, Vault, type VaultFeesFilter, type VaultFeesQueryResult, type VaultFilter, type VaultQueryResult, createAddressFilter, createDiscriminatorFilter, createMemcmpFilter, createPartialBytesFilter, createU16Filter, createU32Filter, createU64Filter, createU8Filter, encodeBase58, fetchProgramAccountAddresses, fetchProgramAccountsWithData, filterByFeeCollectionProgramMemcmp, filterByManager, filterByManagerMemcmp, filterByMemcmp, filterByMemcmpDynamic, filterByParentVault, filterByParentVaultMemcmp, filterBySeedPrefix, filterBySeedPrefixMemcmp, filterByUnderlyingMint, filterByUnderlyingMintMemcmp, filterValidVaultFees, filterValidVaults, filterVaultFeesByAnyRecipient, filterVaultFeesByFeeCalcProgram, filterVaultFeesByFeeCalcProgramMemcmp, filterVaultFeesByLpRecipient, filterVaultFeesByLpRecipientMemcmp, filterVaultFeesByManagerRecipient, filterVaultFeesByManagerRecipientMemcmp, filterVaultFeesByPerformanceRecipient, filterVaultFeesByPerformanceRecipientMemcmp, filterVaultFeesByProtocolRecipient, filterVaultFeesByProtocolRecipientMemcmp, filterVaultFeesByVault, filterVaultFeesByVaultMemcmp, filterVaultFeesWithAccumulatedFees, filterVaultFeesWithClaimableLpFees, filterVaultFeesWithClaimableManagerFees, filterVaultFeesWithClaimablePerformanceFees, filterVaultFeesWithClaimableProtocolFees, findAllVaultFees, findAllVaults, findChildVaults, findVaultFeesByAnyRecipient, findVaultFeesByFeeCalcProgram, findVaultFeesByLpRecipient, findVaultFeesByManagerRecipient, findVaultFeesByPerformanceRecipient, findVaultFeesByProtocolRecipient, findVaultFeesByVault, findVaultsByFeeCollectionProgram, findVaultsByManager, findVaultsByPolicyAccount, findVaultsByPolicyProgram, findVaultsByPolicyProgramV2, findVaultsBySeedPrefix, findVaultsByUnderlyingMint, getApproveDiscriminatorBytes, getApproveInstruction, getApproveInstructionDataCodec, getApproveInstructionDataDecoder, getApproveInstructionDataEncoder, getAuthorityOffset, getChargeFeesCpiDiscriminatorBytes, getChargeFeesCpiInstruction, getChargeFeesCpiInstructionAsync, getChargeFeesCpiInstructionDataCodec, getChargeFeesCpiInstructionDataDecoder, getChargeFeesCpiInstructionDataEncoder, getClaimFeesDiscriminatorBytes, getClaimFeesInstruction, getClaimFeesInstructionAsync, getClaimFeesInstructionDataCodec, getClaimFeesInstructionDataDecoder, getClaimFeesInstructionDataEncoder, getCreateTxDiscriminatorBytes, getCreateTxInstruction, getCreateTxInstructionAsync, getCreateTxInstructionDataCodec, getCreateTxInstructionDataDecoder, getCreateTxInstructionDataEncoder, getExecuteTxDiscriminatorBytes, getExecuteTxInstruction, getExecuteTxInstructionAsync, getExecuteTxInstructionDataCodec, getExecuteTxInstructionDataDecoder, getExecuteTxInstructionDataEncoder, getFeeAmountsCodec, getFeeAmountsDecoder, getFeeAmountsEncoder, getFeeCollectionFrequencyCodec, getFeeCollectionFrequencyDecoder, getFeeCollectionFrequencyEncoder, getFeeConfigCodec, getFeeConfigDecoder, getFeeConfigEncoder, getFeeOperationCodec, getFeeOperationDecoder, getFeeOperationEncoder, getFeeRecipientsCodec, getFeeRecipientsDecoder, getFeeRecipientsEncoder, getFeeTypeCodec, getFeeTypeDecoder, getFeeTypeEncoder, getFractionConfigPda, getFractionFeeConfigCodec, getFractionFeeConfigDecoder, getFractionFeeConfigEncoder, getInitializeDiscriminatorBytes, getInitializeFractionConfigDiscriminatorBytes, getInitializeFractionConfigInstruction, getInitializeFractionConfigInstructionAsync, getInitializeFractionConfigInstructionDataCodec, getInitializeFractionConfigInstructionDataDecoder, getInitializeFractionConfigInstructionDataEncoder, getInitializeInstruction, getInitializeInstructionAsync, getInitializeInstructionDataCodec, getInitializeInstructionDataDecoder, getInitializeInstructionDataEncoder, getInitializeLimitTransferDiscriminatorBytes, getInitializeLimitTransferInstruction, getInitializeLimitTransferInstructionAsync, getInitializeLimitTransferInstructionDataCodec, getInitializeLimitTransferInstructionDataDecoder, getInitializeLimitTransferInstructionDataEncoder, getInitializeMultisigDiscriminatorBytes, getInitializeMultisigInstruction, getInitializeMultisigInstructionAsync, getInitializeMultisigInstructionDataCodec, getInitializeMultisigInstructionDataDecoder, getInitializeMultisigInstructionDataEncoder, getInitializeOwnersDiscriminatorBytes, getInitializeOwnersInstruction, getInitializeOwnersInstructionAsync, getInitializeOwnersInstructionDataCodec, getInitializeOwnersInstructionDataDecoder, getInitializeOwnersInstructionDataEncoder, getInitializeV2DiscriminatorBytes, getInitializeV2Instruction, getInitializeV2InstructionAsync, getInitializeV2InstructionDataCodec, getInitializeV2InstructionDataDecoder, getInitializeV2InstructionDataEncoder, getInitializeVaultDiscriminatorBytes, getInitializeVaultInstruction, getInitializeVaultInstructionAsync, getInitializeVaultInstructionDataCodec, getInitializeVaultInstructionDataDecoder, getInitializeVaultInstructionDataEncoder, getManagerFeeStructureCodec, getManagerFeeStructureDecoder, getManagerFeeStructureEncoder, getManagerOffset, getParentVaultOffset, getPolicyAccountPda, getSeedLength, getShareMintOffset, getShareMintPda, getShareSignerPda, getTransactionAccountCodec, getTransactionAccountDecoder, getTransactionAccountEncoder, getTransactionPda, getTransferLamportsDiscriminatorBytes, getTransferLamportsInstruction, getTransferLamportsInstructionDataCodec, getTransferLamportsInstructionDataDecoder, getTransferLamportsInstructionDataEncoder, getUnderlyingMintOffset, getUpdateRecipientsDiscriminatorBytes, getUpdateRecipientsInstruction, getUpdateRecipientsInstructionAsync, getUpdateRecipientsInstructionDataCodec, getUpdateRecipientsInstructionDataDecoder, getUpdateRecipientsInstructionDataEncoder, getVaultFeesFeeCalcProgramOffset, getVaultFeesHighWaterMarkOffset, getVaultFeesLastUpdateOffset, getVaultFeesLpRecipientOffset, getVaultFeesManagerRecipientOffset, getVaultFeesPda, getVaultFeesPerformanceRecipientOffset, getVaultFeesProtocolRecipientOffset, getVaultFeesTotalCollectedOffset, getVaultFeesUnclaimedLpOffset, getVaultFeesUnclaimedManagerOffset, getVaultFeesUnclaimedPerformanceOffset, getVaultFeesUnclaimedProtocolOffset, getVaultFeesVaultOffset, getVaultPda, getVaultTokenAccountPda, isOptionSome, isValidVault, isValidVaultFees, parseApproveInstruction, parseCreateTxInstruction, parseExecuteTxInstruction, parseInitializeInstruction, parseInitializeLimitTransferInstruction, parseInitializeMultisigInstruction, parseInitializeOwnersInstruction, parseInitializeVaultInstruction, parseTransferLamportsInstruction, readOptionAddress, readVaultFeesAddress, readVaultFeesU64 };